分块内存映射处理大文件-例子

最新推荐文章于 2024-08-10 18:26:45 发布
最新推荐文章于 2024-08-10 18:26:45 发布
阅读量4.6k 收藏 10
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hemmingway/article/details/8819516
版权

参考 ：http://user.qzone.qq.com/382164370/infocenter#!app=2&via=QZ.HashRefresh&pos=1363445766

内存映射文件可以用于3个不同的目的

• 系统使用内存映射文件，以便加载和执行. exe和DLL文件。这可以大大节省页文件空间和应用程序启动运行所需的时间。

• 可以使用内存映射文件来访问磁盘上的数据文件。这使你可以不必对文件执行I/O操作，并且可以不必对文件内容进行缓存。

• 可以使用内存映射文件，使同一台计算机上运行的多个进程能够相互之间共享数据。Windows确实提供了其他一些方法，以便在进程之间进行数据通信，但是这些方法都是使用内存映射文件来实现的，这使得内存映射文件成为单个计算机上的多个进程互相进行通信的最有效的方法。

使用内存映射数据文件 

若要使用内存映射文件，必须执行下列操作步骤：

1) 创建或打开一个文件内核对象，该对象用于标识磁盘上你想用作内存映射文件的文件。

2) 创建一个文件映射内核对象，告诉系统该文件的大小和你打算如何访问该文件。

3) 让系统将文件映射对象的全部或一部分映射到你的进程地址空间中。

当完成对内存映射文件的使用时，必须执行下面这些步骤将它清除：

1) 告诉系统从你的进程的地址空间中撤消文件映射内核对象的映像。

2) 关闭文件映射内核对象。

3) 关闭文件内核对象。


      文件操作是应用程序最为基本的功能之一，Win32 API和MFC均提供有支持文件处理的函数和类，常用的有Win32 API的CreateFile()、WriteFile()、ReadFile()和MFC提供的CFile类等。一般来说，以上这些函数可以满足大多数场合的要求，但是对于某些特殊应用领域所需要的动辄几十GB、几百GB、乃至几TB的海量存储，再以通常的文件处理方法进行处理显然是行不通的。所以可以使用内存文件映射来处理数据，网上也有铺天盖地的文章，但是映射大文件的时候又往往会出错，需要进行文件分块内存映射，这里就是这样的一个例子，教你如何把文件分块映射到内存。


