《OGRE 3D 渲染引擎原理与架构》13.3 分类分配与容器策略

OGRE 把内存按使用类别分类:OGRE_ALLOC_T/OGRE_FREE 带 category 参数,STL 容器用带 category 的分配器(STLAllocator<T, DefaultAllocPolicy, Category>)。每种类别独立统计,便于定位内存归属与泄漏。lab 用 C++ 复现分类统计与带 category 的 std::vector 分配器。

13.3 分类分配与容器策略

13.1/13.2 讲了「怎么分配」「怎么管理生命周期」;这一节讲「分配从哪来、归类到哪去」——OGRE 把内存按使用类别分类,便于审计与定位。

本章与站内既有内容的分工

13.1 是原始对齐分配;这里讲 OGRE 的分类宏与「STL 容器 + 自定义分配器」的接线方式。

分类宏:OGRE_ALLOC_T / OGRE_FREE

OgreMemoryAllocatorConfig.h 定义按类别分配的一组宏:

// OgreMain/include/OgreMemoryAllocatorConfig.h:分类宏(v14.6.3 源码摘录,已删减)
/// Allocate a block of raw memory, and indicate the category of usage
#   define OGRE_MALLOC(bytes, category) (void*)new char[bytes]
/// Allocate a block of memory for a primitive type, and indicate the category of usage
#   define OGRE_ALLOC_T(T, count, category) (T*)new char[(count) * sizeof(T)]
/// Free the memory allocated with OGRE_MALLOC or OGRE_ALLOC_T. Category is required to be restated to ensure the matching policy is used
#   define OGRE_FREE(ptr, category) delete[] (char*)ptr

// aligned allocation
/// Allocate a block of raw memory aligned to SIMD boundaries, and indicate the category of usage
#   define OGRE_MALLOC_SIMD(bytes, category) ::Ogre::AlignedMemory::allocate(bytes)
/// Free the memory allocated with either OGRE_MALLOC_SIMD or OGRE_ALLOC_T_SIMD. Category is required to be restated to ensure the matching policy is used
#   define OGRE_FREE_SIMD(ptr, category) ::Ogre::AlignedMemory::deallocate((void*)ptr)

两个要点:

  • category 参数:调用处必须声明「这笔内存是干什么的」,释放时也要重申 category——注释强调「to ensure the matching policy is used」,保证分配与释放走同一策略;
  • SIMD 变体:OGRE_MALLOC_SIMD/OGRE_FREE_SIMD 直接转发到 13.1 的 AlignedMemory,得到 SIMD 对齐内存。

category 是一个「使用类别」枚举的实例。头文件里有大量 typedef ...Alloc 别名,把类别语义化:

// OgreMain/include/OgreMemoryAllocatorConfig.h:类别别名(v14.6.3 源码摘录,已删减)
    typedef RenderSysAllocatedObject    ViewportAlloc;
    typedef SceneCtlAllocatedObject     LodAlloc;
    typedef GeneralAllocatedObject      FileSystemLayerAlloc;
    typedef GeneralAllocatedObject      StereoDriverAlloc;

容器:STLAllocator 接线

注释里写明容器的接法:

// OgreMain/include/OgreMemoryAllocatorConfig.h:容器策略注释(v14.6.3 源码摘录,已删减)
    // Containers (by-value only)
    // Will  be of the form:
    // typedef STLAllocator<T, DefaultAllocPolicy, Category> TAlloc;
    // for use in std::vector<T, TAlloc> 

即:std::vector<T> 的第二个模板参数换成一个携带 category 的 STL 分配器。这样一个 vector 的全部内部分配都落到指定类别名下,可以按类别聚合统计——「场景几何用了多少内存、渲染队列用了多少」一目了然。

分类的意义

  • 归属可审计:每类内存独立统计,定位高内存消耗模块;
  • 策略可定制:某类别可换成专用池/对齐策略,其他类别不动;
  • 释放配对:分配/释放都带 category,防错配。

源码定位

上游引用固定到 OGRE v14.6.3 源码 。

可运行产物:C++ 最小验证

下面复现分类分配与带 category 的容器分配器。它与 src/13-3-container-categories.cpp 逐字节一致:

// file: src/13-3-container-categories.cpp
// tier: L1
// verify: clang++ -std=c++20 -I. src/13-3-container-categories.cpp -o bin/13-3-container-categories && ./bin/13-3-container-categories
//
// 复现 OGRE 的分类内存与容器分配策略:
//   OGRE_ALLOC_T(T, count, category) / OGRE_FREE 按使用类别分配;
//   STL 容器用带 category 的分配器(对应 OgreMemoryAllocatorConfig.h
//   注释的 "typedef STLAllocator<T, DefaultAllocPolicy, Category> TAlloc");
//   每种类别独立统计分配字节数,便于定位内存归属。
// 独立最小验证,非 OGRE 源码。
#include "verify.h"

#include <cstddef>
#include <vector>

