如何扫描磁盘上真正庞大的文件？

Question

考虑到磁盘上的一个非常大的文件(可能超过4GB),我想扫描这个文件并计算出特定二进制模式的发生时间.

我的想法是:

1. 使用内存映射文件(CreateFileMap或boost mapped_file)将文件加载到虚拟内存.

2. 对于每个100MB映射内存,创建一个线程进行扫描并计算结果.

这可行吗？有没有更好的方法呢？

更新:
内存映射文件将是一个不错的选择,通过1.6GB文件扫描可以在11s内处理.

谢谢.

Answer 1

创建20个线程,每个假设处理大约100 MB的文件可能只会恶化性能,因为HD必须同时从几个不相关的位置读取.

高清性能在读取顺序数据时达到峰值.因此,假如你的大文件不是零散的,做的最好的事情很可能是只使用一个线程,并从阅读开始在几个(如4)MB的块结束.

但我知道什么.文件系统和缓存很复杂.做一些测试,看看什么效果最好.

Answer 2

虽然您可以使用内存映射,但您不必这样做.如果您以小块(例如每个1 MB)顺序读取文件,则文件将永远不会同时出现在内存中.

如果您的搜索代码实际上比您的硬盘慢,您仍然可以根据需要将块移交给工作线程.

Answer 3

多线程只会使速度变慢，除非您想扫描多个文件，每个文件都位于不同的硬盘驱动器上。否则你只是去寻找。

我使用内存映射文件编写了一个简单的测试函数，使用单线程扫描 1.4 Gb 文件大约需要 20 秒。对于两个线程，每个线程占用一半的文件（即使一个线程占用 1MB 块，另一个线程占用奇数），花费了 80 秒以上。

• 1 个线程：20015 毫秒
• 2 个线程：83985 毫秒

没错，2 个线程比 1 个线程慢四倍！

这是我使用的代码，这是单线程版本，我使用了 1 字节扫描模式，因此用于定位与跨式映射边界匹配的代码未经测试。

HRESULT ScanForPattern(LPCTSTR pszFilename, LPBYTE pbPattern, UINT cbPattern, LONGLONG * pcFound)
{
   HRESULT hr = S_OK;

   *pcFound = 0;
   if ( ! pbPattern || ! cbPattern)
      return E_INVALIDARG;

   //  Open the file
   //
   HANDLE hf = CreateFile(pszFilename,
                          GENERIC_READ,
                          FILE_SHARE_READ, NULL,
                          OPEN_EXISTING,
                          FILE_FLAG_SEQUENTIAL_SCAN,
                          NULL);

   if (INVALID_HANDLE_VALUE == hf)
      {
      hr = HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
      // catch an open file that exists but is in use
      if (ERROR_SHARING_VIOLATION == GetLastError())
         hr = HRESULT_FROM_WIN32(ERROR_SHARING_VIOLATION);
      return hr;
      }

   // get the file length
   //
   ULARGE_INTEGER  uli;
   uli.LowPart = GetFileSize(hf, &uli.HighPart);
   LONGLONG cbFileSize = uli.QuadPart;
   if (0 == cbFileSize)
      {
      CloseHandle (hf);
      return S_OK;
      }

   const LONGLONG cbStride = 1 * 1024 * 1024; // 1 MB stride.
   LONGLONG cFound  = 0;
   LPBYTE   pbGap = (LPBYTE) malloc(cbPattern * 2);

   //  Create a mapping of the file.
   //
   HANDLE hmap = CreateFileMapping(hf, NULL, PAGE_READONLY, 0, 0, NULL);
   if (NULL != hmap)
      {
      for (LONGLONG ix = 0; ix < cbFileSize; ix += cbStride)
         {
         uli.QuadPart = ix;
         UINT cbMap = (UINT) min(cbFileSize - ix, cbStride);
         LPCBYTE pb = (LPCBYTE) MapViewOfFile(hmap, FILE_MAP_READ, uli.HighPart, uli.LowPart, cbMap);
         if ( ! pb)
            {
            hr = HRESULT_FROM_WIN32(GetLastError());
            break;
            }
         // handle pattern scanning over the gap.
         if (cbPattern > 1 && ix > 0)
            {
            CopyMemory(pbGap + cbPattern - 1, &pb[0], cbPattern - 1);
            for (UINT ii = 1; ii < cbPattern; ++ii)
               {
               if (pb[ii] == pbPattern[0] && 0 == memcmp(&pb[ii], pbPattern, cbPattern))
                  {
                  ++cFound; 
                  // advance by cbPattern-1 to avoid detecting overlapping patterns
                  }
               }
            }

         for (UINT ii = 0; ii < cbMap - cbPattern + 1; ++ii)
            {
            if (pb[ii] == pbPattern[0] && 
                ((cbPattern == 1) || 0 == memcmp(&pb[ii], pbPattern, cbPattern)))
               {
               ++cFound; 
               // advance by cbPattern-1 to avoid detecting overlapping patterns
               }
            }
         if (cbPattern > 1 && cbMap >= cbPattern)
            {
            // save end of the view in our gap buffer so we can detect map-straddling patterns
            CopyMemory(pbGap, &pb[cbMap - cbPattern + 1], cbPattern - 1);
            }
         UnmapViewOfFile(pb);
         }

      CloseHandle (hmap);
      }
   CloseHandle (hf);

   *pcFound = cFound;
   return hr;
}