mmapmgr.h
上传用户:zhongxx05
上传日期:2007-06-06
资源大小:33641k
文件大小:7k
源码类别:

Symbian

开发平台:

C/C++

  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  35. #ifndef _MMAPMGR_H_
  36. #define _MMAPMGR_H_
  37. #include "hxtypes.h"
  38. #include "hxcom.h"
  39. #include "hxbuffer.h"
  40. #include "hxslist.h"
  41. #include "hxengin.h"
  42. #include "hxcomm.h"
  43. #include "hxmap.h"
  44. struct IHXScheduler;
  45. struct IHXDescriptorRegistration;
  46. #define NUMBER_OF_REAP_BUCKETS 3
  47. #define MMAP_EXCEPTION                                  0xfffffff1
  48. #define MMAP_EOF_EXCEPTION   0xfffffff2
  49. #define NUM_PTES 128
  50. #if defined(_UNIX) || defined(_SYMBIAN)
  51. #define FILE_IDENTIFIER int
  52. #else
  53. #define FILE_IDENTIFIER HANDLE
  54. #endif
  55. #if defined _WIN32 || defined(HELIX_FEATURE_THREADSAFE_MEMMAP_IO)
  56. #define _MMM_NEED_MUTEX
  57. #endif
  58. class MMMCallback;
  59. class MemoryMapManager : public IUnknown
  60. {
  61. public:
  62.     MemoryMapManager(IUnknown* pContext, BOOL bDisableMemoryMappedIO = 0,
  63.     UINT32 ulChunkSize = 0);
  64.     virtual ~MemoryMapManager();
  65.     void*   OpenMap(FILE_IDENTIFIER Descriptor, IUnknown* pContext);
  66.     void    CloseMap(void* pHandle);
  67. #ifdef _WIN32
  68.     void    AttemptCloseMapNow(void* pHandle);
  69. #endif
  70.     void*   GetMMHandle(FILE_IDENTIFIER Descriptor);
  71.     UINT32  GetBlock(REF(IHXBuffer*) pBuffer, void* pHandle,
  72. UINT32 ulOffset, UINT32 ulSize);
  73.     static void DestroyFileInfo(void* pHandle);
  74.     STDMETHOD(QueryInterface)   (THIS_
  75.  REFIID riid,
  76.  void** ppvObj);
  77.     STDMETHOD_(ULONG32,AddRef)  (THIS);
  78.     STDMETHOD_(ULONG32,Release) (THIS);
  79.     void ProcessIdle(void);
  80.     MMMCallback*    m_pMMMCallback;
  81.     friend class MMMCallback;
  82.     struct _FileInfo;
  83.     struct _PageTableLevel1;
  84.     struct _PageTableEntry
  85.     {
  86. UINT32     ulPageRefCount;
  87. UINT32     ulSize;
  88. void*     pPage;
  89. /* Page is active (i.e. this entry is valid) */
  90. unsigned char     bActive : 1;
  91. /* Page should be reaped in CheckAndReapPageTableEntry() */
  92. unsigned char     bReapMe : 1;
  93. /* Page is dead and will be reaped by refcount==0 */
  94. unsigned char     bDeadPage : 1;
  95. UINT8     usReapListNumber : 8;
  96. LISTPOSITION     ReapListPosition;
  97. struct _FileInfo*     pInfo;
  98. struct _PageTableLevel1*    pParent;
  99. #ifdef _WIN32
  100. _PageTableEntry*     m_pNextPTE;
  101. _PageTableEntry*     m_pPrevPTE;
  102. #endif
  103.     };
  104.     struct _PageTableLevel1
  105.     {
  106. struct _PageTableEntry     pEntry[NUM_PTES];
  107. UINT32     ulNumberOfPageTableEntriesInUse;
  108. struct _PageTableLevel1**   pMyEntryInParentsPageTable;
  109.     };
  110. #define FILEINFO_KEY_SIZE   32
  111.     struct _FileInfo
  112.     {
  113. FILE_IDENTIFIER     Descriptor;
  114. UINT32          ulSize;
  115. UINT32          ulRefCount;
  116. UINT32          ulUseCount;
  117. char          pKey[FILEINFO_KEY_SIZE]; /* Flawfinder: ignore */
  118. MemoryMapManager*        pMgr;
  119. struct _PageTableLevel1*    pPageTable[NUM_PTES];
  120. IHXDescriptorRegistration* pDescReg;
  121. #ifdef _WIN32
  122. _PageTableEntry*     m_pPTEList;
  123. #endif
  124.     };
  125.     static BOOL CheckAndReapPageTableEntry(struct _PageTableEntry* pPTE);
  126. private:
  127.     class Buffer : public IHXBuffer
  128.     {
  129.     public:
  130. FAST_CACHE_MEM
  131. Buffer(struct _PageTableEntry* pEntry, UCHAR* pData, ULONG32 ulLength);
  132. virtual ~Buffer();
  133. STDMETHOD(QueryInterface)   (THIS_
  134.                                      REFIID riid,
  135.                                      void** ppvObj);
  136. STDMETHOD_(ULONG32,AddRef)  (THIS);
  137. STDMETHOD_(ULONG32,Release) (THIS);
  138. STDMETHOD(Get)              (THIS_
  139.                                     REF(UCHAR*) pData, 
  140.                                     REF(ULONG32) ulLength);
  141. STDMETHOD(Set)              (THIS_
  142.                                     const UCHAR* pData, 
  143.                                     ULONG32 ulLength);
  144. STDMETHOD(SetSize)          (THIS_
  145.                                     ULONG32 ulLength);
  146. STDMETHOD_(ULONG32,GetSize) (THIS);
  147. STDMETHOD_(UCHAR*,GetBuffer)(THIS);
  148.     private:
  149. LONG32     m_lRefCount;
  150. ULONG32     m_ulLength;
  151. UCHAR*     m_pData;
  152. #ifdef _WINDOWS
  153. _PageTableEntry*     m_pPTE;
  154. #else
  155. class MemoryMapManager::_PageTableEntry*   m_pPTE;
  156. #endif
  157.     };
  158.     void EmptyReapBuckets();
  159.     CHXSimpleList ReapBuckets[NUMBER_OF_REAP_BUCKETS];
  160.     CHXMapStringToOb* m_pDevINodeToFileInfoMap;
  161.     UINT8 m_ulActiveReapList;
  162.     IHXScheduler* m_pScheduler;
  163.     UINT32 m_ulChunkSize;
  164.     INT32 m_lRefCount;
  165.     CallbackHandle m_PendingHandle;
  166.     /*
  167.      * Buffer needs to call back into here
  168.      * on delete.
  169.      */
  170.     friend class MemoryMapManager::Buffer;
  171.     void LockMutex();
  172.     void UnlockMutex();
  173. #ifdef _MMM_NEED_MUTEX
  174.     IHXMutex* m_pMutex;
  175. #ifdef _DEBUG
  176.     BOOL m_bHaveMutex;
  177. #endif
  178. #endif
  179.     IHXFastAlloc* m_pFastAlloc;
  180.     BOOL m_bDisableMemoryMappedIO;
  181. };
  182. class MMMCallback : public IHXCallback
  183. {
  184. public:
  185.    
  186.     MemoryMapManager* m_pMMM;
  187.     CallbackHandle m_hPendingHandle;
  188. MMMCallback(MemoryMapManager* pMMM);
  189. ~MMMCallback();
  190.     /*
  191.      * IUnknown methods
  192.      */
  193.     STDMETHOD(QueryInterface) (THIS_
  194. REFIID riid,
  195. void** ppvObj);
  196.     STDMETHOD_(ULONG32,AddRef) (THIS);
  197.     STDMETHOD_(ULONG32,Release) (THIS);
  198.     /*
  199.      * IHXCallback methods
  200.      */
  201.     STDMETHOD(Func) (THIS);
  202. protected:
  203.     LONG32 m_lRefCount;
  204. };
  205. #ifdef _MMM_NEED_MUTEX
  206. /*
  207.  * If you are in here your os has one mmapmgr for the whole 
  208.  * server.
  209.  */
  210. inline void
  211. MemoryMapManager::LockMutex()
  212. {
  213.     AddRef();
  214.     if (m_pMutex)
  215.     {
  216. m_pMutex->Lock();
  217.     }
  218. #ifdef _DEBUG
  219.     m_bHaveMutex = TRUE;
  220. #endif
  221. }
  222. inline void
  223. MemoryMapManager::UnlockMutex()
  224. {
  225. #ifdef _DEBUG
  226.     m_bHaveMutex = FALSE;
  227. #endif
  228.     if (m_pMutex)
  229.     {
  230. m_pMutex->Unlock();
  231.     }
  232.     Release();
  233. }
  234. #else
  235. /*
  236.  * If you are in here then each server process has its
  237.  * own mmapmgr.
  238.  */
  239. inline void
  240. MemoryMapManager::LockMutex()
  241. {
  242. }
  243. inline void
  244. MemoryMapManager::UnlockMutex()
  245. {
  246. }
  247. #endif
  248. #endif /* _MMAPMGR_H_ */