namespace ogre_repro {

// 使用类别(对应 OgreMemoryAllocatorConfig.h 的 *Alloc typedef)
enum Category { CATEGORY_GENERAL = 0, CATEGORY_SCENE, CATEGORY_RENDER, CATEGORY_COUNT };

// 分类统计:每种类别记录存活字节与累计字节
class CategoryStats {
 public:
  static long long& liveBytes(Category c) { return sLive[c]; }
  static long long& totalBytes(Category c) { return sTotal[c]; }

 private:
  static long long sLive[CATEGORY_COUNT];
  static long long sTotal[CATEGORY_COUNT];
};
long long CategoryStats::sLive[CATEGORY_COUNT] = {};
long long CategoryStats::sTotal[CATEGORY_COUNT] = {};

// 对应 OGRE_ALLOC_T / OGRE_FREE:按类别分配并统计
template <typename T>
T* allocT(size_t count, Category c) {
  T* p = static_cast<T*>(::operator new(count * sizeof(T)));
  CategoryStats::liveBytes(c) += static_cast<long long>(count * sizeof(T));
  CategoryStats::totalBytes(c) += static_cast<long long>(count * sizeof(T));
  return p;
}
template <typename T>
void freeT(T* p, size_t count, Category c) {
  ::operator delete(p);
  CategoryStats::liveBytes(c) -= static_cast<long long>(count * sizeof(T));
}

// STL 分配器:把 std::vector 的分配挂到指定 category
template <typename T>
class CategoryAllocator {
 public:
  using value_type = T;
  CategoryAllocator(Category c) : mCategory(c) {}
  template <typename U>
  CategoryAllocator(const CategoryAllocator<U>& o) : mCategory(o.category()) {}
  Category category() const { return mCategory; }

  T* allocate(size_t n) { return allocT<T>(n, mCategory); }
  void deallocate(T* p, size_t n) { freeT<T>(p, n, mCategory); }

  bool operator==(const CategoryAllocator& o) const { return mCategory == o.mCategory; }
  bool operator!=(const CategoryAllocator& o) const { return !(*this == o); }

 private:
  Category mCategory;
};

}  // namespace ogre_repro

int main() {
  using namespace ogre_repro;

  // OGRE_ALLOC_T:分配 4 个 float(SCENE 类别)
  float* verts = allocT<float>(4, CATEGORY_SCENE);
  verts[0] = 1.0f; verts[3] = 4.0f;
  CHECK(CategoryStats::liveBytes(CATEGORY_SCENE) == 4 * static_cast<long long>(sizeof(float)));
  freeT(verts, 4, CATEGORY_SCENE);
  CHECK(CategoryStats::liveBytes(CATEGORY_SCENE) == 0);

  // std::vector 使用带 category 的分配器
  CategoryAllocator<int> sceneAlloc(CATEGORY_SCENE);
  {
    std::vector<int, CategoryAllocator<int>> positions(sceneAlloc);
    for (int i = 0; i < 100; ++i) positions.push_back(i);
    CHECK(positions.size() == 100);
    // 分配全部去向 SCENE 类别
    CHECK(CategoryStats::totalBytes(CATEGORY_SCENE) >= 100 * static_cast<long long>(sizeof(int)));
  }  // 析构时释放
  CHECK(CategoryStats::liveBytes(CATEGORY_SCENE) == 0);

  // 各类别独立统计,互不干扰
  CategoryAllocator<int> renderAlloc(CATEGORY_RENDER);
  std::vector<int, CategoryAllocator<int>> drawCalls(renderAlloc);
  drawCalls.push_back(1);
  CHECK(CategoryStats::totalBytes(CATEGORY_RENDER) >= static_cast<long long>(sizeof(int)));
  CHECK(CategoryStats::totalBytes(CATEGORY_SCENE) > 0);  // SCENE 仍在累计

  return lab::report("13-3 内存与容器:分类分配与容器策略");
}

本机实测(Apple clang 16,clang++ -std=c++20):编译通过(-Wall 零警告),断言 7/7 通过。

小结

  • OGRE_ALLOC_T(T, count, category)/OGRE_FREE(ptr, category) 按使用类别分配,释放须重申类别。
  • OGRE_MALLOC_SIMD/OGRE_FREE_SIMD 转发到 AlignedMemory 得到 SIMD 对齐内存。
  • 容器用 std::vector<T, STLAllocator<T, DefaultAllocPolicy, Category>> 接线,整容器归类。
  • 分类统计让内存归属可审计、策略可按类别定制。

阅读导航:上一节:13.2 SharedPtr 智能指针 · 下一节:14.1 日志管理器 。

继续阅读

探索更多技术文章

浏览归档,发现更多关于系统设计、工具链和工程实践的内容。

全部文章 返回首页

「books」更多文章

  1. 《大规模分布式计算深入解析》15.3 落地:从 Neo4j 到自研图引擎
  2. 《大规模分布式计算深入解析·图计算与图数据库内核》 · 目录与学习路径(45 篇)
  3. 《大规模分布式计算深入解析》15.2 十一卷主线:从切分到图