//
// 该函数用于读取从CCD摄像头采集来的RAW视频数据当中的某一帧图像,
// RAW视频前596字节为头部信息，可以从其中读出视频总的帧数，
// 帧格式为1024*576*8
/* 
参数：
	pszPath：文件名
	dwFrame: 要读取第几帧，默认读取第2帧
*/
BOOL  MyFreeImage::LoadXRFrames(TCHAR *pszPath, DWORD dwFrame/* = 2*/ )
{

	// get the frames of X-Ray frames
	BOOL bLoop = TRUE;
	int	i;
	int width = 1024;
	int height = 576;
	int bitcount = 8;			//1, 4, 8, 24, 32

	//
	//Build bitmap header
	BITMAPFILEHEADER bitmapFileHeader; 
	BITMAPINFOHEADER bitmapInfoHeader; 
	BYTE			 rgbquad[4];			// RGBQUAD
	int				 index = 0;

	DWORD widthbytes = ((bitcount*width + 31)/32)*4;		//每行都是4的倍数  DWORD的倍数  这里是 576-
	TRACE1("widthbytes=%d\n", widthbytes);

	switch(bitcount) { 
	case 1: 
		index = 2; 
		bitmapFileHeader.bfOffBits = (DWORD)(sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + 2*4); 
		break; 
	case 4: 
		index = 16; 
		bitmapFileHeader.bfOffBits = (DWORD)(sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + 16*4); 
		break; 
	case 8: 
		index = 256; 
		bitmapFileHeader.bfOffBits = (DWORD)(sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + 256*sizeof(RGBQUAD)); 
		break; 
	case 24: 
	case 32: 
		index = 0; 
		bitmapFileHeader.bfOffBits = (DWORD)(sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER)); 
		break; 
	default:
		break;
	} 

	//构造Bitmap文件头BITMAPFILEHEADER 
	bitmapFileHeader.bfType = 0x4d42;    // 很重要的标志位  BM 标识
	bitmapFileHeader.bfSize = (DWORD)(bitmapFileHeader.bfOffBits + height * widthbytes);		//bmp文件长度  
	bitmapFileHeader.bfReserved1 = 0; 
	bitmapFileHeader.bfReserved2 = 0; 

	//构造Bitmap文件信息头BITMAPINFOHEADER 
	bitmapInfoHeader.biSize = sizeof(BITMAPINFOHEADER); 
	bitmapInfoHeader.biWidth = width; 
	bitmapInfoHeader.biHeight = height; 
	bitmapInfoHeader.biPlanes = 1; 
	bitmapInfoHeader.biBitCount = bitcount;
	bitmapInfoHeader.biCompression = BI_RGB;  // 未压缩
	bitmapInfoHeader.biSizeImage = height * widthbytes; 
	bitmapInfoHeader.biXPelsPerMeter = 3780; 
	bitmapInfoHeader.biYPelsPerMeter = 3780; 
	bitmapInfoHeader.biClrUsed = 0; 
	bitmapInfoHeader.biClrImportant = 0; 

	//创建BMP内存映像,写入位图头部
	BYTE *pMyBmp = new BYTE[bitmapFileHeader.bfSize];		// 我的位图pMyBmp
	BYTE *curr = pMyBmp;									// curr指针指示pMyBmp的位置
	memset(curr, 0, bitmapFileHeader.bfSize); 

	//写入头信息 
	memcpy(curr, &bitmapFileHeader,sizeof(BITMAPFILEHEADER));
	curr = pMyBmp + sizeof(BITMAPFILEHEADER); 
	memcpy(curr, &bitmapInfoHeader,sizeof(BITMAPINFOHEADER)); 
	curr += sizeof(BITMAPINFOHEADER);

	//构造调色板 , 当像素大于8位时，就没有调色板了。
	if(bitcount == 8) 
	{
		rgbquad[3] = 0;										//rgbReserved
		for(i = 0; i < index; i++) 
		{ 
			rgbquad[0] = rgbquad[1] = rgbquad[2] = i; 
			memcpy(curr, rgbquad, sizeof(RGBQUAD)); 
			curr += sizeof(RGBQUAD); 
		} 
	}else if(bitcount == 1) 
	{ 
		rgbquad[3] = 0;										//rgbReserved
		for(i = 0; i < index; i++) 
		{ 
			rgbquad[0] = rgbquad[1] = rgbquad[2] = (256 - i)%256; 
			memcpy(curr, rgbquad, sizeof(RGBQUAD)); 
			curr += sizeof(RGBQUAD); 
		} 
	} 

	//
	// 文件映射,从文件中查找图像的数据
	//Open the real file on the file system
	HANDLE hFile = CreateFile(pszPath, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
	if (hFile == INVALID_HANDLE_VALUE)
	{
		DWORD dwError = GetLastError();
		ATLTRACE(_T("MapFile, Failed in call to CreateFile, Error:%d\n"), dwError);
		SetLastError(dwError);
		bLoop = FALSE;
		return FALSE;
	}

	//Create the file mapping object
	HANDLE hMapping = CreateFileMapping(hFile, NULL, PAGE_READWRITE, 0, 0, NULL);
	if (hMapping == NULL)
	{
		DWORD dwError = GetLastError();
		ATLTRACE(_T("MapFile, Failed in call to CreateFileMapping, Error:%d\n"), dwError);

		// Close handle
		if (hFile != INVALID_HANDLE_VALUE)
		{
			CloseHandle(hFile);
			hFile = INVALID_HANDLE_VALUE;
		}

		SetLastError(dwError);
		bLoop = FALSE;
		return FALSE;
	}

	// Retrieve allocation  granularity
	SYSTEM_INFO sinf;
	GetSystemInfo(&sinf);
	DWORD dwAllocationGranularity = sinf.dwAllocationGranularity;

	// Retrieve file size
	// Retrieve file size
	DWORD dwFileSizeHigh;
	__int64 qwFileSize = GetFileSize(hFile, &dwFileSizeHigh);
	qwFileSize |= (((__int64)dwFileSizeHigh) << 32);

	CloseHandle(hFile);

	// Read Image
	__int64 qwFileOffset = 0;									// 偏移地址
	DWORD   dwBytesInBlock = 0,									// 映射的块大小
			dwStandardBlock = 100* dwAllocationGranularity ;	// 标准块大小
	DWORD   dwFrameSize = height*width;					        // 计算一帧图像的数据量，不包括头部信息
	DWORD   dwCurrentFrame = 1;

	dwBytesInBlock = dwStandardBlock;
	if (qwFileSize < dwStandardBlock)
		dwBytesInBlock  = (DWORD)qwFileSize;

	//Map the view  
	LPVOID lpData = MapViewOfFile(hMapping,  FILE_MAP_ALL_ACCESS, 
		static_cast<DWORD>((qwFileOffset & 0xFFFFFFFF00000000) >> 32), static_cast<DWORD>(qwFileOffset & 0xFFFFFFFF), dwBytesInBlock);
	if (lpData == NULL)
	{
		DWORD dwError = GetLastError();
		ATLTRACE(_T("MapFile, Failed in call to MapViewOfFile, Error:%d\n"), dwError);

		// Close Handle
		if (hMapping != NULL)
		{
			CloseHandle(hMapping);
			hMapping = NULL;
		}
		SetLastError(dwError);
		bLoop = FALSE;
		return FALSE;
	}


	BYTE  *lpBits = (BYTE *)lpData;
	BYTE  *curr1, *curr2, *lpEnd;
	curr1 = lpBits;							// seek to start
	curr2 = lpBits + 596;					// seek to first frame
	lpEnd = lpBits + dwBytesInBlock;		// seek to end

	// Read video infomation
	KMemDataStream streamData( curr1, dwBytesInBlock);
	ReadXRHeader(streamData);

	while(bLoop)
	{
		DWORD dwTmp = lpEnd - curr2;		//内存缓冲剩余的字节
		if ( dwTmp >= dwFrameSize )	
		{
			if(dwCurrentFrame == dwFrame)
			{
				memcpy(curr, curr2, dwFrameSize);
				bLoop = FALSE;
			}
			curr2 += dwFrameSize;
		}else		//内存中不够一帧数据
		{
			DWORD dwTmp2 = dwFrameSize - dwTmp;			// 一副完整的帧还需要dwTmp2字节

			if (dwCurrentFrame == dwFrame)
			{
				memcpy(curr, curr2, dwTmp);
				curr += dwTmp;
			}

                        
			//1、首先计算文件的偏移位置
                        qwFileOffset += dwBytesInBlock;
//2、 检查还可以映射多少字节的东东到内存里面if ( qwFileSize - qwFileOffset < dwStandardBlock)dwBytesInBlock = (DWORD)(qwFileSize - qwFileOffset);//3、重新映射文件UnmapViewOfFile(lpData);lpData = MapViewOfFile(hMapping, FILE_MAP_ALL_ACCESS,
 static_cast<DWORD>((qwFileOffset & 0xFFFFFFFF00000000) >> 32), static_cast<DWORD>(qwFileOffset & 0xFFFFFFFF), dwBytesInBlock);if (lpData == NULL) // 一定要检查，不然可能内存映射失败{DWORD dwError = GetLastError();ATLTRACE(_T("MapFile, Failed in call to MapViewOfFile, Error:%d\n"),
 dwError);SetLastError(dwError);bLoop = FALSE;break;}curr2 = lpBits = (BYTE *)lpData;lpEnd = lpBits + dwBytesInBlock; // seek to endif (dwCurrentFrame == dwFrame){memcpy(curr, curr2, dwTmp2);bLoop = FALSE;}curr2 += dwTmp2;}dwCurrentFrame++;if (dwCurrentFrame
 > ((LPKINFO)m_VideoInfoHeader)->frames ) // 到达文件末尾{bLoop = FALSE;}}//将内存流 pMyBmp 转为bitmapKMemDataStream stream(pMyBmp, bitmapFileHeader.bfSize, true);if(!LoadFromMemory(FIF_BMP, stream))return FALSE;//if (lpData != NULL){//FlushViewOfFile(lpData, 0);UnmapViewOfFile(lpData);lpData
 = NULL;}//remove the file mappingif (hMapping != NULL){CloseHandle(hMapping);hMapping = NULL;}return TRUE;}










                

        

        

    

  


    

      

        

            

              
                
                  hemmingway
                
              
            

            

                关注
              
            

        

        

          
      

      









                



	

		

			

				
					
