开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 其他游戏 > 查看源码
hkStlDebugMemory.h
资源名称：wow-313-source.rar　[点击查看]
上传用户：yisoukefu
上传日期：2020-08-09
资源大小：39506k
文件大小：22k
源码类别：

其他游戏

开发平台：

Visual C++

hkStlDebugMemory.h：源码内容
  1. /* 
  2.  * 
  3.  * Confidential Information of Telekinesys Research Limited (t/a Havok). Not for disclosure or distribution without Havok's
  4.  * prior written consent. This software contains code, techniques and know-how which is confidential and proprietary to Havok.
  5.  * Level 2 and Level 3 source code contains trade secrets of Havok. Havok Software (C) Copyright 1999-2009 Telekinesys Research Limited t/a Havok. All Rights Reserved. Use of this software is subject to the terms of an end user license agreement.
  6.  * 
  7.  */
  9. // The demoframework will use hkStlDebugMemory if the demos project properties
  10. // is given the "-c" (mem Check) option in 'Debugging->Command Arguments'.
  11. // hkStlDebugMemory will not operate in debug configuration as defined by Havok.
  12. // Debug configuration is an optimized build with line numbers enabled.
  13. // If there are memory leaks, their location and call stack
  14. // are printed to the debug window.
  16. #ifndef HK_STL_DEBUG_MEMORY_H
  17. #define HK_STL_DEBUG_MEMORY_H
  19. #include <Common/Base/Memory/Memory/hkMemory.h>
  20. #include <Common/Base/Memory/StackTracer/hkStackTracer.h>
  21. #include <Common/Base/Thread/CriticalSection/hkCriticalSection.h>
  23. #include <Common/Base/Memory/Memory/Debug/hkDebugMemory.h>
  24. #include <Common/Base/Memory/hkDebugMemorySnapshot.h>
  26. // use STL here so we avoid memory recursion.
  27. #include <map>
  28. #if defined(HK_PLATFORM_PS3_PPU) && (_HAS_EXCEPTIONS==0) && HK_CELL_SDK_VERSION < 0x190002
  29. void std::exception::_Raise() const { HK_BREAKPOINT(0); }
  30. #endif
  32. # define PTR_CLASS _FARQ
  34. template <typename T>
  35. class hkAllocator : public std::allocator<T>
  36. {
  37. public:
  39. hkAllocator() {}
  41. template <typename U> hkAllocator(const hkAllocator<U>&) {};
  43. char PTR_CLASS * _Charalloc(size_t size)
  44. {
  45. return (char PTR_CLASS *)malloc( size );
  46. }
  48. T PTR_CLASS * allocate(size_t count)
  49. {
  50. return (T PTR_CLASS *)malloc( count * sizeof(T) );
  51. }
  53. void deallocate(void PTR_CLASS * ptr, size_t )
  54. {
  55. free(ptr);
  56. }
  58. template <typename U>
  59. struct rebind { typedef hkAllocator<U> other; };
  60. };
  62. class hkDebugMemorySnapshot;
  64. /// Memory implementation to find common memory problems.
  65. /// hkStlDebugMemory finds leaks, multiple frees and underrun/overruns.
  66. /// hkStlDebugMemory always scrubs allocations in contrast to hkPoolMemory
  67. /// which only scrubs when HK_DEBUG is defined.
  68. /// See the userguide for more details.<p>
  70. class hkStlDebugMemory : public hkDebugMemory
  71. {
  72. public:
  73. typedef void (HK_CALL *OutputStringFunc)(const char* s, void* arg);
  75. static void HK_CALL defaultOutputStringFunc(const char* s, void* a);
  77. virtual void allocateChunkBatch(void** blocksOut, int nblocks, int nbytes,HK_MEMORY_CLASS cl )
  78. {
  79. for( int i = 0; i < nblocks; ++i )
  80. {
  81. blocksOut[i] = allocateChunk(nbytes, cl);
  82. }
  83. }
  84. virtual void deallocateChunkBatch(void** blocks, int nblocks, int nbytes,HK_MEMORY_CLASS cl )
  85. {
  86. for( int i = 0; i < nblocks; ++i )
  87. {
  88. deallocateChunk(blocks[i], nbytes, cl);
  89. }
  90. }
  92.         hkStlDebugMemory( OutputStringFunc outFunc = defaultOutputStringFunc, void* funcArg = HK_NULL, hkUint32 maxStackTrace = MAX_STACKTRACE);
  94.         ~hkStlDebugMemory();
  96. virtual void* allocateChunk(int nbytes, HK_MEMORY_CLASS cl);
  98. virtual void deallocateChunk(void*, int nbytes, HK_MEMORY_CLASS );
  100. virtual void preAllocateRuntimeBlock(int nbytes, HK_MEMORY_CLASS cl);
  102. virtual void* allocateRuntimeBlock(int nbytes, HK_MEMORY_CLASS cl);
  104. virtual void deallocateRuntimeBlock(void*, int nbytes, HK_MEMORY_CLASS cl);
  106. virtual void provideRuntimeBlock(void*, int nbytes, HK_MEMORY_CLASS cl);
  108. virtual void registerStaticAddress(void*, int nbytes);
  110. virtual void freeRuntimeBlocks();
  112. virtual void printStatistics(hkOstream* c);
  114. virtual hkBool isOk() const;
  116. virtual void* findBaseAddress(void* p, int nbytes);
  118. virtual void lockBlock(void* p);
  120. virtual void unlockBlock(void* p);
  122.         virtual void calculateStatistics(hkMemoryStatistics& stats);
  124.         virtual hkBool hasMemoryAvailable(hk_size_t size);
  126. virtual void setMaxStackTraceDepth(int maxDepth);
  128.         virtual void setLimitedMemoryListener(hkLimitedMemoryListener* listener)
  129.         {
  130.             hkCriticalSectionLock lock( &m_section );
  131.             m_listener = listener;
  132.         }
  134.         virtual hkLimitedMemoryListener* getLimitedMemoryListener() { return m_listener; }
  136.         virtual void setMemoryHardLimit(hk_size_t maxMemory)
  137.         {
  138.             hkCriticalSectionLock lock( &m_section );
  139.             if (maxMemory==0)
  140.             {
  141.                 m_hardLimit = maxMemory;
  142.                 return;
  143.             }
  144.             HK_ASSERT(0x3423434,!(maxMemory < hk_size_t(m_sysAllocsSize)));
  145.             if (maxMemory < hk_size_t(m_sysAllocsSize)) { return; }
  146.             HK_ASSERT(0x3423434,!(m_softLimit!=0&&maxMemory<m_softLimit));
  147.             if (m_softLimit!=0&&maxMemory<m_softLimit) { return; }
  148.             m_hardLimit = maxMemory;
  149.         }
  150.         virtual hk_size_t getMemoryHardLimit() { return m_hardLimit; }
  152.         virtual void setMemorySoftLimit(hk_size_t maxMemory)
  153.         {
  154.             hkCriticalSectionLock lock( &m_section );
  155.             if (maxMemory==0)
  156.             {
  157.                 m_softLimit = 0;
  158.                 return;
  159.             }
  160.             HK_ASSERT(0x3424344,!(m_hardLimit && maxMemory > m_hardLimit));
  161.             if (m_hardLimit && maxMemory > m_hardLimit) { return; }
  162.             m_softLimit = maxMemory;
  163.         }
  164.         virtual hk_size_t getMemorySoftLimit() { return m_softLimit; }
  166. protected:
  168. void printMemoryReport();
  170. virtual void* internalAllocate(int nbytes, HK_MEMORY_CLASS, int flags, int alignment=16);
  172. virtual void internalFree(void* p, int bytesToFree, int flags);
  174. void outputString(const char* s)
  175. {
  176. (*m_outputStringFunc)(s, m_outputStringArg);
  177. }
  179. public:
  181.             /// Overriding hkDebugMemory
  182.         virtual void setAllocationMark(int mark);
  183.         virtual int getAllocationMark() { return m_mark; }
  184.         virtual void getSnapshot(int mark,hkBool mask,hkDebugMemorySnapshot& snapshot);
  185.         virtual hkBool getPointerInfo(const void* ptr,PointerInfo& out);
  187. #if defined ( HK_PLATFORM_WIN32 ) && (HK_COMPILER_MSVC_VERSION >= 1400)
  188. typedef std::map<void*, PointerInfo, std::less<void*>, hkAllocator< std::pair <const void*, PointerInfo> > > Map;
  189. #else
  190. typedef std::map<void*, PointerInfo, std::less<void*> > Map;
  191. #endif
  193. protected:
  195. Map m_activePointers;
  196. OutputStringFunc m_outputStringFunc;
  197. void* m_outputStringArg;
  198. hkUint32 m_maxStackTrace;
  200. hkStackTracer m_tracer;
  201. mutable hkCriticalSection m_section;
  203.         int m_mark;
  205.         /// All the statistics of the same style as the old stats collector
  207.         int m_numSysAllocs;
  208.             /// The total number of bytes allocated by the system memory
  209.         int m_sysAllocsSize;
  210.             /// The current maximum of the total number of bytes allocated by the system memory
  211.         int m_sysAllocsHighMark;
  213.             /// The limited memory listener
  214.         hkLimitedMemoryListener* m_listener;
  216.             /// The total amount of memory we're allowing allocation on
  217.         hk_size_t m_softLimit;
  218.         hk_size_t m_hardLimit;
  219. };
  221. /// The implementation.
  222. /// The reason this is not inside of a .cpp file is so that there isn't a dependency in the lib with STL, which is
  223. /// what the implementation uses for block tracking.
  225. hkStlDebugMemory::hkStlDebugMemory( OutputStringFunc func, void* arg, hkUint32 maxStackTrace) :
  226. m_outputStringFunc(func),
  227. m_outputStringArg(arg),
  228. m_maxStackTrace(maxStackTrace),
  229.     m_section(0),
  230.     m_mark(0),
  231.     m_listener(HK_NULL),
  232.     m_softLimit(0),
  233.     m_hardLimit(0)
  234. {
  235.     m_numSysAllocs =0 ;
  236.     m_sysAllocsSize = 0;
  237.     m_sysAllocsHighMark = 0;
  238. }
  240. hkStlDebugMemory::~hkStlDebugMemory()
  241. {
  242. printMemoryReport();
  243. }
  245. void hkStlDebugMemory::setMaxStackTraceDepth(int maxDepth)
  246. {
  247. m_maxStackTrace = maxDepth;
  248. }
  250. hkBool
  251. hkStlDebugMemory::hasMemoryAvailable(hk_size_t size)
  252. {
  253.     hk_size_t limit = m_softLimit?m_softLimit:m_hardLimit;
  254.     if (limit == 0) return true;
  256.         /// Consider 4k as the minimum memory workspace
  257.     if (size ==0) size = 4*1024;
  258.     hk_size_t remaining = limit - m_sysAllocsSize;
  260. return size<remaining;
  261. }
  263. void
  264. hkStlDebugMemory::calculateStatistics(hkMemoryStatistics& stats)
  265. {
  266.     stats.m_allocated = m_sysAllocsSize;
  267.     stats.m_used = m_sysAllocsSize;
  268. // <js.todo.a use :: stylee
  269.     stats.m_available = stats.INFINITE_SIZE;
  270.     stats.m_totalAvailable = stats.INFINITE_SIZE;
  271. stats.m_largestBlock = stats.INFINITE_SIZE;
  273.     if (m_hardLimit != 0)
  274. {
  275.         stats.m_available = m_hardLimit - m_sysAllocsSize;
  276.         stats.m_totalAvailable = m_hardLimit - m_sysAllocsSize;
  277.         stats.m_largestBlock = m_hardLimit - m_sysAllocsSize;
  278. }
  279. }
  281. void // <js.todo.aaa change mask into enum and make it first parameter
  282. hkStlDebugMemory::getSnapshot( int mark, hkBool mask, hkDebugMemorySnapshot& snapshot )
  283. {
  284. hkCriticalSectionLock lock( &m_section );
  286.     snapshot.reset();
  288.     int numAllocs = 0;
  290. // Determine how many pointers pass the mark/mask filter.
  291. const hkStlDebugMemory::Map::iterator m_activePointersEnd = m_activePointers.end();
  292. if( mask && ( mark == 0 ) )
  293. {
  294. // If the mark is a mask with no bits set (0x0000), then all pointers pass the filter.
  295. numAllocs = int(m_activePointers.size());
  296. }
  297. else
  298. {
  299. // Gotta count them manually.
  300. for( hkStlDebugMemory::Map::iterator i = m_activePointers.begin(); i != m_activePointersEnd; ++i )
  301. {
  302. PointerInfo& inInfo = i->second;
  303. if (mask)
  304. {
  305. if (mark == 0 || (mark & inInfo.mark) !=0 ) numAllocs++;
  306. }
  307. else
  308. {
  309. if (inInfo.mark == mark) numAllocs++;
  310. }
  311. }
  312. }
  314. // If we have no objects to report, we're done
  315. if( numAllocs == 0 )
  316. {
  317. return;
  318. }
  320.     // Allocate the memory
  321.     snapshot.m_size = numAllocs;
  322.     snapshot.m_info = (PointerInfo*)hkSystemMalloc(sizeof(PointerInfo)*numAllocs,16);
  323.     snapshot.m_pointers = (void**)hkSystemMalloc(sizeof(void*)*numAllocs,16);
  325. // Fill up the records
  326. PointerInfo* outInfo = snapshot.m_info;
  327. void** ptr = snapshot.m_pointers;
  328.     for( hkStlDebugMemory::Map::iterator i = m_activePointers.begin(); i != m_activePointersEnd; ++i )
  329.     {
  330. PointerInfo& inInfo = i->second;
  331.         if (mask)
  332.         {
  333.             if (mark != 0 && (mark & inInfo.mark)==0) 
  334. {
  335. continue;
  336. }
  337.         }
  338.         else
  339.         {
  340.             if (inInfo.mark != mark) 
  341. {
  342. continue;
  343. }
  344.         }
  346.         *ptr = i->first;
  347.         *outInfo = i->second;
  349. outInfo++;
  350. ptr++;
  351.     }
  353. HK_ASSERT2( 0xdafec31b, outInfo == ( snapshot.m_info + snapshot.m_size ), "Allocated the wrong number of pointer info records." );
  354. }
  356. hkBool
  357. hkStlDebugMemory::getPointerInfo(const void* ptrIn,PointerInfo& out)
  358. {
  359. hkCriticalSectionLock lock( &m_section );
  360. void* ptr = const_cast<void*>(ptrIn);
  361.     hkStlDebugMemory::Map::iterator i = m_activePointers.find(ptr);
  362.     if ( i != m_activePointers.end())
  363.     {
  364.         out = i->second;
  365.         return true;
  366.     }
  367.     return false;
  368. }
  370. void hkStlDebugMemory::printMemoryReport()
  371. {
  372. hkCriticalSectionLock lock( &m_section );
  373. if( m_activePointers.size() != 0)
  374. {
  375.         hkStlDebugMemory::Map::iterator i = m_activePointers.begin();
  376.         hkStlDebugMemory::Map::iterator e = m_activePointers.end();
  378. outputString("**************************************************************n");
  379. outputString("* BEGIN MEMORY LEAK REPORT                                   *n");
  380. outputString("**************************************************************n");
  382. for( ; i!=e; ++i)
  383. {
  384. const PointerInfo& pinfo = i->second;
  385. char buf[256];
  386. hkString::snprintf(buf, 256, "n%i bytes leaked. Data at 0x%p. Stack trace follows:n", pinfo.numBytes, i->first );
  387. outputString(buf);
  388. // skip first two frames - they are always allocateX/internalAllocate
  389. m_tracer.dumpStackTrace( pinfo.stackTraces + 2, pinfo.numStackTrace - 2, m_outputStringFunc, m_outputStringArg );
  390. }
  392. outputString("**************************************************************n");
  393. outputString("* END MEMORY LEAK REPORT                                     *n");
  394. outputString("**************************************************************n");
  395. }
  396. else
  397. {
  398. outputString("**************************************************************n");
  399. outputString("* NO HAVOK MEMORY LEAKS FOUND                                *n");
  400. outputString("**************************************************************n");
  401. }
  402. }
  404. void hkStlDebugMemory::printStatistics(hkOstream* c)
  405. {
  406. hkCriticalSectionLock lock( &m_section );
  407. if(c)
  408. {
  409. c->printf("n");
  410. c->printf("************************************************************************************** *n");
  411. c->printf("* Debug memory doesn't support memory classes. Therefore no statistics available here. *n");
  412. c->printf("************************************************************************************** *n");
  413. c->printf("n");
  414. }
  415. }
  417. static void HK_CALL checkUnderOverrun(void* pfree, const hkDebugMemory::PointerInfo& info)
  418. {
  419. hkUint8* check = static_cast<hkUint8*>(info.realMem);
  420. int prepadBytes = (int)hkUlong( static_cast<char*>(pfree) - static_cast<char*>(info.realMem) );
  422. int i;
  423. for( i = 0; i < prepadBytes; ++i )
  424. {
  425. HK_ASSERT(0x6af0c498, check[i] == hkMemory::s_fillGuardArea);
  426. }
  428. check += prepadBytes + info.numBytes;
  430.     for( i = 0; i < hkStlDebugMemory::MEMORY_PADDING; ++i )
  431. {
  432. HK_ASSERT(0x431a98ae, check[i] == hkMemory::s_fillGuardArea);
  433. }
  434. }
  436. void hkStlDebugMemory::setAllocationMark(int mark)
  437. {
  438.     hkCriticalSectionLock lock( &m_section );
  439.     m_mark = mark;
  440. }
  442. void* hkStlDebugMemory::internalAllocate(int nbytes, HK_MEMORY_CLASS, int flags, int alignment )
  443. {
  444. if( nbytes )
  445. {
  446. hkCriticalSectionLock lock( &m_section );
  448.         if (m_hardLimit&&m_sysAllocsSize + hk_size_t(nbytes) > m_hardLimit)
  449.         {
  450.                 /// Say we can't allocate
  451.             if (m_listener)
  452.             {
  453.                 m_listener->cannotAllocate(this,nbytes);
  454.                 /// See if the callback helped... if not we fail
  455.                 if (m_sysAllocsSize + hk_size_t(nbytes) > m_hardLimit)
  456.                 {
  457.                     /// Inform we failed
  458.                     m_listener->allocationFailure(this,nbytes);
  459.                     /// Return NULL
  460.                     return HK_NULL;
  461.                 }
  462.             }
  463.             else
  464.             {
  465.                 // We failed
  466.                 return HK_NULL;
  467.             }
  468.         }
  470. PointerInfo pointerinfo;
  471. pointerinfo.numStackTrace = m_tracer.getStackTrace(pointerinfo.stackTraces, m_maxStackTrace);
  472. pointerinfo.numBytes = nbytes;
  473. pointerinfo.flags = flags;
  474.         pointerinfo.mark = m_mark;
  476. HK_ASSERT( 0x1be63280, MEMORY_PADDING >= 4 );
  477. HK_ASSERT( 0x1be63281, (MEMORY_PADDING % sizeof(int)) == 0 );
  478. HK_ASSERT( 0x1be63282, (alignment % sizeof(int)) == 0 );
  480. // allocate a little more (MEMORY_PADDING) at each end
  481. hk_size_t postpad = MEMORY_PADDING;
  482. // if alignment greater than padding is requested we need to be careful
  483. hk_size_t prepad = (MEMORY_PADDING >= alignment) ? MEMORY_PADDING : alignment;
  484. pointerinfo.realMem = hkSystemMalloc( int(nbytes + prepad + postpad), alignment);
  485. char* realMem = static_cast<char*>(pointerinfo.realMem);
  487. // scrub memory
  488. hkString::memSet( realMem, s_fillGuardArea, int(prepad) );
  489. hkString::memSet( realMem + prepad, s_fillReturnedToUser, nbytes );
  490. hkString::memSet( realMem + prepad + nbytes, s_fillGuardArea, int(postpad) );
  492. //
  493. /////
  494. //char* start = realMem + prepad;
  495. //char* end   = start + nbytes;
  497. //char* start4 = (char*)HK_NEXT_MULTIPLE_OF(4, hkUlong(start));
  498. //char* end4   = (char*)HK_NEXT_MULTIPLE_OF(4, hkUlong(end+1)) - 4;
  500. //start4 = hkMath::min2(start4, end);
  501. //end4   = hkMath::max2(end4, start);
  503. //HK_ASSERT2(0xad8750dd, (start4 <= end4) ^ ((hkUlong(start4) & 0x3) || (hkUlong(end4) & 0x3)), "Hmm");
  505. //if (start4 <= end4)
  506. //{
  507. // hkString::memSet(start, s_fillReturnedToUser, start4-start);
  508. // hkReal max = HK_REAL_MAX; or use nans
  509. // hkString::memSet4(start4, (int&)(max), (end4-start4)>>2);
  510. // hkString::memSet(end4, s_fillReturnedToUser, end-end4);
  511. //}
  512. //else
  513. //{
  514. // hkString::memSet( realMem + prepad, s_fillReturnedToUser, nbytes );
  515. //}
  516. /////
  518. void* memory = realMem + prepad;
  519. m_activePointers[memory] = pointerinfo;
  521. m_numSysAllocs += 1;
  522. m_sysAllocsSize += nbytes;
  523. if( m_sysAllocsSize > m_sysAllocsHighMark )
  524. {
  525. m_sysAllocsHighMark = m_sysAllocsSize;
  526. }
  528. return memory;
  529. }
  530. else
  531. {
  532. return HK_NULL;
  533. }
  534. }
  536. void hkStlDebugMemory::internalFree(void* pfree, int bytesToFree, int flags)
  537. {
  538. hkCriticalSectionLock lock( &m_section );
  541.     hkStlDebugMemory::Map::iterator i = m_activePointers.find(pfree);
  542. HK_ASSERT2( 0x356976c1, i != m_activePointers.end(), "Freeing junk pointer");
  543. const PointerInfo& info = i->second;
  545. HK_ASSERT2( 0xaf53fe12, info.m_lockCount <= 0, "Freeing locked memory block.");
  546. HK_ASSERT2( 0x5861b912, (info.flags & MEM_ALIGNED) == (flags & MEM_ALIGNED), "Mismatched aligned methods");
  547. HK_ASSERT2( 0x5861b913, (info.flags & MEM_CHUNK) == (flags & MEM_CHUNK), "Mismatched chunk methods");
  548. if(bytesToFree == -1)
  549. {
  550. HK_ASSERT2( 0x5861b911, (flags & MEM_CHUNK) == 0, "Calling deallocate on a chunk");
  551. }
  552. else
  553. {
  554. HK_ASSERT2( 0x743ce000, info.numBytes == bytesToFree, "Freeing chunk of wrong size");
  555. }
  557. checkUnderOverrun(pfree, info);
  558. { // scrub area
  559. int prepadBytes = (int)hkUlong( static_cast<char*>(pfree) - static_cast<char*>(info.realMem) );
  560. hkString::memSet( info.realMem, s_fillFreeSpace, prepadBytes + info.numBytes + MEMORY_PADDING );
  561. }
  563. m_numSysAllocs -= 1;
  564. m_sysAllocsSize -= bytesToFree;
  566. hkSystemFree( info.realMem );
  567. m_activePointers.erase(i);
  568. }
  570. void* hkStlDebugMemory::allocateChunk(int nbytes, HK_MEMORY_CLASS c)
  571. {
  572. return internalAllocate(nbytes, c, MEM_CHUNK);
  573. }
  575. void hkStlDebugMemory::deallocateChunk(void* p, int nbytes, HK_MEMORY_CLASS cl)
  576. {
  577. if(p)
  578. {
  579. internalFree(p, nbytes, MEM_CHUNK);
  580. }
  581. }
  583. hkBool hkStlDebugMemory::isOk() const
  584. {
  585. hkCriticalSectionLock lock( &m_section );
  586.     hkStlDebugMemory::Map::const_iterator i = m_activePointers.begin();
  587.     hkStlDebugMemory::Map::const_iterator e = m_activePointers.end();
  589. for( ; i!=e; ++i)
  590. {
  591. checkUnderOverrun( i->first, i->second );
  592. }
  593. return true;
  594. }
  596. # include <Common/Base/Fwd/hkwindows.h>
  597. void HK_CALL hkStlDebugMemory::defaultOutputStringFunc( const char* s, void* context)
  598. {
  599. OutputDebugStringA(s);
  600. printf("%s",s); // Also output to console for automated testing
  601. }
  603. void hkStlDebugMemory::preAllocateRuntimeBlock(int nbytes, HK_MEMORY_CLASS cl)
  604. {
  605. }
  607. void* hkStlDebugMemory::allocateRuntimeBlock(int nbytes, HK_MEMORY_CLASS cl)
  608. {
  609. void* memory = allocateChunk(nbytes, cl);
  610. return memory;
  611. }
  613. void hkStlDebugMemory::deallocateRuntimeBlock(void* p, int nbytes, HK_MEMORY_CLASS cl)
  614. {
  615. deallocateChunk(p, nbytes, cl);
  616. }
  618. void hkStlDebugMemory::provideRuntimeBlock(void*, int nbytes, HK_MEMORY_CLASS cl)
  619. {
  620. }
  622. void hkStlDebugMemory::registerStaticAddress(void* address, int nbytes)
  623. {
  624. PointerInfo pointerinfo;
  625. {
  626. pointerinfo.numBytes      = nbytes;
  627. pointerinfo.flags         = MEM_CHUNK;
  628. pointerinfo.mark          = m_mark;
  629. pointerinfo.realMem       = address;
  630. }
  632. m_activePointers[address] = pointerinfo;
  633. }
  635. void hkStlDebugMemory::freeRuntimeBlocks()
  636. {
  637. }
  639. void* hkStlDebugMemory::findBaseAddress(void* p, int nbytes)
  640. {
  641. // try to use p as a base address
  642. {
  643.         hkStlDebugMemory::Map::iterator i = m_activePointers.find(p);
  644. if ( i != m_activePointers.end())
  645. {
  646. HK_ON_DEBUG( const PointerInfo& pinfo = i->second; )
  647. HK_ASSERT2( 0xf0457ef5, hkAddByteOffset(p, nbytes) <= hkAddByteOffset(i->first, pinfo.numBytes), "Invalid Block" );
  648. return i->first;
  649. }
  650. }
  652. // try to walk backward from p
  653. {
  654. void* q = (void*)(HK_NEXT_MULTIPLE_OF(16, hkUlong(p)));
  655. for (int n = 0; n < 50; n++)
  656. {
  657. q = hkAddByteOffset(q, hkUlong(-16));
  659.             hkStlDebugMemory::Map::iterator i = m_activePointers.find(q);
  660. if ( i != m_activePointers.end())
  661. {
  662. HK_ON_DEBUG( const PointerInfo& pinfo = i->second; )
  663. HK_ASSERT2( 0xf0457ef5, hkAddByteOffset(p, nbytes) <= hkAddByteOffset(i->first, pinfo.numBytes), "Invalid Block" );
  664. return i->first;
  665. }
  666. }
  667. }
  671. // search the full list
  672. {
  673.         hkStlDebugMemory::Map::iterator i = m_activePointers.begin();
  674.         hkStlDebugMemory::Map::iterator e = m_activePointers.end();
  676. for( ; i!=e; ++i)
  677. {
  678. const PointerInfo& pinfo = i->second;
  679. if ( i->first <= p && hkAddByteOffset(p, nbytes) <= hkAddByteOffset(i->first, pinfo.numBytes) )
  680. {
  681. return i->first;
  682. }
  683. }
  684. }
  686. HK_ASSERT2(0xaf543fe2, false, "Invalid memory block.");
  687. return HK_NULL;
  688. }
  690. void hkStlDebugMemory::lockBlock(void* p)
  691. {
  692.     hkStlDebugMemory::Map::iterator i = m_activePointers.find(p);
  693. PointerInfo& pinfo = i->second;
  694. pinfo.m_lockCount++;
  695. }
  697. void hkStlDebugMemory::unlockBlock(void* p)
  698. {
  699.     hkStlDebugMemory::Map::iterator i = m_activePointers.find(p);
  700. PointerInfo& pinfo = i->second;
  701. pinfo.m_lockCount--;
  702. }
  704. #endif // HK_STL_DEBUG_MEMORY_H
  707. /*
  708. * Havok SDK - NO SOURCE PC DOWNLOAD, BUILD(#20090216)
  709. * 
  710. * Confidential Information of Havok.  (C) Copyright 1999-2009
  711. * Telekinesys Research Limited t/a Havok. All Rights Reserved. The Havok
  712. * Logo, and the Havok buzzsaw logo are trademarks of Havok.  Title, ownership
  713. * rights, and intellectual property rights in the Havok software remain in
  714. * Havok and/or its suppliers.
  715. * 
  716. * Use of this software for evaluation purposes is subject to and indicates
  717. * acceptance of the End User licence Agreement for this product. A copy of
  718. * the license is included with this software and is also available at www.havok.com/tryhavok.
  719. * 
  720. */