//// Optimized Windows virtual memory allocator.//class FMallocWindows : public FMalloc{private: // Counts. enum {POOL_COUNT = 42 }; enum {POOL_MAX = 32768+1}; // Forward declares. struct FFreeMem; struct FPoolTable; // Memory pool info. 32 bytes. struct FPoolInfo { DWORD Bytes; // Bytes allocated for pool. DWORD OsBytes; // Bytes aligned to page size. DWORD Taken; // Number of allocated elements in this pool, when counts down to zero can free the entire pool. BYTE* Mem; // Memory base. FPoolTable* Table; // Index of pool. FFreeMem* FirstMem; // Pointer to first free memory in this pool. FPoolInfo* Next; FPoolInfo** PrevLink; void Link( FPoolInfo*& Before ) { if( Before ) Before->PrevLink = &Next; Next = Before; PrevLink = &Before; Before = this; } void Unlink() { if( Next ) Next->PrevLink = PrevLink; *PrevLink = Next; } }; // Information about a piece of free memory. 8 bytes. struct FFreeMem { FFreeMem* Next; // Next or MemLastPool[], always in order by pool. DWORD Blocks; // Number of consecutive free blocks here, at least 1. FPoolInfo* GetPool() { return (FPoolInfo*)((INT)this & 0xffff0000); } }; // Pool table. struct FPoolTable { FPoolInfo* FirstPool; FPoolInfo* ExhaustedPool; DWORD BlockSize; }; // Variables. FPoolTable PoolTable[POOL_COUNT], OsTable; FPoolInfo* PoolIndirect[256]; FPoolTable* MemSizeToPoolTable[POOL_MAX]; INT MemInit; INT OsCurrent,OsPeak,UsedCurrent,UsedPeak,CurrentAllocs,TotalAllocs; DOUBLE MemTime; INT PageSize; // Implementation. void OutOfMemory() { appErrorf( *LocalizeError("OutOfMemory",TEXT("Core")) ); } FPoolInfo* CreateIndirect() { FPoolInfo* Indirect = (FPoolInfo*)VirtualAlloc( NULL, 256*sizeof(FPoolInfo), MEM_COMMIT, PAGE_READWRITE ); if( !Indirect ) OutOfMemory(); return Indirect; }public: // FMalloc interface. FMallocWindows() : MemInit( 0 ) , OsCurrent ( 0 ) , OsPeak ( 0 ) , UsedCurrent ( 0 ) , UsedPeak ( 0 ) , CurrentAllocs ( 0 ) , TotalAllocs ( 0 ) , MemTime ( 0.0 ) , PageSize ( 0 ) {} void* Malloc( DWORD Size, DWORD Alignment ) { check(Alignment == DEFAULT_ALIGNMENT && "Alignment currently unsupported in Windows"); checkSlow(MemInit); MEM_TIME(MemTime -= appSeconds()); STAT(CurrentAllocs++); STAT(TotalAllocs++); FFreeMem* Free; if( Size<POOL_MAX ) { // Allocate from pool. FPoolTable* Table = MemSizeToPoolTable[Size]; checkSlow(Size<=Table->BlockSize); FPoolInfo* Pool = Table->FirstPool; if( !Pool ) { // Must create a new pool. DWORD Blocks = 65536 / Table->BlockSize; DWORD Bytes = Blocks * Table->BlockSize; checkSlow(Blocks>=1); checkSlow(Blocks*Table->BlockSize<=Bytes); // Allocate memory. //!分配内存,Bytes表示分配的内存的大小. Free = (FFreeMem*)VirtualAlloc( NULL, Bytes, MEM_COMMIT, PAGE_READWRITE ); if( !Free ) OutOfMemory(); // Create pool in the indirect table. FPoolInfo*& Indirect = PoolIndirect[((DWORD)Free>>24)]; if( !Indirect ) Indirect = CreateIndirect(); Pool = &Indirect[((DWORD)Free>>16)&255]; // Init pool. Pool->Link( Table->FirstPool ); Pool->Mem = (BYTE*)Free; Pool->Bytes = Bytes; Pool->OsBytes = Align(Bytes,PageSize); STAT(OsPeak = Max(OsPeak,OsCurrent+=Pool->OsBytes)); Pool->Table = Table; Pool->Taken = 0; Pool->FirstMem = Free; // Create first free item. Free->Blocks = Blocks; Free->Next = NULL; } // Pick first available block and unlink it. Pool->Taken++; checkSlow(Pool->FirstMem); checkSlow(Pool->FirstMem->Blocks>0); Free = (FFreeMem*)((BYTE*)Pool->FirstMem + --Pool->FirstMem->Blocks * Table->BlockSize); if( Pool->FirstMem->Blocks==0 ) { Pool->FirstMem = Pool->FirstMem->Next; if( !Pool->FirstMem ) { // Move to exhausted list. Pool->Unlink(); Pool->Link( Table->ExhaustedPool ); } } STAT(UsedPeak = Max(UsedPeak,UsedCurrent+=Table->BlockSize)); } else { // Use OS for large allocations. INT AlignedSize = Align(Size,PageSize); Free = (FFreeMem*)VirtualAlloc( NULL, AlignedSize, MEM_COMMIT, PAGE_READWRITE ); if( !Free ) OutOfMemory(); checkSlow(!((SIZE_T)Free&65535)); // Create indirect. FPoolInfo*& Indirect = PoolIndirect[((DWORD)Free>>24)]; if( !Indirect ) Indirect = CreateIndirect(); // Init pool. FPoolInfo* Pool = &Indirect[((DWORD)Free>>16)&255]; Pool->Mem = (BYTE*)Free; Pool->Bytes = Size; Pool->OsBytes = AlignedSize; Pool->Table = &OsTable; STAT(OsPeak = Max(OsPeak, OsCurrent+=AlignedSize)); STAT(UsedPeak = Max(UsedPeak,UsedCurrent+=Size)); } MEM_TIME(MemTime += appSeconds()); return Free; } void* Realloc( void* Ptr, DWORD NewSize, DWORD Alignment ) { check(Alignment == DEFAULT_ALIGNMENT && "Alignment currently unsupported in Windows"); checkSlow(MemInit); MEM_TIME(MemTime -= appSeconds()); void* NewPtr = Ptr; if( Ptr && NewSize ) { checkSlow(MemInit); FPoolInfo* Pool = &PoolIndirect[(DWORD)Ptr>>24][((DWORD)Ptr>>16)&255]; if( Pool->Table!=&OsTable ) { // Allocated from pool, so grow or shrink if necessary. if( NewSize>Pool->Table->BlockSize || MemSizeToPoolTable[NewSize]!=Pool->Table ) { NewPtr = Malloc( NewSize, Alignment ); appMemcpy( NewPtr, Ptr, Min(NewSize,Pool->Table->BlockSize) ); Free( Ptr ); } } else { // Allocated from OS. checkSlow(!((INT)Ptr&65535)); if( NewSize>Pool->OsBytes || NewSize*3<Pool->OsBytes*2 ) { // Grow or shrink. NewPtr = Malloc( NewSize, Alignment ); appMemcpy( NewPtr, Ptr, Min(NewSize,Pool->Bytes) ); Free( Ptr ); } else { // Keep as-is, reallocation isn't worth the overhead. Pool->Bytes = NewSize; } } } else if( Ptr == NULL ) { NewPtr = Malloc( NewSize, Alignment ); } else { Free( Ptr ); NewPtr = NULL; } MEM_TIME(MemTime += appSeconds()); return NewPtr; } void Free( void* Ptr ) { if( !Ptr ) return; checkSlow(MemInit); MEM_TIME(MemTime -= appSeconds()); STAT(CurrentAllocs--); // Windows version. FPoolInfo* Pool = &PoolIndirect[(DWORD)Ptr>>24][((DWORD)Ptr>>16)&255]; checkSlow(Pool->Bytes!=0); if( Pool->Table!=&OsTable ) { // If this pool was exhausted, move to available list. if( !Pool->FirstMem ) { Pool->Unlink(); Pool->Link( Pool->Table->FirstPool ); } // Free a pooled allocation. FFreeMem* Free = (FFreeMem *)Ptr; Free->Blocks = 1; Free->Next = Pool->FirstMem; Pool->FirstMem = Free; STAT(UsedCurrent -= Pool->Table->BlockSize); // Free this pool. checkSlow(Pool->Taken>=1); if( --Pool->Taken == 0 ) { // Free the OS memory. Pool->Unlink(); verify( VirtualFree( Pool->Mem, 0, MEM_RELEASE )!=0 ); STAT(OsCurrent -= Pool->OsBytes); } } else { // Free an OS allocation. checkSlow(!((INT)Ptr&65535)); STAT(UsedCurrent -= Pool->Bytes); STAT(OsCurrent -= Pool->OsBytes); verify( VirtualFree( Ptr, 0, MEM_RELEASE )!=0 ); } MEM_TIME(MemTime += appSeconds()); } /** * Gathers memory allocations for both virtual and physical allocations. * * @param Virtual [out] size of virtual allocations * @param Physical [out] size of physical allocations */ void GetAllocationInfo( SIZE_T& Virtual, SIZE_T& Physical ) { Virtual = OsCurrent; Physical = 0; } void DumpAllocs( UBOOL bSummaryOnly, FOutputDevice& Ar ) { FMallocWindows::HeapCheck(); STAT(Ar.Logf( TEXT("Memory Allocation Status") )); STAT(Ar.Logf( TEXT("Curr Memory % 5.3fM / % 5.3fM"), UsedCurrent/1024.0/1024.0, OsCurrent/1024.0/1024.0 )); STAT(Ar.Logf( TEXT("Peak Memory % 5.3fM / % 5.3fM"), UsedPeak /1024.0/1024.0, OsPeak /1024.0/1024.0 )); STAT(Ar.Logf( TEXT("Allocs % 6i Current / % 6i Total"), CurrentAllocs, TotalAllocs )); MEM_TIME(Ar.Logf( "Seconds % 5.3f", MemTime )); MEM_TIME(Ar.Logf( "MSec/Allc % 5.5f", 1000.0 * MemTime / MemAllocs ));#if STATS if( !bSummaryOnly ) { Ar.Logf( TEXT("Block Size Num Pools Cur Allocs Total Allocs Mem Used Mem Waste Efficiency") ); Ar.Logf( TEXT("---------- --------- ---------- ------------ -------- --------- ----------") ); INT TotalPoolCount = 0; INT TotalAllocCount = 0; INT TotalMemUsed = 0; INT TotalMemWaste = 0; for( INT i=0; i<POOL_COUNT; i++ ) { FPoolTable* Table = &PoolTable[i]; INT PoolCount=0; INT AllocCount=0; INT MemUsed=0; for( INT i=0; i<2; i++ ) { for( FPoolInfo* Pool=(i?Table->FirstPool:Table->ExhaustedPool); Pool; Pool=Pool->Next ) { PoolCount++; AllocCount += Pool->Taken; MemUsed += Pool->Bytes; INT FreeCount=0; for( FFreeMem* Free=Pool->FirstMem; Free; Free=Free->Next ) FreeCount += Free->Blocks; } } INT MemWaste = MemUsed - AllocCount*Table->BlockSize; Ar.Logf ( TEXT("% 10i % 9i % 10i % 11iK % 7iK % 8iK % 9.2f%%"), Table->BlockSize, PoolCount, AllocCount, 0, MemUsed /1024, MemWaste/1024, MemUsed ? 100.0 * MemUsed / (MemUsed+MemWaste) : 100.0 ); TotalPoolCount += PoolCount; TotalAllocCount += AllocCount; TotalMemUsed += MemUsed; TotalMemWaste += MemWaste; } Ar.Logf ( TEXT("BlkOverall % 9i % 10i % 11iK % 7iK % 8iK % 9.2f%%"), TotalPoolCount, TotalAllocCount, 0, TotalMemUsed /1024, TotalMemWaste/1024, TotalMemUsed ? 100.0 * TotalMemUsed / (TotalMemUsed+TotalMemWaste) : 100.0 ); }#endif } void HeapCheck() { for( INT i=0; i<POOL_COUNT; i++ ) { FPoolTable* Table = &PoolTable[i]; for( FPoolInfo** PoolPtr=&Table->FirstPool; *PoolPtr; PoolPtr=&(*PoolPtr)->Next ) { FPoolInfo* Pool=*PoolPtr; check(Pool->PrevLink==PoolPtr); check(Pool->FirstMem); for( FFreeMem* Free=Pool->FirstMem; Free; Free=Free->Next ) check(Free->Blocks>0); } for( FPoolInfo** PoolPtr=&Table->ExhaustedPool; *PoolPtr; PoolPtr=&(*PoolPtr)->Next ) { FPoolInfo* Pool=*PoolPtr; check(Pool->PrevLink==PoolPtr); check(!Pool->FirstMem); } } } void Init() { check(!MemInit); MemInit = 1; // Get OS page size. SYSTEM_INFO SI; GetSystemInfo( &SI ); PageSize = SI.dwPageSize; check(!(PageSize&(PageSize-1))); // Init tables. OsTable.FirstPool = NULL; OsTable.ExhaustedPool = NULL; OsTable.BlockSize = 0; PoolTable[0].FirstPool = NULL; PoolTable[0].ExhaustedPool = NULL; PoolTable[0].BlockSize = 8; for( DWORD i=1; i<5; i++ ) { PoolTable[i].FirstPool = NULL; PoolTable[i].ExhaustedPool = NULL; PoolTable[i].BlockSize = (8<<((i+1)>>2)) + (2<<i); } for( DWORD i=5; i<POOL_COUNT; i++ ) { PoolTable[i].FirstPool = NULL; PoolTable[i].ExhaustedPool = NULL; PoolTable[i].BlockSize = (4+((i+7)&3)) << (1+((i+7)>>2)); } for( DWORD i=0; i<POOL_MAX; i++ ) { DWORD Index; for( Index=0; PoolTable[Index].BlockSize<i; Index++ ); checkSlow(Index<POOL_COUNT); MemSizeToPoolTable[i] = &PoolTable[Index]; } for( DWORD i=0; i<256; i++ ) { PoolIndirect[i] = NULL; } check(POOL_MAX-1==PoolTable[POOL_COUNT-1].BlockSize); }};/*----------------------------------------------------------------------------- The End.-----------------------------------------------------------------------------*/