Qt_大文件读写

				
			

			

				

					轩宇的博客
				

				

					06-26
					
					1674
					
				

			

		

		

			
				
探讨如何快速处理大的文件

			
		

	



                

              
                



	

		

			

				
					
qt的内存映射

				
			

			

				

					西门吹雪
				

				

					09-30
					
					3070
					
				

			

		

		

			
				
uchar *QFileDevice::map(qint64 offset, qint64 size, QFileDevice::MemoryMapFlags flags = NoOptions)

从偏移量开始将文件的大小字节映射到内存中。应该打开一个文件以使映射成功，但在映射内存之后，该文件不需要保持打开状态。当QFile被销毁或用这个对象打开一个新文件时，任何未被映射的映射都将被自动取消映射。
映射将具有与文件相同的打开模式（读和/或写），除非使用maprivateOption，在这种情况下，始终可以

			
		

	



                


  
              

                


	

		

			

				
					
大文件的分块读取

				
			

			

				

					梅晓强
				

				

					07-16
					
					887
					
				

			

		

		

			
				
using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.IO;//引用iO命名空间用到内存流using System.Threading;namespace Test{    class Program    {        static void Main(st

			
		

	





	

		

			

				
					
C++搭建框架，利用OpenGL、GDAL、Qt进行分块显示遥感影像

				
			

			

				

					小刀砍流氓的博客
				

				

					11-11
					
					3715
					
				

			

		

		

			
				
 

