Mongodb源码分析--内存文件映射(MMAP)

在Mongodb中,其使用了操作系统底层提供的内存映射机制,即MMAP。MMAP可以把磁盘文件的一部分或全部内容直接映射到内存,这样文件中的信息 位置就会在内存中有对应的地址空间,这时对文件的读写可以直接用指针来做,而不需要read/write函数了。同时操作系统会将数据刷新保存到磁盘上。 如下图:
       

     鉴于linux,window系统为mmap所提供的API大同小异(见下图)。这里仅以mongodb对window系统的mmap调用机制为例,来说 明一下其具体的实现方式,以及在mongodb启动时,客户端提交查询和插入操作请求时mongodb的mmap执行流程。
     

    上面类图中:
    MongoFile :定义了mongo文件对象常用操作,包括创建,关闭,设置名称,flushAll,获取MongoFile文件总尺寸等。
    MMF : 一个类型定义,其声明:typedef MemoryMappedFile MMF;    
    MongoMMF :为了便于journaling/durability操作,对MemoryMappedFile进行了一些封装(特别是对private views )
       
    下面着重看一下windows提供的mmap的常用API:
    MapViewOfFile (): 把文件数据映射到进程的地址空间
    CreateFileMapping () : 创建一个新的文件映射内核对象 
    FlushViewOfFile (): 强制系统将内存中修改过的数据重新写入磁盘映像,从而可以确保所有的数据更新能及时保存到磁盘
    CloseHandle (): 关闭文件映射对象和文件对象
    MapViewOfFileEx (): 将文件映射到指定的进程地址空间

    参数说明:

 

  1. MapViewOfFile(  
  2.     __in HANDLE hFileMappingObject,  /*hFileMappingObject是共享文件对象*/  
  3.     __in DWORD dwDesiredAccess, /*dwDesiredAccess是文件共享属性*/  
  4.     __in DWORD dwFileOffsetHigh, /*dwFileOffsetHigh是文件共享区的偏移地址*/  
  5.     __in DWORD dwFileOffsetLow, /*dwFileOffsetLow是文件共享区的偏移地址*/  
  6.     __in SIZE_T dwNumberOfBytesToMap /*dwNumberOfBytesToMap是共享数据长度*/  
  7.     );  
  8.      
  9. //winbase.h  
  10.     CreateFileMappingW(  
  11.     __in      HANDLE hFile,   /*hFile是创建共享文件的句柄*/  
  12.     __in_opt LPSECURITY_ATTRIBUTES lpFileMappingAttributes, /*lpFileMappingAttributes是文件共享的属性*/  
  13.     __in      DWORD flProtect,  /*flProtect是当文件映射时读写文件的属性*/  
  14.     __in      DWORD dwMaximumSizeHigh, /*是文件共享的大小高位字节*/  
  15.     __in      DWORD dwMaximumSizeLow, /*是文件共享的大小低位字节*/  
  16.     __in_opt LPCWSTR lpName /*lpName是共享文件对象名称*/  
  17.     );  
  18.     #ifdef UNICODE  
  19.     #define CreateFileMapping  CreateFileMappingW  
  20.     #else  
  21.     #define CreateFileMapping  CreateFileMappingA  
  22.     #endif // !UNICODE  
  23.   
  24.     FlushViewOfFile(  
  25.     __in LPCVOID lpBaseAddress, /*内存映射文件中的视图的一个字节的地址*/  
  26.     __in SIZE_T dwNumberOfBytesToFlush /*想要刷新的字节数*/  
  27.     );  
  28.   
  29.     MapViewOfFileEx(  
  30.     __in HANDLE hFileMappingObject,  /*共享文件对象*/  
  31.     __in DWORD dwDesiredAccess, /*文件共享属性*/  
  32.     __in DWORD dwFileOffsetHigh, /*文件共享区的偏移地址*/  
  33.     __in DWORD dwFileOffsetLow, /*文件共享区的偏移地址*/  
  34.     __in SIZE_T dwNumberOfBytesToMap /*共享数据长度*/  
  35.     __in_opt LPVOID lpBaseAddress /*指定映射文件映射对象的地址。如这个地址处没有足够的内存空间, 
  36.                                     那么对MapViewOfFileEx的调用会失效*/  
  37.     );  

 



    下面我们看一下mongodb如何使用上述API,来实现windows环境下对mongofile进行mmap操作的.

  1.  //mmap_win.cpp  
  2.   mutex mapViewMutex("mapView");//声明mapView的互斥体(mutex)对象  
  3.  ourbitset writable;  
  4.  /** unmapping 通知,以便清空 writable bits */  
  5.  void MemoryMappedFile::clearWritableBits(void *p) {  
  6.      for( unsigned i = ((size_t)p)/ChunkSize; i <= (((size_t)p)+len)/ChunkSize; i++ ) {  
  7.          writable.clear(i);  
  8.          assert( !writable.get(i) );  
  9.      }  
  10.  }  
  11.  MemoryMappedFile::MemoryMappedFile()  
  12.      : _flushMutex(new mutex("flushMutex")) {  
  13.      fd = 0;  
  14.      maphandle = 0;  
  15.      len = 0;  
  16.      created();  
  17.  }  
  18.  //关闭文件MemoryMappedFile  
  19.  void MemoryMappedFile::close() {  
  20.      for( vector<void*>::iterator i = views.begin(); i != views.end(); i++ ) {  
  21.          clearWritableBits(*i);  
  22.          UnmapViewOfFile(*i);  
  23.      }  
  24.      views.clear();  
  25.      if ( maphandle )  
  26.          CloseHandle(maphandle);//关闭文件映射对象和文件对象  
  27.      maphandle = 0;  
  28.      if ( fd )  
  29.          CloseHandle(fd);//关闭文件映射对象和文件对象  
  30.      fd = 0;  
  31.  }  
  32.  unsigned long long mapped = 0;  
  33.  //创建只读map  
  34.  void* MemoryMappedFile::createReadOnlyMap() {  
  35.      assert( maphandle );  
  36.      scoped_lock lk(mapViewMutex);  
  37.      void *p = MapViewOfFile(maphandle, FILE_MAP_READ, /*f ofs hi*/0, /*f ofs lo*/ 0, /*dwNumberOfBytesToMap 0 means to eof*/0);  
  38.      if ( p == 0 ) {  
  39.          DWORD e = GetLastError();  
  40.          log() << "FILE_MAP_READ MapViewOfFile failed " << filename() << " " << errnoWithDescription(e) << endl;  
  41.      }  
  42.      else {  
  43.          views.push_back(p);  
  44.      }  
  45.      return p;  
  46.  }  
  47.  //创建指定名称和大小的MapViewOfFile  
  48.  void* MemoryMappedFile::map(const char *filenameIn, unsigned long long &length, int options) {  
  49.      assert( fd == 0 && len == 0 ); // 仅能打开一次  
  50.      setFilename(filenameIn);  
  51.      /* big hack here: Babble uses db names with colons.  doesn't seem to work on windows.  temporary perhaps. */  
  52.      char filename[256];  
  53.      strncpy(filename, filenameIn, 255);  
  54.      filename[255] = 0;  
  55.      {  
  56.          size_t len = strlen( filename );  
  57.          for ( size_t i=len-1; i>=0; i-- ) {  
  58.              if ( filename[i] == '/' ||  
  59.                      filename[i] == '//' )  
  60.                  break;  
  61.              if ( filename[i] == ':' )  
  62.                  filename[i] = '_';  
  63.          }  
  64.      }  
  65.      updateLength( filename, length );//如果指定文件已存在,则用已存在的文件长度更新length值  
  66.      {  
  67.          DWORD createOptions = FILE_ATTRIBUTE_NORMAL;  
  68.          if ( options & SEQUENTIAL )  
  69.              createOptions |= FILE_FLAG_SEQUENTIAL_SCAN;//针对连续访问对文件缓冲进行优化选项  
  70.          DWORD rw = GENERIC_READ | GENERIC_WRITE;//普通读/写  
  71.          fd = CreateFile(//创建相关文件  
  72.                   toNativeString(filename).c_str(),//创建的文件名称  
  73.                   rw, // desired access  
  74.                   FILE_SHARE_WRITE | FILE_SHARE_READ, // share mode  
  75.                   NULL, // security  
  76.                   OPEN_ALWAYS, // create disposition  
  77.                   createOptions , // flags  
  78.                   NULL); // hTempl  
  79.          if ( fd == INVALID_HANDLE_VALUE ) {  
  80.              DWORD e = GetLastError();  
  81.              log() << "Create/OpenFile failed " << filename << " errno:" << e << endl;  
  82.              return 0;  
  83.          }  
  84.      }  
  85.      mapped += length;  
  86.      {  
  87.         //采用“读写文件数据”方式的页面保护属性            
  88.         DWORD flProtect = PAGE_READWRITE;  
  89.          //创建一个文件映射内核对象并告诉系统文件的尺寸以及访问文件的方式  
  90.          maphandle = CreateFileMapping(fd, NULL, flProtect,  
  91.                                        length >> 32 /*maxsizehigh*/,  
  92.                                        (unsigned) length /*maxsizelow*/,  
  93.                                        NULL/*lpName*/);  
  94.          if ( maphandle == NULL ) {  
  95.             // 先获取操作信息, 因为下面的log()要删除lasterror信息  
  96.              DWORD e = GetLastError();  
  97.              log() << "CreateFileMapping failed " << filename << ' ' << errnoWithDescription(e) << endl;  
  98.              close();  
  99.              return 0;  
  100.          }  
  101.      }  
  102.      void *view = 0;  
  103.      {  
  104.          scoped_lock lk(mapViewMutex);  
  105.          DWORD access = (options&READONLY)? FILE_MAP_READ : FILE_MAP_ALL_ACCESS;  
  106.          //把文件数据映射到进程的地址空间  
  107.          view = MapViewOfFile(maphandle, access, /*f ofs hi*/0, /*f ofs lo*/ 0, /*dwNumberOfBytesToMap 0 means to eof*/0);  
  108.      }  
  109.      if ( view == 0 ) {  
  110.          DWORD e = GetLastError();  
  111.          log() << "MapViewOfFile failed " << filename << " " << errnoWithDescription(e) << endl;  
  112.          close();  
  113.      }  
  114.      else {  
  115.          views.push_back(view);  
  116.      }  
  117.      len = length;  
  118.      return view;  
  119.  }  
  120.  class WindowsFlushable : public MemoryMappedFile::Flushable {  
  121.  public:  
  122.      WindowsFlushable( void * view , HANDLE fd , string filename , boost::shared_ptr<mutex> flushMutex )  
  123.          : _view(view) , _fd(fd) , _filename(filename) , _flushMutex(flushMutex)  
  124.      {}  
  125.      void flush() {  
  126.          if (!_view || !_fd)  
  127.              return;  
  128.          scoped_lock lk(*_flushMutex);  
  129.          // 强制系统将内存中修改过的数据重新写入磁盘映像,从而可以确保所有的数据更新能及时保存到磁盘。  
  130.          bool success = FlushViewOfFile(_view, 0 /*0表示全部mapping*/);  
  131.          if (!success) {  
  132.              int err = GetLastError();  
  133.              out() << "FlushViewOfFile failed " << err << " file: " << _filename << endl;  
  134.          }  
  135.          success = FlushFileBuffers(_fd);//刷新内部文件缓冲区的数据刷到磁盘上  
  136.          if (!success) {  
  137.              int err = GetLastError();  
  138.              out() << "FlushFileBuffers failed " << err << " file: " << _filename << endl;  
  139.          }  
  140.      }  
  141.      void * _view;  
  142.      HANDLE _fd;  
  143.      string _filename;  
  144.      boost::shared_ptr<mutex> _flushMutex;  
  145.  };  
  146.  //是否进行异步的flush操作(该操作会将修改过的数据部分或全部重新写入磁盘映像)  
  147.  void MemoryMappedFile::flush(bool sync) {  
  148.   uassert(13056, "Async flushing not supported on windows", sync);//windows系统不支持异步flush  
  149.      if( !views.empty() ) {  
  150.          WindowsFlushable f( views[0] , fd , filename() , _flushMutex);  
  151.          f.flush();  
  152.      }  
  153.  }  
  154. //预先刷数据操作,该方法确保这个对象是可以执行flush()操作,以便在调用该方法之后执行flush操作.  
  155. //参见mmap.cpp flushAll操作  
  156. MemoryMappedFile::Flushable * MemoryMappedFile::prepareFlush() {  
  157.      return new WindowsFlushable( views.empty() ? 0 : views[0] , fd , filename() , _flushMutex );  
  158.  }  
  159.  void MemoryMappedFile::_lock() {}  
  160.  void MemoryMappedFile::_unlock() {}      


    上面的代码比较简单,大家看一下注释就可以了,下面看一下mmf对于上面的MemoryMappedFile类实现是如何封装的,因为mmf会在journaling/durability这类场景下使用PrivateMap():    

  1.    //mongommf.cpp文件  
  2.     //构造PrivateMap  
  3.     void* MemoryMappedFile::createPrivateMap() {  
  4.         assert( maphandle );  
  5.         scoped_lock lk(mapViewMutex);  
  6.         //void *p = mapaligned(maphandle, len);  
  7.         void *p = MapViewOfFile(maphandle, FILE_MAP_READ, 0, 0, 0);  
  8.         if ( p == 0 ) {  
  9.             DWORD e = GetLastError();  
  10.             log() << "createPrivateMap failed " << filename() << " " << errnoWithDescription(e) << endl;  
  11.         }  
  12.         else {  
  13.             clearWritableBits(p);  
  14.             views.push_back(p);  
  15.         }  
  16.         return p;  
  17.     }  
  18.     //重新映射PrivateView  
  19.     void* MemoryMappedFile::remapPrivateView(void *oldPrivateAddr) {  
  20.         dbMutex.assertWriteLocked(); // short window where we are unmapped so must be exclusive  
  21.         // mapViewMutex确保在重新映射时获得相同的地址  
  22.         scoped_lock lk(mapViewMutex);  
  23.         //清空 writable bits  
  24.         clearWritableBits(oldPrivateAddr);  
  25.         //从进程的地址空间(oldPrivateAddr)撤消文件数据的映像  
  26.         if( !UnmapViewOfFile(oldPrivateAddr) ) {  
  27.             DWORD e = GetLastError();  
  28.             log() << "UnMapViewOfFile failed " << filename() << ' ' << errnoWithDescription(e) << endl;  
  29.             assert(false);  
  30.         }  
  31.         // 将文件映射到指定的进程地址空间  
  32.         void *p = MapViewOfFileEx(maphandle, FILE_MAP_READ, 0, 0,  
  33.                                   /*dwNumberOfBytesToMap 0 means to eof*//*len*/,  
  34.                                   oldPrivateAddr);  
  35.           
  36.         if ( p == 0 ) {  
  37.             DWORD e = GetLastError();  
  38.             log() << "MapViewOfFileEx failed " << filename() << " " << errnoWithDescription(e) << endl;  
  39.             assert(p);  
  40.         }  
  41.         assert(p == oldPrivateAddr);  
  42.         return p;  
  43.     }  
  44. #endif  
  45.     //重新映射PrivateView  
  46.     void MongoMMF::remapThePrivateView() {  
  47.         assert( cmdLine.dur );  
  48.         // todo 1.9 : it turns out we require that we always remap to the same address.  
  49.         // so the remove / add isn't necessary and can be removed  
  50.         privateViews.remove(_view_private);  
  51.         _view_private = remapPrivateView(_view_private);  
  52.         privateViews.add(_view_private, this);  
  53.     }  
  54.     ......  
  55.     //打开指定的文件并执行mmap操作  
  56.     bool MongoMMF::open(string fname, bool sequentialHint) {  
  57.         setPath(fname);  
  58.         _view_write = mapWithOptions(fname.c_str(), sequentialHint ? SEQUENTIAL : 0);  
  59.         return finishOpening();  
  60.     }  
  61.     //创建指定名称的文件并执行mmap操作  
  62.     bool MongoMMF::create(string fname, unsigned long long& len, bool sequentialHint) {  
  63.         setPath(fname);  
  64.         _view_write = map(fname.c_str(), len, sequentialHint ? SEQUENTIAL : 0);  
  65.         return finishOpening();  
  66.     }  
  67.     //创建PrivateMap并加载到privateViews集合中  
  68.     bool MongoMMF::finishOpening() {  
  69.         if( _view_write ) {  
  70.             if( cmdLine.dur ) {  
  71.                 _view_private = createPrivateMap();  
  72.                 if( _view_private == 0 ) {  
  73.                     massert( 13636 , "createPrivateMap failed (look in log for error)" , false );  
  74.                 }  
  75.                 privateViews.add(_view_private, this); // note that testIntent builds use this, even though it points to view_write then...  
  76.             }  
  77.             else {  
  78.                 _view_private = _view_write;  
  79.             }  
  80.             return true;  
  81.         }  
  82.         return false;  
  83.     }  
  84.     ......  
  85.     //从privateViews集合中移除当前 _view_private,并关闭文件映射对象和文件对象  
  86.     void MongoMMF::close() {  
  87.         {  
  88.             if( cmdLine.dur && _view_write/*actually was opened*/ ) {  
  89.                 if( debug )  
  90.                     log() << "closingFileNotication:" << filename() << endl;  
  91.                 dur::closingFileNotification();  
  92.             }  
  93.             privateViews.remove(_view_private);  
  94.         }  
  95.         _view_write = _view_private = 0;  
  96.         MemoryMappedFile::close();//关闭文件映射对象和文件对象  
  97.     }  

    mongodb完成了上面的工具类的声明定义之后,就会在前台使用这些类了,下面通过插入数据操作(之前主要流程我已在这篇文章 中有所描述)过程中,对上面类的使用来进行阐述.   

    首先需要说明的是,如果是首次在本地运行mongod,则不会在指定的数据库目录(dbpath 参数)下生成数据库文件,但如果有数据插入时,则会生成相应文件,这里可以理解为生成文件的过程就是mmap的创建过程。
    
    之前的文章中提到过,当客户端要插入记录时,则系统会根据客户端的操作枚举信息来调用相应的操作,这里它会执行instance.cpp 文件中的receivedInsert方法,并进而调用 pdfile.cpp 文件的 insert ()函数,而在该方法下有如下一段代码:

 
  1. DiskLoc DataFileMgr::insert(const char *ns, const void *obuf, int len, bool god, const BSONElement &writeId, bool mayAddIndex) {  
  2.  ......  
  3.        NamespaceDetails *d = nsdetails(ns);//获取ns的详细信息  
  4.        if ( d == 0 ) {  
  5.            addNewNamespaceToCatalog(ns);//向system catalog添加新的名空间,它会再次调用当前insert()方法  
  6.            
  7.            // 创建第一个数据库文件,方法位于database.cpp  
  8.            cc().database()->allocExtent(ns, Extent::initialSize(len), false);  
  9.  ......  
  10.  }  
 



    上面的allocExtent方法用于分配Extent要求的磁盘空间,其中Extent用于记录多个record记录信息,而record就是数据库中 的一条记录。这里可以将Extent看成是一个数据集合,但与我们通常所理解的"数据表"(datatable)有所差异,因为在同一个 namespace下可以有一个或多个extent(可以不连续),extent之间是一个双向链表结构,其通过cursor进行向前(forward) 或反转(reverse)的访问。有关这些内容,参见我之前写的这篇文章 。   

    言归正传,在上面的allocExtent方法中,会执行pdfile.cpp中的如下方法:

  
  1. //pdfile.cpp  
  2.     Extent* MongoDataFile::createExtent(const char *ns, int approxSize, bool newCapped, int loops) {  
  3.         .....  
  4.         int ExtentSize = approxSize <= header()->unusedLength ? approxSize : header()->unusedLength;  
  5.         DiskLoc loc;  
  6.         if ( ExtentSize < Extent::minSize() ) {//判断当前ExtentSize的大小  
  7.             ......  
  8.             //addAFile方法位于 database.cpp  
  9.             return cc().database()->addAFile( 0, true )->createExtent(ns, approxSize, newCapped, loops+1);  
  10.         .....  
  11.     }   

    最后在addAFile方法中,我们会看下如下代码段:

  1. //database.cpp  
  2.    MongoDataFile* Database::addAFile( int sizeNeeded, bool preallocateNextFile ) {  
  3.        int n = (int) files.size();  
  4.        MongoDataFile *ret = getFile( n, sizeNeeded );//调用下面的getFile方法  
  5.        .....  
  6.    }  
  7.    //database.cpp    
  8.    MongoDataFile* Database::getFile( int n, int sizeNeeded , bool preallocateOnly) {  
  9.        ......  
  10.        namespaceIndex.init();  
  11.        .....  
  12.    }  
  13.      
  14.    //namespace.cpp    
  15.    void NamespaceIndex::init() {  
  16.        ......  
  17.        unsigned long long len = 0;  
  18.        boost::filesystem::path nsPath = path();  
  19.        string pathString = nsPath.string();  
  20.        void *p = 0;  
  21.        if( MMF::exists(nsPath) ) {//使用本文前面提到的MMF类,判断数据库文件是否存在  
  22.            if( f.open(pathString, true) ) {//打开指定的文件并执行mmap操作  
  23.                len = f.length();  
  24.                if ( len % (1024*1024) != 0 ) {  
  25.                    log() << "bad .ns file: " << pathString << endl;  
  26.                    uassert( 10079 ,  "bad .ns file length, cannot open database", len % (1024*1024) == 0 );  
  27.                }  
  28.                p = f.getView();//返回mapview  
  29.            }  
  30.        }  
  31.        else {//不存在  
  32.            // use lenForNewNsFiles, we are making a new database  
  33.            massert( 10343, "bad lenForNewNsFiles", lenForNewNsFiles >= 1024*1024 );  
  34.            maybeMkdir();//创建相应目录(如不存在)  
  35.            unsigned long long l = lenForNewNsFiles;  
  36.            if( f.create(pathString, l, true) ) {//创建指定名称的文件并执行mmap操作  
  37.                getDur().createdFile(pathString, l); // always a new file  
  38.                len = l;  
  39.                assert( len == lenForNewNsFiles );  
  40.                p = f.getView();//返回mapview  
  41.            }  
  42.        }  
  43.        ......  
  44.    }  


    下面用一张时序图来大体回顾一下这一流程:
    

    在创建了该数据库文件及相应mmap操作之后,下面再重新启动mongod时,系统会通过构造client类的上下文对象 (context)方法来最终调用namespaceIndex.init()方法,其时序图如下,大家可以通过调试源码来难证这一流程:
    

    好了,今天的内容到这里就告一段落。

    参考链接:

             http://www.cnblogs.com/daizhj/archive/2011/03/30/1999699.html

             http://en.wikipedia.org/wiki/Mmap
             http://linux.about.com/library/cmd/blcmdl2_mmap.htm
             http://msdn.microsoft.com/en-us/library/aa366761.aspx
             http://hi.baidu.com/%B2%A4%B2%CB%B1%F9%B1%F9/blog/item/f6e6fb2561c0136a35a80f70.html

    原文链接:http://www.cnblogs.com/daizhj/archive/2011/04/25/mongos_mmap_source_code.html

    作者: daizhj, 代震军   
    微博: http://t.sina.com.cn/daizhj
    Tags: mongodb,c++,mmap

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值