Unreal内存分配策略

发布时间: 2025-03-24 09:18

↑

# Unreal内存分配策略

本文将深入探讨Unreal引擎的内存分配策略,包括内存管理系统、分配器实现以及优化技术。

## 内存管理系统

### 基础架构

```cpp
// 内存管理系统
class FMemoryManager
{
public:
    // 内存分配
    void* Malloc(
        SIZE_T Size,
        uint32 Alignment)
    {
        // 1. 分配策略
        if(Size < SmallBlockSize)
        {   
            // 小块分配
            return SmallBlockAllocator.
                Allocate(Size, Alignment);
        }
        else if(Size < LargeBlockSize)
        {
            // 大块分配
            return LargeBlockAllocator.
                Allocate(Size, Alignment);
        }
        else
        {
            // 直接分配
            return FPlatformMemory::
                BinnedAllocFromOS(
                    Size, 
                    Alignment);
        }
    }
    
    // 内存释放
    void Free(void* Ptr)
    {
        // 1. 获取块信息
        FBlockInfo* Block = 
            GetBlockInfo(Ptr);
        
        // 2. 释放内存
        if(Block->Size < SmallBlockSize)
        {
            SmallBlockAllocator.
                Deallocate(Ptr);
        }
        else if(Block->Size < LargeBlockSize)
        {
            LargeBlockAllocator.
                Deallocate(Ptr);
        }
        else
        {
            FPlatformMemory::
                BinnedFreeToOS(Ptr);
        }
    }
};
```

内存管理特性:

1. 分配策略
   - 小块分配
   - 大块分配
   - 直接分配

2. 内存回收
   - 块信息
   - 释放策略
   - 内存回收

### 分配器实现

```cpp
// 内存分配器
class FBlockAllocator
{
public:
    // 内存分配
    void* Allocate(
        SIZE_T Size,
        uint32 Alignment)
    {
        // 1. 对齐大小
        Size = Align(Size, Alignment);
        
        // 2. 查找空闲块
        FBlock* Block = 
            FindFreeBlock(Size);
            
        if(!Block)
        {
            // 创建新块
            Block = CreateNewBlock(Size);
        }
        
        // 3. 分配内存
        void* Ptr = Block->Data;
        Block->bAllocated = true;
        
        // 4. 更新统计
        UpdateStats(Size);
        
        return Ptr;
    }
    
    // 内存释放
    void Deallocate(void* Ptr)
    {   
        // 1. 获取块信息
        FBlock* Block = 
            GetBlockFromPtr(Ptr);
        
        // 2. 释放内存
        Block->bAllocated = false;
        
        // 3. 合并空闲块
        MergeFreeBlocks(Block);
        
        // 4. 更新统计
        UpdateStats(-Block->Size);
    }
    
 private:
    // 创建内存块
    FBlock* CreateNewBlock(
        SIZE_T Size)
    {
        // 1. 分配内存
        void* Memory = 
            FPlatformMemory::
                BinnedAllocFromOS(
                    Size + sizeof(FBlock),
                    DEFAULT_ALIGNMENT);
        
        // 2. 初始化块
        FBlock* Block = 
            new(Memory) FBlock;
            
        Block->Size = Size;
        Block->Data = 
            (uint8*)Memory + 
            sizeof(FBlock);
        
        // 3. 添加到列表
        Blocks.Add(Block);
        
        return Block;
    }
    
    // 合并空闲块
    void MergeFreeBlocks(
        FBlock* Block)
    {
        // 1. 向前合并
        FBlock* Prev = Block->Prev;
        if(Prev && !Prev->bAllocated)
        {
            Prev->Size += 
                Block->Size + 
                sizeof(FBlock);
                
            Prev->Next = Block->Next;
            Block = Prev;
        }
        
        // 2. 向后合并
        FBlock* Next = Block->Next;
        if(Next && !Next->bAllocated)
        {
            Block->Size += 
                Next->Size + 
                sizeof(FBlock);
                
            Block->Next = Next->Next;
        }
    }
};
```

分配器特性:

1. 内存分配
   - 块管理
   - 空闲查找
   - 块创建

2. 内存释放
   - 块释放
   - 块合并
   - 统计更新

## 优化技术

### 池化管理

```cpp
// 内存池系统
class FMemoryPool
{
public:
    // 初始化内存池
    void Initialize(
        SIZE_T BlockSize,
        uint32 BlockCount)
    {
        // 1. 分配内存
        PoolMemory = 
            FPlatformMemory::
                BinnedAllocFromOS(
                    BlockSize * BlockCount,
                    DEFAULT_ALIGNMENT);
        
        // 2. 初始化块
        for(uint32 i = 0; i < BlockCount; ++i)
        {
            FPoolBlock* Block = 
                (FPoolBlock*)((uint8*)PoolMemory + 
                    i * BlockSize);
                    
            Block->Next = FreeBlocks;
            FreeBlocks = Block;
        }
    }
    
    // 分配内存
    void* Allocate()
    {
        // 1. 检查空闲块
        if(!FreeBlocks)
        {
            return nullptr;
        }
        
        // 2. 获取块
        FPoolBlock* Block = FreeBlocks;
        FreeBlocks = Block->Next;
        
        // 3. 返回内存
        return Block;
    }
    
    // 释放内存
    void Free(void* Ptr)
    {
        // 1. 转换类型
        FPoolBlock* Block = 
            (FPoolBlock*)Ptr;
        
        // 2. 添加到空闲列表
        Block->Next = FreeBlocks;
        FreeBlocks = Block;
    }
};
```

池化特性:

1. 池初始化
   - 内存预分配
   - 块初始化
   - 链表构建

2. 内存管理
   - 快速分配
   - 快速释放
   - 内存复用

### 缓存优化

```cpp
// 缓存优化系统
class FMemoryCache
{
public:
    // 缓存分配
    void* CacheAllocate(
        SIZE_T Size)
    {
        // 1. 查找缓存
        FCacheEntry* Entry = 
            FindCache(Size);
            
        if(Entry)
        {
            // 使用缓存
            return Entry->Memory;
        }
        
        // 2. 分配内存
        void* Memory = 
            FMemory::Malloc(
                Size);
        
        // 3. 添加缓存
        AddCache(
            Size,
            Memory);
        
        return Memory;
    }
    
    // 缓存释放
    void CacheFree(
        void* Ptr)
    {
        // 1. 查找缓存
        FCacheEntry* Entry = 
            FindCacheByPtr(Ptr);
            
        if(!Entry)
        {
            // 直接释放
            FMemory::Free(Ptr);
            return;
        }
        
        // 2. 更新缓存
        Entry->bFree = true;
        Entry->LastUsedTime = 
            FPlatformTime::Seconds();
    }
    
 private:
    // 缓存清理
    void CleanCache()
    {
        // 1. 获取当前时间
        double CurrentTime = 
            FPlatformTime::Seconds();
        
        // 2. 遍历缓存
        for(auto It = Cache.CreateIterator();
            It; ++It)
        {
            FCacheEntry* Entry = *It;
            
            // 检查过期
            if(Entry->bFree && 
               CurrentTime - Entry->LastUsedTime > 
               CacheTimeout)
            {
                // 释放内存
                FMemory::Free(
                    Entry->Memory);
                    
                // 移除缓存
                It.RemoveCurrent();
            }
        }
    }
};
```

缓存优化特性:

1. 缓存管理
   - 缓存查找
   - 缓存添加
   - 缓存更新

2. 清理策略
   - 过期检查
   - 内存释放
   - 缓存移除

元素码农