主要是利用C++搭建的框架，利用OpenGL、GDAL及Qt进行影像分块显示遥感影像，目前测试显示600M的资源3号卫星影像，仅仅需要15秒左右的时间。

此文章不对OpenGL以及GDAL做解释，如果对OpenGL和GDAL不熟悉，请自行查阅相应的文档。

利用OpenGL显示影像，那么第一步首先是要对OpenGL进行初始化。
void GeoGraphicsView::initializ...

			
		

	



		

			
		



	

		

			

				
					
Qt中内存映射技术：优雅处理大文件的艺术

					
最新发布

				
			

			

				

					weiweiqiao的专栏
				

				

					08-10
					
					331
					
				

			

		

		

			
				
在Qt中，处理大文件时直接加载整个文件到内存往往是不切实际的，这会导致程序运行缓慢甚至崩溃。内存映射（Memory Mapping）提供了一种有效的方法来处理这类问题，通过将文件的一部分或全部映射到进程的虚拟地址空间，使得对文件的访问就像访问内存一样高效。以下将详细介绍如何在Qt中使用内存映射来读取大文件。

			
		

	





	

		

			

				
					
Qt内存映射

				
			

			

				

					hscoder的博客
				

				

					06-03
					
					6547
					
				

			

		

		

			
				
最近在看代码的时候发现了Qt的内存映射，原来只知道MFC有内存映射机制，可以在读取大数据文件时节约读取的时间，原来Qt中也有相应的机制，其用法更简单，下面用一个小例子演示其用法#include <QtCore/QCoreApplication>
#include <QFile>
#include <QDebug>
#include <iostream>
#include <stdio.h>
int

			
		

	





	

		

			

				
					
QT 内存文件映射

				
			

			

				

					Maybe
				

				

					10-28
					
					5559
					
				

			

		

		

			
				
QFile file(fileName);
     file.open(QIODevice::ReadWrite );
     uchar* fpr = file.map(0, file.size()); //映射文件，注意这里的file.size()如果大于系统的虚拟内存，
                                                        

			
		

	





	

		

			

				
					
Qt——文件映射

					
热门推荐

				
			

			

				

					michael019的博客
				

				

					09-02
					
					1万+
					
				

			

		

		

			
				
概述：在处理数据量较大的文件时，往往需要使用文件映射技术，即虚拟内存。 通过文件映射之后，就可以像操作内存一样去直接操作文件。而不需要再调用文件读写方法了。原理:给磁盘上的文件分配地址，类似内存的地址一样，对虚拟出来的内存的操作就是对文件的操作了。 // virtual memory
    QFile file("../map.txt");
    file.resize(64*1024);

			
		

	





	

		

			

				
					
文件内存映射

				
			

			

				

					Jinuxwu的专栏
				

				

					08-07
					
					878
					
				

			

		

		

			
				
Java NIO中文件内存映射功能，将文件内容映射到内存中。这样大幅度提高对文件的读操作速度。代码如下
MappedByteBuffer buffer=null;  
int bufferSize = filesize;     
buffer = new RandomAccessFile( "/home/felix/file1","rw" )
				   .getChannel()

			
		

	





	

		

			

				
					
C语言实现大数据文件的内存映射机制

				
			

			

				

					08-31
				

			

		

		

			
				
内存映射文件是操作系统提供的一种高效访问大文件的技术，它允许程序将文件直接映射到进程的虚拟地址空间中，从而无需通过传统的文件I/O操作来读写文件。在C语言中，Windows API 提供了实现内存映射文件的功能。本文...

			
		

	





	

		

			

				
					
VC++以多种方式处理位图文件的例子.rar

				
			

			

				

					03-08
				

			

		

		

			
				
 - 对于大型位图，可以使用内存映射文件技术提高效率，直接操作文件映射到内存中的数据。  - 使用`CreateFileMapping`和`MapViewOfFile`函数创建和映射文件到内存。  6. **位图资源管理**：  - 记得释放加载的位图...

			
		

	





	

		

			

				
					
