Category

Development Platform
Home > SourceCode/Document > Communication-Mobile > Symbian > View Code
hxalloc.cpp
Package: 142_61_thumb_advanced.rar　[view]
Upload User: dangjiwu
Upload Date: 2013-07-19
Package Size: 42019k
Code Size: 25k
Category:

Symbian

Development Platform:

Visual C++

hxalloc.cpp：Code Content
  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 ***** */ 
  36. ///////////////////
  37. // include files
  38. #include "hxtypes.h"
  39. #include "hxmap.h"
  40. #include "hxalloc.h"
  41. #include "hxassert.h"
  42. #include "hxerrors.h"
  43. #include "hxheap.h" 
  44. #include "hxtick.h"
  45. #include "chxpckts.h"
  46. #include "hxstrutl.h"
  48. #if defined(_WINDOWS)
  49. #include "hlxclib/windows.h"
  50. #include <windowsx.h>
  51. #endif
  53. ///////////////////
  54. // private data
  55. #ifdef _DEBUG
  56. #undef HX_THIS_FILE
  57. static const char HX_THIS_FILE[] = __FILE__;
  58. #endif
  60. ///////////////////
  61. // private functions
  63. ///////////////////////////////////////////////////////////////////////////////
  64. // CHXMemoryBlock Implementation
  65. ///////////////////////////////////////////////////////////////////////////////
  66. CHXMemoryBlock::CHXMemoryBlock(CHXMemoryAllocator *pAllocator, BOOL bGlobalAlloc /* = FALSE */)
  67. {
  68. HX_ASSERT_VALID_PTR(pAllocator);
  70. m_pMemBuffer = NULL;
  71. m_MemBufferSize = 0;
  72. m_RefCount = 0;
  73. m_pAllocator = pAllocator;    
  74. m_bUseGlobalAlloc = bGlobalAlloc; // Determines whether we use GlobalAlloc or new
  75. }
  77. CHXMemoryBlock::~CHXMemoryBlock()
  78. {
  79. HX_ASSERT(m_RefCount == 0);
  80. HX_ASSERT(m_pMemBuffer == NULL);
  82. // clean up just in case
  83. if (m_pMemBuffer != NULL)
  84. {
  85. #if defined(_WINDOWS) && !defined(WIN32_PLATFORM_PSPC)
  86.             if (m_bUseGlobalAlloc)
  87.             {    
  88.                 GlobalFreePtr(m_pMemBuffer);
  89.             }
  90.             else
  91. #endif // _WINDOWS
  92.             {
  93. delete [] m_pMemBuffer;
  94.             }
  96.             m_pMemBuffer = NULL;
  97.             m_MemBufferSize = 0;
  98. }
  99. }
  101. BOOL CHXMemoryBlock::Allocate(ULONG32 uSize)
  102. {
  103. HX_ASSERT_VALID_PTR(m_pAllocator);
  105. if (uSize > 0)
  106. {   
  107. // On x86 systems we'd like the buffer to be aligned to "HXALLOC_BUFFER_ALIGNMENT" bytes.
  108. // So we'll allocate (uSize + HXALLOC_BUFFER_ALIGNMENT - 1) bytes, and move the returned
  109. // buffer pointer to the correct alignment
  110. // clean up just in case
  111. HX_ASSERT(NULL==m_pMemBuffer);
  112. if (m_pMemBuffer != NULL)
  113. {
  114. #if defined(_WINDOWS) && !defined(WIN32_PLATFORM_PSPC)
  115. if (m_bUseGlobalAlloc)
  116. {    
  117. GlobalFreePtr(m_pMemBuffer);
  118. }
  119. else
  120. #endif // _WINDOWS
  121. {
  122. delete [] m_pMemBuffer;
  123. }
  124.         m_pMemBuffer = NULL;
  125.     m_MemBufferSize = 0;
  126. }
  128. #if defined(_WINDOWS) && !defined(WIN32_PLATFORM_PSPC)
  129. if (m_bUseGlobalAlloc)
  130. {
  131. #if defined(_M_IX86)
  132.     m_pMemBuffer = (UCHAR*) GlobalAllocPtr(GMEM_MOVEABLE | GMEM_SHARE, uSize + HXALLOC_BUFFER_ALIGNMENT - 1);
  133. #else
  134.     m_pMemBuffer = (UCHAR*) GlobalAllocPtr(GMEM_MOVEABLE | GMEM_SHARE, uSize);
  135. #endif
  136. }
  137. else
  138. #endif
  139. {
  140. #if defined(_M_IX86)
  141. m_pMemBuffer = new UCHAR[uSize + HXALLOC_BUFFER_ALIGNMENT - 1];
  142. #else
  143. m_pMemBuffer = new UCHAR[uSize];
  144. #endif
  145. }
  147.                 HX_ASSERT(m_pMemBuffer);
  148. if (m_pMemBuffer != NULL)
  149. {
  150. m_MemBufferSize = uSize;
  151.                         return(TRUE);
  152. }
  153. }
  155. // we consider it a improper to allocate with 0 size.
  156. return(FALSE);
  157. }
  159. void CHXMemoryBlock::Free()
  160. {
  161. HX_ASSERT_VALID_PTR(m_pMemBuffer);
  163. if (m_pMemBuffer != NULL)
  164. {
  165. #if defined(_WINDOWS) && !defined(WIN32_PLATFORM_PSPC)
  166. if (m_bUseGlobalAlloc)
  167. {    
  168. GlobalFreePtr(m_pMemBuffer);
  169.         }
  170. else
  171. #endif // _WINDOWS
  172. {
  173.             delete [] m_pMemBuffer;
  174. }
  176. m_pMemBuffer = NULL;
  177. m_MemBufferSize = 0;
  178. }
  179. }
  181. HX_RESULT
  182. CHXMemoryBlock::QueryInterface(HX_IID iid, void** ppvObj)
  183. {
  184. // Do dynamic Cast
  185. if (iid == IID_IHXUnknown)
  186. {
  187. *ppvObj = (IHXUnknown *)this;
  188. }
  189. else
  190. {
  191. *ppvObj = NULL;
  192. }
  194. // Do lifetime control
  195. if (*ppvObj != NULL)
  196. {
  197. ((IHXUnknown *)*ppvObj)->AddRef();
  198. }
  200. return( (*ppvObj != NULL)?(HX_NO_ERROR):(HX_NO_INTERFACE));
  201. }
  203. ULONG32 CHXMemoryBlock::AddRef()
  204. {
  205. // shouldn't add ref empty blocks.
  206. HX_ASSERT_VALID_PTR(m_pMemBuffer);
  208. return InterlockedIncrement(&m_RefCount);
  209. }
  211. ULONG32 CHXMemoryBlock::Release()
  212. {
  213.     HX_ASSERT(m_RefCount != 0);
  215.     if(InterlockedDecrement(&m_RefCount) == 0)
  216.     {
  217. //  This is used instead of delete
  218. //  The Allocator puts the memory into a free pool and 
  219. //  deletes it when it is destroyed
  220. m_pAllocator->NotifyFreeBlock(this);
  221. return 0;
  222.     }
  224.     return m_RefCount;
  225. }
  227. ///////////////////////////////////////////////////////////////////////////////
  228. // CHXMemoryAllocator Implementation
  229. ///////////////////////////////////////////////////////////////////////////////
  230. HX_RESULT
  231. CHXMemoryAllocator::QueryInterface(HX_IID iid, void** ppvObj)
  232. {
  233. // Do dynamic Cast
  234. if (iid == IID_IHX20MemoryAllocator)
  235. {
  236. *ppvObj = (IHX20MemoryAllocator *)this;
  237. }
  238. else if (iid == IID_IHXUnknown)
  239. {
  240. *ppvObj = (IHXUnknown *)this;
  241. }
  242. else
  243. {
  244. *ppvObj = NULL;
  245. }
  247. // Do lifetime control
  248. if (*ppvObj != NULL)
  249. {
  250. ((IHXUnknown *)*ppvObj)->AddRef();
  251. }
  253. return( (*ppvObj != NULL)?(HX_NO_ERROR):(HX_NO_INTERFACE));
  255. }
  257. ULONG32 CHXMemoryAllocator::AddRef()
  258. {
  259.     return InterlockedIncrement(&m_ref);
  260. }
  262. ULONG32 CHXMemoryAllocator::Release()
  263. {
  264.     HX_ASSERT(m_ref != 0);
  265.     if(InterlockedDecrement(&m_ref) == 0)
  266.     {
  267. delete this;
  268. return 0;
  269.     }
  271.     return m_ref;
  272. }
  274. CHXMemoryAllocator::CHXMemoryAllocator(const char* szIdentifier, 
  275.                                        BOOL bThreadSafe, 
  276.                                        BOOL bUseGlobalAlloc, 
  277.                                        BOOL bEstimateFreeListSize, 
  278.                                        UINT32 uiPoolHistoryDepth)
  279.     : m_AllocCount(0)
  280.     , m_Count(0)
  281.     , m_uSize(0)
  282.     , m_ref(0)
  283.     , m_bThreadSafe(bThreadSafe)
  284.     , m_bUseGlobalAlloc(bUseGlobalAlloc)
  285.     , m_bEstimateFreeListSize(bEstimateFreeListSize)
  286.     , m_uiPoolHistoryDepth(uiPoolHistoryDepth)
  287.     , m_uiCurrentHistoryIndex(0)
  288. #ifndef WIN32
  289.     , m_pMutex(NULL)
  290. #endif // WIN32
  291. {
  292.     m_strIdentifier = szIdentifier;
  294. #ifdef WIN32
  295.     if (m_bThreadSafe) InitializeCriticalSection(&m_critsec);
  296.     if (ERROR_SUCCESS != RegOpenKeyEx(HKEY_CLASSES_ROOT,
  297.       OS_STRING("RVEncoderStats"),0,
  298.       KEY_ALL_ACCESS,&m_hkey))
  299.     {
  300.         m_hkey = NULL;
  301.     }
  302. #else // WIN32
  303.     if (bThreadSafe)
  304.     {
  305. #ifdef THREADS_SUPPORTED
  306. HXMutex::MakeMutex(m_pMutex);
  307. #else  // THREADS_SUPPORTED
  308. HXMutex::MakeStubMutex(m_pMutex);
  309. #endif  // THREADS_SUPPORTED
  310.     }
  311. #endif // WIN32
  313.     if (m_bEstimateFreeListSize && uiPoolHistoryDepth)
  314.     {
  315.         m_puiBufferUseHistory = new UINT32[uiPoolHistoryDepth]; 
  316.         memset(m_puiBufferUseHistory, 0, sizeof(m_puiBufferUseHistory));
  317.     }
  318.     else
  319.     {
  320.         m_puiBufferUseHistory = NULL;
  321.         m_bEstimateFreeListSize = FALSE;
  322.     }
  324.     WriteRuntimeStats();
  325. }
  328. CHXMemoryAllocator::CHXMemoryAllocator(BOOL bThreadSafe/*=FALSE*/, 
  329.                                        BOOL bUseGlobalAlloc/*=FALSE*/,
  330.                                        BOOL bEstimateFreeListSize, 
  331.                                        UINT32 uiPoolHistoryDepth)
  332.     : m_AllocCount(0)
  333.     , m_Count(0)
  334.     , m_uSize(0)
  335.     , m_ref(0)
  336.     , m_bThreadSafe(bThreadSafe)
  337.     , m_bUseGlobalAlloc(bUseGlobalAlloc)
  338.     , m_bEstimateFreeListSize(bEstimateFreeListSize)
  339.     , m_uiPoolHistoryDepth(uiPoolHistoryDepth)
  340.     , m_uiCurrentHistoryIndex(0)
  341. #ifndef WIN32
  342.     , m_pMutex(NULL)
  343. #endif // WIN32
  344. {
  345. #ifdef WIN32
  346. if (m_bThreadSafe) InitializeCriticalSection(&m_critsec);
  347.         m_hkey = NULL;
  348. #else // WIN32
  349. if (bThreadSafe)
  350. {
  351. #ifdef THREADS_SUPPORTED
  352.     HXMutex::MakeMutex(m_pMutex);
  353. #else  // THREADS_SUPPORTED
  354.     HXMutex::MakeStubMutex(m_pMutex);
  355. #endif  // THREADS_SUPPORTED
  356. }
  357. #endif // WIN32
  359.         if (m_bEstimateFreeListSize && uiPoolHistoryDepth)
  360.         {
  361.             m_puiBufferUseHistory = new UINT32[uiPoolHistoryDepth]; 
  362.             memset(m_puiBufferUseHistory, 0, sizeof(m_puiBufferUseHistory));
  363.         }
  364.         else
  365.         {
  366.             m_puiBufferUseHistory = NULL;
  367.             m_bEstimateFreeListSize = FALSE;
  368.         }
  369. }
  371. CHXMemoryAllocator::~CHXMemoryAllocator()
  372. {
  373.     WriteRuntimeStats();
  375.         // cleanup memory left by the user in the map
  376. POSITION currentMapNode = m_MemBlockMap.GetStartPosition();
  377. CHXMemoryBlock * pMemBlock;
  378. UCHAR * memPtr;
  380. // we should find the map empty.
  381. HX_ASSERT(m_MemBlockMap.IsEmpty());
  383. while(!m_MemBlockMap.IsEmpty())
  384. {
  385. m_MemBlockMap.GetNextAssoc(currentMapNode, (void *&)memPtr, (void *&)pMemBlock);
  387. if (pMemBlock != NULL)
  388. {
  389. // by releasing the memory the memblock and buffer
  390. // get cleaned up correctly.
  391. while ((UINT16)pMemBlock->Release())
  392. {
  393. ;
  394. }
  395. }
  396. }
  398. // need to clean up all the allocated nodes
  399. while(!m_freeList.IsEmpty())
  400. {
  401. CHXMemoryBlock * pMemBlock = (CHXMemoryBlock *)
  402. m_freeList.RemoveHead();
  404. pMemBlock->Free();
  405. delete pMemBlock;
  406. }
  408. #ifdef WIN32
  409. if (m_bThreadSafe) DeleteCriticalSection(&m_critsec);
  410.         if (m_hkey)
  411.             RegCloseKey(m_hkey);
  412. #else // WIN32
  413. HX_DELETE(m_pMutex);
  414. #endif // WIN32
  416.         if (m_puiBufferUseHistory)
  417.         {
  418.             delete [] m_puiBufferUseHistory; 
  419.         }
  420. }
  422. #ifdef RUNTIME_STATISTICS
  423. void CHXMemoryAllocator::WriteRuntimeStats()
  424. {
  425. #ifdef WIN32
  426.     if (m_hkey && m_strIdentifier.GetLength())
  427.     {
  428.         char szData[128]; /* Flawfinder: ignore */
  429.         SafeSprintf(szData,128,"Size:%d AllocCount:%d FreeList:%d Map:%d",
  430.             m_uSize,m_AllocCount,m_freeList.GetCount(),m_MemBlockMap.GetCount());
  431.         RegSetValueEx(m_hkey,m_strIdentifier,0,REG_SZ,(BYTE*)szData,strlen(szData)+1);
  432.     }
  433. #endif
  434. }
  435. #endif
  437. HX_RESULT CHXMemoryAllocator::SetProperties(HX20ALLOCPROPS* pRequest, 
  438. HX20ALLOCPROPS* pActual)
  439. {
  440. #ifdef WIN32
  441. if (m_bThreadSafe) EnterCriticalSection(&m_critsec);
  442. #else // WIN32
  443. if (m_pMutex)
  444. {
  445.     m_pMutex->Lock();
  446. }
  447. #endif // WIN32
  449. // if there are buffers allocated, then empyt the free list 
  450. // so we don't give anyone a buffer of the wrong size
  451. if (m_AllocCount != 0 && pRequest->uBufferSize != m_uSize)
  452. {
  453.             while (!m_freeList.IsEmpty())
  454.             {
  455.                 CHXMemoryBlock * pMemBlock = (CHXMemoryBlock *)
  456.                         m_freeList.RemoveHead();
  457.                 HX_ASSERT(pMemBlock);
  458.                 pMemBlock->Free();
  459.                 delete pMemBlock;
  460.                 m_AllocCount--;
  461.             }
  462. }
  464. pActual->uBufferSize = m_uSize = pRequest->uBufferSize;
  465. pActual->nNumBuffers = m_Count = pRequest->nNumBuffers;
  467.         WriteRuntimeStats();
  469. #ifdef WIN32
  470. if (m_bThreadSafe) LeaveCriticalSection(&m_critsec);
  471. #else // WIN32
  472. if (m_pMutex)
  473. {
  474.     m_pMutex->Unlock();
  475. }
  476. #endif // WIN32
  478. return(HXR_OK);
  479. }
  481. HX_RESULT CHXMemoryAllocator::GetProperties(HX20ALLOCPROPS* pProps)
  482. {
  483. pProps->uBufferSize = m_uSize;
  484. pProps->nNumBuffers = m_Count;
  486. return(HXR_OK);
  487. }
  489. UCHAR * CHXMemoryAllocator::GetPacketBuffer(IHXUnknown ** pPacketBuffer)
  490. {
  491. HX_ASSERT_VALID_PTR(this);
  492. HX_ASSERT_VALID_PTR(pPacketBuffer);
  493. UCHAR * pRetVal = NULL;
  494. *pPacketBuffer = NULL;
  496. #ifdef WIN32
  497. if (m_bThreadSafe) EnterCriticalSection(&m_critsec);
  498. #else // WIN32
  499. if (m_pMutex)
  500. {
  501.     m_pMutex->Lock();
  502. }
  503. #endif // WIN32
  505. if (m_uSize > 0)
  506. {
  507. // Get the next free buffer from the buffer pool
  508. if (!m_freeList.IsEmpty())
  509. {
  510. CHXMemoryBlock * pMemBlock;
  511. BOOL bRemoveFromHead = (HX_GET_BETTERTICKCOUNT() & 0x01) ? TRUE : FALSE;
  512. if (bRemoveFromHead)
  513. {
  514.     // Get the first buffer
  515.     pMemBlock = (CHXMemoryBlock *) m_freeList.RemoveHead();
  516. }
  517. else
  518. {
  519.     // Get the last buffer
  520.     pMemBlock = (CHXMemoryBlock *) m_freeList.RemoveTail();
  521. }
  523. // Add ref the block so we know we are using it
  524. pMemBlock->AddRef();
  526. // setup the map so we don't loose the block
  527. pRetVal = pMemBlock->GetSampleBase();
  528. m_MemBlockMap.SetAt(pRetVal, pMemBlock);
  529. *pPacketBuffer = (IHXUnknown *)pMemBlock;
  530. }
  532. // if we didn't find any blocks in the list allocate a new one
  533. if (pRetVal == NULL)
  534. {
  535. CHXMemoryBlock * pMemBlock = new CHXMemoryBlock(this, m_bUseGlobalAlloc);
  536.                         HX_ASSERT(pMemBlock);
  537.                         
  538. if (pMemBlock != NULL)
  539. {
  540. if (pMemBlock->Allocate(m_uSize))
  541. {
  542. pMemBlock->AddRef();
  543. pRetVal = pMemBlock->GetSampleBase();
  544. m_MemBlockMap.SetAt(pRetVal, pMemBlock);
  545. m_AllocCount++;
  546. *pPacketBuffer = (IHXUnknown *)pMemBlock;
  547. }
  548.                                 else
  549.                                 {
  550.                                     HX_ASSERT(FALSE);
  551.                                     delete pMemBlock;
  552.                                 }
  553. }
  554. }
  555. }
  557.         if (m_bEstimateFreeListSize)
  558.         {                
  559.             m_uiCurrentHistoryIndex = ++m_uiCurrentHistoryIndex % m_uiPoolHistoryDepth;
  560.             m_puiBufferUseHistory[m_uiCurrentHistoryIndex] = m_MemBlockMap.GetCount(); 
  561.         }
  563.         WriteRuntimeStats();
  565. #ifdef WIN32
  566. if (m_bThreadSafe) LeaveCriticalSection(&m_critsec);
  567. #else // WIN32
  568. if (m_pMutex)
  569. {
  570.     m_pMutex->Unlock();
  571. }
  572. #endif // WIN32
  574. return(pRetVal);
  575. }
  577. CHXMemoryBlock* CHXMemoryAllocator::PacketPtrToPacketObj(UCHAR * memPtr)
  578. {
  579.         HX_ASSERT(memPtr);
  580.         
  581. // find the instance pointer for the CHXMemoryBlock that 
  582. // ownes this memory buffer and AddRef the block
  583. CHXMemoryBlock * pMemBlock = NULL;
  585. #ifdef WIN32
  586. if (m_bThreadSafe) EnterCriticalSection(&m_critsec);
  587. #else // WIN32
  588. if (m_pMutex)
  589. {
  590.     m_pMutex->Lock();
  591. }
  592. #endif // WIN32
  594. m_MemBlockMap.Lookup(memPtr, (void *&)pMemBlock);
  596. #ifdef WIN32
  597. if (m_bThreadSafe) LeaveCriticalSection(&m_critsec);
  598. #else // WIN32
  599. if (m_pMutex)
  600. {
  601.     m_pMutex->Unlock();
  602. }
  603. #endif // WIN32
  605. return(pMemBlock);
  606. }
  608. UINT16 CHXMemoryAllocator::AddRefPacketPtr(UCHAR * memPtr)
  609. {
  610.         HX_ASSERT(memPtr);
  611.         
  612. // find the instance pointer for the CHXMemoryBlock that 
  613. // ownes this memory buffer and AddRef the block
  614. CHXMemoryBlock * pMemBlock;
  615. UINT16 uiRetVal = 0;
  617. #ifdef WIN32
  618. if (m_bThreadSafe) EnterCriticalSection(&m_critsec);
  619. #else // WIN32
  620. if (m_pMutex)
  621. {
  622.     m_pMutex->Lock();
  623. }
  624. #endif // WIN32
  626. if (m_MemBlockMap.Lookup(memPtr, (void *&)pMemBlock))
  627. {
  628. uiRetVal = (UINT16)pMemBlock->AddRef();
  629. }
  630. else
  631. {
  632. // shouldn't AddRef memory that doesn't exist...
  633. HX_ASSERT(FALSE);
  634. }
  636. #ifdef WIN32
  637. if (m_bThreadSafe) LeaveCriticalSection(&m_critsec);
  638. #else // WIN32
  639. if (m_pMutex)
  640. {
  641.     m_pMutex->Unlock();
  642. }
  643. #endif // WIN32
  645. return(uiRetVal);
  646. }
  648. UINT16 CHXMemoryAllocator::ReleasePacketPtr(UCHAR * memPtr)
  649. {
  650.         HX_ASSERT(memPtr);
  651. // find the instance pointer for the CHXMemoryBlock that 
  652. // ownes this memory buffer and AddRef the block
  653. UINT16 uiRetVal = 0;
  654. if (!memPtr)
  655. {
  656.     return(uiRetVal);
  657. }
  659. #ifdef WIN32
  660. if (m_bThreadSafe) EnterCriticalSection(&m_critsec);
  661. #else // WIN32
  662. if (m_pMutex)
  663. {
  664.     m_pMutex->Lock();
  665. }
  666. #endif // WIN32
  668. CHXMemoryBlock * pMemBlock;
  669. if (m_MemBlockMap.Lookup(memPtr, (void *&)pMemBlock))
  670. {
  671. uiRetVal = (UINT16)pMemBlock->Release();
  672. }
  673. else
  674. {
  675. // shouldn't AddRef memory that doesn't exist...
  676. HX_ASSERT(FALSE);
  677. }
  679.         WriteRuntimeStats();
  681. #ifdef WIN32
  682. if (m_bThreadSafe) LeaveCriticalSection(&m_critsec);
  683. #else // WIN32
  684. if (m_pMutex)
  685. {
  686.     m_pMutex->Unlock();
  687. }
  688. #endif // WIN32
  690. return(uiRetVal);
  691. }
  693. #ifdef XXXJEFFA_DEBUG
  694. UINT32 g_NextLogTime = 0;
  695. #endif
  697. void CHXMemoryAllocator::NotifyFreeBlock(CHXMemoryBlock * pMemBlock)
  698. {
  699.         HX_ASSERT(pMemBlock);
  700. #ifdef WIN32
  701. if (m_bThreadSafe) EnterCriticalSection(&m_critsec);
  702. #else // WIN32
  703. if (m_pMutex)
  704. {
  705.     m_pMutex->Lock();
  706. }
  707. #endif // WIN32
  709. // Remove the memory from the map since it's not going
  710. // to be considered valid anymore
  711. m_MemBlockMap.RemoveKey(pMemBlock->GetSampleBase());
  713.         UINT32 uiMaxRecentlyUsed = 0;
  714.         if (m_bEstimateFreeListSize)
  715.         {
  716.             for (UINT32 i = 0; i < m_uiPoolHistoryDepth; i++)
  717.             {
  718.                 if (m_puiBufferUseHistory[i] > uiMaxRecentlyUsed)
  719.                 {
  720.                     uiMaxRecentlyUsed = m_puiBufferUseHistory[i];   
  721.                 }
  722.             }
  723.         }
  725. // as long as this block is the right size we will
  726. // recycle it
  727. if (m_uSize == pMemBlock->GetLength() 
  728.     && ( (m_freeList.GetCount() < (int) m_Count) &&
  729.                  (m_bEstimateFreeListSize ? m_AllocCount <= uiMaxRecentlyUsed + 1 : TRUE)
  730.                )
  731.            )
  732. {
  733. BOOL bAddToTail = (HX_GET_BETTERTICKCOUNT() & 0x01) ? TRUE : FALSE;
  734. if (bAddToTail)
  735. {
  736.     m_freeList.AddTail(pMemBlock);
  737. }
  738. else
  739. {
  740.     m_freeList.AddHead(pMemBlock);
  741. }
  743. #ifdef XXXJEFFA_DEBUG
  744. if (!HXMM_ATINTERRUPT() && HX_GET_TICKCOUNT() > g_NextLogTime)
  745. {
  746. FILE* pFile = fopen("Boot Drive:Desktop Folder:log.txt", "a+t");
  747. if (pFile)
  748. {
  749. fprintf(pFile, "%pt%dt%dt%lun", this, m_freeList.GetCount(), m_uSize, (m_freeList.GetCount()*m_uSize));
  750. fclose(pFile);
  751. }
  752. g_NextLogTime = HX_GET_TICKCOUNT()  + 10000UL;
  753. }
  754. #endif
  755. }
  756. else
  757. {
  758. // if it doesn't go on the free block list 
  759. // then delete it
  760. pMemBlock->Free();
  761. delete pMemBlock;
  762. m_AllocCount--;
  763. }
  765. #ifdef WIN32
  766. if (m_bThreadSafe) LeaveCriticalSection(&m_critsec);
  767. #else // WIN32
  768. if (m_pMutex)
  769. {
  770.     m_pMutex->Unlock();
  771. }
  772. #endif // WIN32
  773. }
  775. ///////////////////////////////////////////////////////////////////////////////
  776. // CHXBufferMemoryAllocator Implementation
  777. ///////////////////////////////////////////////////////////////////////////////
  778. HX_RESULT
  779. CHXBufferMemoryAllocator::QueryInterface(HX_IID iid, void** ppvObj)
  780. {
  781.     HX_ASSERT(ppvObj);
  782.     // Do dynamic Cast
  783.     if (iid == IID_IHX20MemoryAllocator)
  784.     {
  785. *ppvObj = (IHX20MemoryAllocator *)this;
  786.     }
  787.     else if (iid == IID_IHXUnknown)
  788.     {
  789. *ppvObj = (IHXUnknown *)this;
  790.     }
  791.     else
  792.     {
  793. *ppvObj = NULL;
  794.     }
  796.     // Do lifetime control
  797.     if (*ppvObj != NULL)
  798.     {
  799. ((IHXUnknown *)*ppvObj)->AddRef();
  800.     }
  802.     return( (*ppvObj != NULL)?(HX_NO_ERROR):(HX_NO_INTERFACE));
  804. }
  806. ULONG32 CHXBufferMemoryAllocator::AddRef()
  807. {
  808.     HX_ASSERT(this);
  809.     return InterlockedIncrement(&m_ref);
  810. }
  812. ULONG32 CHXBufferMemoryAllocator::Release()
  813. {
  814.     HX_ASSERT(this);
  815.     HX_ASSERT(m_ref != 0);
  817.     if(InterlockedDecrement(&m_ref) == 0)
  818.     {
  819. delete this;
  820. return 0;
  821.     }
  822.     
  823.     return m_ref;
  824. }
  826. struct BufferBlock
  827. {
  828.     IHXBuffer* m_pBuf;
  829.     INT32 m_lRefCount;
  830. };
  832. CHXBufferMemoryAllocator::CHXBufferMemoryAllocator(BOOL bThreadSafe)
  833.     : m_Count(0)
  834.     , m_uSize(0)
  835.     , m_ref(0)
  836. #ifndef WIN32
  837.     , m_pMutex(NULL)
  838. #else // WIN32
  839.     , m_bThreadSafe(bThreadSafe)
  840. #endif // WIN32
  841. {
  842. #ifdef WIN32
  843.     if (m_bThreadSafe) InitializeCriticalSection(&m_critsec);
  844. #else // WIN32
  845.     if (bThreadSafe)
  846.     {
  847. #ifdef THREADS_SUPPORTED
  848. HXMutex::MakeMutex(m_pMutex);
  849. #else  // THREADS_SUPPORTED
  850. HXMutex::MakeStubMutex(m_pMutex);
  851. #endif  // THREADS_SUPPORTED
  852.     }
  853. #endif // WIN32
  854. }
  856. CHXBufferMemoryAllocator::~CHXBufferMemoryAllocator()
  857. {
  858.     // cleanup memory left by the user in the map
  859.     POSITION currentMapNode = m_BufMap.GetStartPosition();
  860.     BufferBlock* pBufBlock;
  861.     UCHAR* memPtr;
  862.     
  863.     // we should find the map empty.
  864.     HX_ASSERT(m_BufMap.IsEmpty());
  866.     while(!m_BufMap.IsEmpty())
  867.     {
  868. m_BufMap.GetNextAssoc(currentMapNode, (void *&)memPtr, (void *&)pBufBlock);
  870. if (pBufBlock != NULL)
  871. {
  872.     HX_ASSERT(FALSE);
  873.     HX_RELEASE(pBufBlock->m_pBuf);
  874.             HX_DELETE(pBufBlock);
  875. }
  876.     }
  878. #ifdef WIN32
  879.     if (m_bThreadSafe) DeleteCriticalSection(&m_critsec);
  880. #else // WIN32
  881.     HX_DELETE(m_pMutex);
  882. #endif // WIN32
  883. }
  885. HX_RESULT CHXBufferMemoryAllocator::SetProperties(HX20ALLOCPROPS* pRequest, 
  886. HX20ALLOCPROPS* pActual)
  887. {
  888.     pActual->uBufferSize = m_uSize = pRequest->uBufferSize;
  889.     pActual->nNumBuffers = m_Count = pRequest->nNumBuffers;
  890.     return HXR_OK;
  891. }
  893. HX_RESULT CHXBufferMemoryAllocator::GetProperties(HX20ALLOCPROPS* pProps)
  894. {
  895.     pProps->uBufferSize = m_uSize;
  896.     pProps->nNumBuffers = m_Count;
  898.     return HXR_OK;
  899. }
  901. UCHAR* CHXBufferMemoryAllocator::GetPacketBuffer(IHXUnknown ** pPacketBuffer)
  902. {
  903.     // XXXX JHUG we are not keeping a free list, should do that...
  904.     HX_ASSERT_VALID_PTR(this);
  905.     HX_ASSERT_VALID_PTR(pPacketBuffer);
  906.     UCHAR * pRetVal = NULL;
  907.     *pPacketBuffer = NULL;
  909.     if (m_uSize > 0)
  910.     {
  911.         BufferBlock* pBufBlock = new BufferBlock();
  912.         IHXBuffer* pBuffer = new CHXBuffer();
  913.         HX_ASSERT(pBufBlock && pBuffer);
  914.         if (pBuffer && pBufBlock)
  915.         {
  916.                 pBuffer->AddRef();
  918.                 pBufBlock->m_pBuf = pBuffer;
  919.                 pBufBlock->m_lRefCount = 1;
  921.                 if (SUCCEEDED(pBuffer->SetSize(m_uSize)))
  922.                 {
  923.                         pRetVal = pBuffer->GetBuffer();
  925. #ifdef WIN32
  926. if (m_bThreadSafe) EnterCriticalSection(&m_critsec);
  927. #else // WIN32
  928. if (m_pMutex)
  929. {
  930.     m_pMutex->Lock();
  931. }
  932. #endif // WIN32
  934.                         m_BufMap.SetAt(pRetVal, pBufBlock);
  936. #ifdef WIN32
  937. if (m_bThreadSafe) LeaveCriticalSection(&m_critsec);
  938. #else // WIN32
  939. if (m_pMutex)
  940. {
  941.     m_pMutex->Unlock();
  942. }
  943. #endif // WIN32
  945.                         *pPacketBuffer = (IHXUnknown *) pBuffer;
  946.                 }
  947.                 else
  948.                 {
  949.                     HX_RELEASE(pBuffer);
  950.                 }
  951.         }
  952.         else
  953.         {
  954.             HX_DELETE(pBufBlock);
  955.             HX_RELEASE(pBuffer);
  956.         }
  957.     }
  959.     return(pRetVal);
  960. }
  962. UCHAR* CHXBufferMemoryAllocator::AddBuffer(IHXBuffer* pBuf)
  963. {
  964.     HX_ASSERT(pBuf);
  966.     UCHAR* pMem = NULL;
  967.     if (pBuf)
  968.     {
  969.         BufferBlock* pBufBlock = new BufferBlock;
  970.         HX_ASSERT(pBufBlock);
  971.         if (pBufBlock)
  972.         {
  973.             pBuf->AddRef();
  974.             pBufBlock->m_pBuf = pBuf;
  975.             pBufBlock->m_lRefCount = 1;
  976.             pMem = pBuf->GetBuffer();
  977.     
  978. #ifdef WIN32
  979.     if (m_bThreadSafe) EnterCriticalSection(&m_critsec);
  980. #else // WIN32
  981.     if (m_pMutex)
  982.     {
  983. m_pMutex->Lock();
  984.     }
  985. #endif // WIN32
  987.             m_BufMap.SetAt(pMem, pBufBlock);
  989. #ifdef WIN32
  990.     if (m_bThreadSafe) LeaveCriticalSection(&m_critsec);
  991. #else // WIN32
  992.     if (m_pMutex)
  993.     {
  994. m_pMutex->Unlock();
  995.     }
  996. #endif // WIN32
  997.         }
  999.     }
  1001.     return pMem;
  1002. }
  1004. UINT16 CHXBufferMemoryAllocator::AddRefPacketPtr(UCHAR * memPtr)
  1005. {
  1006.     HX_ASSERT(memPtr);
  1007.     
  1008.     BufferBlock* pBlock = NULL;
  1009.     UINT16 uiRetVal = 0;
  1011. #ifdef WIN32
  1012.     if (m_bThreadSafe) EnterCriticalSection(&m_critsec);
  1013. #else // WIN32
  1014.     if (m_pMutex)
  1015.     {
  1016. m_pMutex->Lock();
  1017.     }
  1018. #endif // WIN32
  1020.     if (m_BufMap.Lookup(memPtr, (void *&)pBlock))
  1021.     {
  1022. uiRetVal = (UINT16)++(pBlock->m_lRefCount);
  1023.     }
  1024.     else
  1025.     {
  1026.  // shouldn't AddRef memory that doesn't exist...
  1027.  HX_ASSERT(FALSE);
  1028.     }
  1030. #ifdef WIN32
  1031.     if (m_bThreadSafe) LeaveCriticalSection(&m_critsec);
  1032. #else // WIN32
  1033.     if (m_pMutex)
  1034.     {
  1035. m_pMutex->Unlock();
  1036.     }
  1037. #endif // WIN32
  1039.     return uiRetVal;
  1040. }
  1042. UINT16 CHXBufferMemoryAllocator::ReleasePacketPtr(UCHAR * memPtr)
  1043. {
  1044.     UINT16 uiRetVal = 0;
  1045.     HX_ASSERT(memPtr);
  1046.     if (!memPtr)
  1047.     {
  1048. return uiRetVal;
  1049.     }
  1051. #ifdef WIN32
  1052.     if (m_bThreadSafe) EnterCriticalSection(&m_critsec);
  1053. #else // WIN32
  1054.     if (m_pMutex)
  1055.     {
  1056. m_pMutex->Lock();
  1057.     }
  1058. #endif // WIN32
  1060.     BufferBlock* pBlock = NULL;
  1061.     if (m_BufMap.Lookup(memPtr, (void *&)pBlock))
  1062.     {
  1063. uiRetVal = (UINT16)--(pBlock->m_lRefCount);
  1064. if (pBlock->m_lRefCount == 0)
  1065.         {
  1066.             HX_RELEASE(pBlock->m_pBuf);
  1067.             HX_DELETE(pBlock);
  1068.             m_BufMap.RemoveKey(memPtr);
  1069.         }
  1070.     }
  1071.     else
  1072.     {
  1073. // shouldn't Release memory that doesn't exist...
  1074. HX_ASSERT(FALSE);
  1075.     }
  1077. #ifdef WIN32
  1078.     if (m_bThreadSafe) LeaveCriticalSection(&m_critsec);
  1079. #else // WIN32
  1080.     if (m_pMutex)
  1081.     {
  1082. m_pMutex->Unlock();
  1083.     }
  1084. #endif // WIN32
  1086.     return uiRetVal;
  1087. }