内存映射修改大文件_内存映射_MemoryFile_超大文件读写_

				
			

			

				

					10-03
				

			

		

		

			
				
实际工作中遇到超大文件读写时很多系统需要等待较长时间，给用户体验不佳。本文结合源码讲解了超大文件的内存映射读写方式。内存映射方式极大的提高了读写效率，提升用户体验感。

			
		

	





	

		

			

				
					
C实现的分块读取较大文件

				
			

			

				

					08-22
				

			

		

		

			
				
一个用C语言实现的分块读取文件程序，能有效的解决读取较大文件时间过久的问题

			
		

	





	

		

			

				
					
Linux 下内存映射与分块读取速度测试程序

				
			

			

				

					08-25
				

			

		

		

			
				
使用每行的字符个数统计和 MD5 两个算法比较内存映射和分块直接读取文件的速度。

			
		

	





	

		

			

				
					
内存映射 C++实例

				
			

			

				

					07-09
				

			

		

		

			
				
主要解决数据量很大的文件，直接全读进内存会导致内存资源不足，提出的一种解决方案！代码是自己写的，调试通过的

			
		

	





	

		

			

				
					
QT编写的基于内存共享方式的进程间通信

				
			

			

				

					03-25
				

			

		

		

			
				
QT编写的基于内存共享方式的进程间通信

			
		

	





	

		

			

				
					
大数据处理 - 分治/hash/排序

				
			

			

				

					DeveloperFire的博客
				

				

					02-20
					
					272
					
				

			

		

		

			
				
分而治之/hash映射: 针对数据太大，内存受限，只能是: 把大文件化成(取模映射)小文件，即16字方针: 大而化小，各个击破，缩小规模，逐个解决hash_map统计: 当大文件转化了小文件，那么我们便可以采用常规的hash_map(ip，value)来进行频率统计。堆/快速排序: 统计完了之后，便进行排序(可采取堆排序)，得到次数最多的IP。

			
		

	





	

		

			

				
					
大文件操作

				
			

			

				

					dawn1003的专栏
				

				

					06-26
					
					604
					
				

			

		

		

			
				
使用内存映射文件读写大文件
　　文件操作是应用程序最为基本的功能之一，Win32 API和MFC均提供有支持文件处理的函数和类。一般来说，这些函数可以满足大多数场合的要求，但是对于某些特殊应用领域所需要的动辄几十GB、几百GB、乃至几TB的海量存储，再以通常的文件处理方法进行处理显然是行不通的。使用字符串变量的方法不仅会加重内存的负担，而且会Unicode和ASCII码的转换会把你弄得焦头烂额。

			
		

	





	

		

			

				
					
内存映射修改大文件

				
			

			

				

					
				

				

					08-04
					
					500
					
				

			

		

		

			
				
 内存映射修改大文件四川师范大学 tacher下载源代码 本文介绍利用内存映射文件修改大文件:在大文件内存前加入一段数据，若要使用内存映射文件,必须执行下列操作步骤：创建或打开一个文件内核对象,该对象用于标识磁盘上你想用作内存映射文件的文件； 创建一个文件映射内核对象,告诉系统该文件的大小和你打算如何访问该文件； 让系统将文件映射对象的全部或一部分映射到你的进程地址

			
		

	





	

		

			

				
					
qt 文件 分块内存映射

				
			

			

				

					04-17
				

			

		

		

			
				
Qt提供了QFile类用于文件操作，而文件分块内存映射是指将文件的一部分内容映射到内存中进行读写操作。在Qt中，可以使用QFile和QFileDevice类的map()函数来实现文件分块内存映射。

具体步骤如下：
1. 打开文件：使用QFile类的open()函数打开需要进行内存映射的文件。
2. 创建内存映射：使用QFileDevice类的map()函数创建内存映射。该函数接受两个参数，第一个参数是映射的起始位置，第二个参数是映射的长度。可以使用QFileDevice::size()函数获取文件的大小作为映射的长度。
3. 获取映射的指针：使用QFileDevice类的data()函数获取映射的指针，可以通过该指针对文件内容进行读写操作。
4. 关闭文件和释放内存映射：使用QFile类的close()函数关闭文件，使用QFileDevice类的unmap()函数释放内存映射。

需要注意的是，文件分块内存映射适用于处理大型文件，可以提高读写效率。但是在使用过程中需要注意内存管理和同步机制，避免出现内存泄漏和数据不一致等问题。

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值