《VulkanSceneGraph 1.1.16 源码深度解析》第二章 内存工程:Allocator、MemoryBlock 与场景图的物理布局
源码基线:VulkanSceneGraph 1.1.16 本章对应模块:
include/vsg/core/(Allocator.h、IntrusiveAllocator.h、MemorySlots.h、ScratchMemory.h) 前置章节:第一章 1.4(Object的引用计数与 24 字节布局)
2.0 先算一笔账:100 万次 new 到底慢在哪
上一章我们说 Object 是 24 字节、ref_ptr 是 8 字节,并且强调"省的是每对象乘以百万次的成本"。这一章要把这笔账算到底:一个 100 万节点的场景图,如果每个节点都走一次 malloc,代价是多少?VSG 又是怎么把它压下去的?
先看朴素做法。用 std::make_shared<Group>() 或 new Group 创建 100 万个 Group,每个 Group 内部还有一个 std::vector<ref_ptr<Node>>(至少一次堆分配)。总计约 200 万次分配 + 200 万次释放。
malloc 的成本由三部分组成,很多人只算了第一项:
| 成本项 | 典型量级(x86-64, glibc) | 说明 |
|---|---|---|
| 分配器自身逻辑 | 20–60 ns/次 | 空闲链表查找、size class 匹配、可能的锁 |
| 元数据开销 | 16 字节/次(glibc 最小 chunk 32 字节) | 8 字节 chunk header + 对齐填充 |
| 缺页中断(page fault) | 首次触碰新页 ~1–2 μs | 真正的杀手:200 万个分散的小对象会触碰上千个新页 |
| 缓存不命中 | 每次访问 ~100 ns(L3 miss) | 对象分散在堆上,遍历时指针追逐 |
只算分配器逻辑:200 万 × 40ns ≈ 80ms,看起来还能接受。
但加上缺页:假设 200 万个对象平均 48 字节(含元数据),总内存约 96MB,按 4KB 页算是 24,000 个页。首次全部触碰的缺页成本约 24,000 × 1.5μs ≈ 36ms。加上分配器为了满足不同 size class 做的 brk/mmap 系统调用,实际总耗时通常在 300ms–1s 量级。
再看遍历的代价。场景图遍历是典型的指针追逐:父节点 → children 向量 → 子节点指针 → 子节点的 children……每次跳转大概率一次 miss。对象随机分布时,100 万节点就是 100 万次 L3 miss(约 100ms 纯等内存);按创建顺序紧凑排列时,预取器能命中大部分,miss 可降到 10 万以下。
这两件事——分配成本和内存局部性——就是 IntrusiveAllocator 要解决的问题。 它的设计目标写在头文件注释里(include/vsg/core/IntrusiveAllocator.h),值得逐句读:
// Memory is allocated for fixed sized blocks, with indexing of allocated and available slots of memory
// are stored within the same memory block that user memory allocation are made from. The memory block
// is created a contiguous block of 4 bytes Elements, where the Element is a union of bitfield linked list
// marker the beginning of the previous slot or the begging of the next, the status of whether the slot is
// allocated or available, or an index when used as part of doubling linked list of free slots.
//
// The block allocation is done based on the type of object so all nodes, data or general objects are
// allocated within the blocks containing objects of similar type. This form of block allocation helps
// scene graph traversal speeds by improving cache coherency/reducing cache missing as it ensures that
// nodes etc. are packed in adjacent memory.
//
// The instrusive indexing means there is only a 4 byte panalty for each memory allocation, and a minimum
// memory use per allocation of 12 bytes (3 Elements - 1 for the slot{previous, next, status} and 2 for the
// previous and next free list indices.
//
// The maximum size of allocations within the block allocation is (2^15-2) * 4, allocations larger than this
// are allocated using aligned versions of std::new and std::delete.
四句话,四个设计决策:
- 按固定大小的块分配(不是每个对象一次
malloc)。 - 索引就存在块内部(intrusive,无外部元数据)。
- 按对象类型分块(nodes 一块、data 一块),提升遍历的局部性。
- 每次分配只付 4 字节代价,最小分配 12 字节,超过 128KB 走系统
new。
下面的小节逐条拆解这四句话的实现。
2.0.1 本章的问题清单
九个问题,按"机制—代价—边界"排列。前六问由 2.1–2.9 回答,第七、八问在 2.7.3 与 2.8 结账,第九问留给 2.19。
- 一行
Group::create()到落位经过几层转发,亲和性写死在哪一层(src/vsg/core/Object.cpp:238的vsg::allocate(count, vsg::ALLOCATOR_AFFINITY_OBJECTS))? - 4 字节的
Element如何同时承载previous、next、status三个字段,15 位为何够用(include/vsg/core/IntrusiveAllocator.h:89)? - 1MB 的块为何被切成 4 段而不是 1 段(
src/vsg/core/IntrusiveAllocator.cpp:54的max_slot_size)? - 131,064 字节的上限是
computeMaxiumAllocationSize算出来的还是量出来的(include/vsg/core/IntrusiveAllocator.h:170)? - GPU 侧为何另起三张 map 而不复用
Element的位域链表(include/vsg/core/MemorySlots.h:65的_availableMemory)? - 释放路径上的
size参数被谁用掉了?没有谁用(src/vsg/core/IntrusiveAllocator.cpp:273把形参写成/*size*/)。 deleteEmptyMemoryBlocks()之后 RSS 为何不降(src/vsg/core/IntrusiveAllocator.cpp:793)?- 全局锁的例外有多长——哪些公开方法读同一批
allocatorMemoryBlocks却不持锁(src/vsg/core/IntrusiveAllocator.cpp:1008)? - 上层模块把哪些约定当成了保证(
src/vsg/core/MemorySlots.cpp:98里只比computedSize与_totalMemorySize)?
2.0.2 答案骨架
结论先行,证据在括号里,推导在对应小节。
- 亲和性是类型属性,不是调用参数。
Data写ALLOCATOR_AFFINITY_DATA、Node写ALLOCATOR_AFFINITY_NODES,都写死在各自的operator new里(src/vsg/core/Data.cpp:46、src/vsg/nodes/Node.cpp:31),运行期无法按对象逐个切换。 - 槽头的 4 字节不在账本里。
totalReservedSize()累加的是slot.next - 1(src/vsg/core/IntrusiveAllocator.cpp:696),把槽头那个Element排除在外;totalMemorySize()同一口径(src/vsg/core/IntrusiveAllocator.cpp:710),所以报告值恒小于块的operator new尺寸。 - 切 4 段是 15 位偏移逼出来的。 容量 131,072 个对齐单元,
max_slot_size取1 << 15(src/vsg/core/IntrusiveAllocator.cpp:54),一个槽最多覆盖 32,768 个。 - GPU 侧用可读性换正确性。 按大小索引的
_availableMemory服务分配,按偏移索引的_offsetSizes服务合并(include/vsg/core/MemorySlots.h:66)。 - 释放不需要请求大小。
MemoryBlock::deallocate的第二个形参连名字都被注释掉(src/vsg/core/IntrusiveAllocator.cpp:273),尺寸只能从槽头反推。 - 块不会自动归还,手工调用也不真归还。
memoryBlocks.swap只剪局部向量,父类按地址建的memoryBlocks表还握着shared_ptr(src/vsg/core/IntrusiveAllocator.cpp:758)。 - 临时结构体只保证 8 字节对齐。
ScratchMemory::align用sizeof(p)(include/vsg/core/ScratchMemory.h:47),dvec4一类 16 字节对齐类型不在保证内。
2.0.3 阅读路线
| 你手上的症状 | 先读 | 先看这一行 |
|---|---|---|
| 分配慢,想量出差值 | 2.0 → 2.2 → 2.7.4 | src/vsg/core/IntrusiveAllocator.cpp:910,锁住 allocatorAffinity 全线 |
显存碎片、vkAllocateMemory 失败 | 2.4 → 2.9.4 → 2.10.5 | src/vsg/core/MemorySlots.cpp:157 的 lower_bound |
| 改了数据没上传 | 2.5.3 → 2.9.2 → 2.10.2 | include/vsg/core/Data.h:206 的 dirty() |
| 长期运行 RSS 上涨 | 2.7.3 → 2.16 → 2.19 | src/vsg/core/IntrusiveAllocator.cpp:793 |
要改分配器的人从 2.12 的七个纯虚函数清单起手(include/vsg/core/Allocator.h:54 的 allocate),再读 2.8.2 为什么没有分片;只想要结论的人读 2.0.2 与 2.19 两节,其余按需回查。
2.1 Allocator 接口:为什么要四个类型、五个亲和性
先看抽象基类(include/vsg/core/Allocator.h):
enum AllocatorType : uint8_t
{
ALLOCATOR_TYPE_NO_DELETE = 0, // 只分配,从不释放(用于"泄漏检测"或"进程级缓存")
ALLOCATOR_TYPE_NEW_DELETE, // 直接转发到 operator new / delete
ALLOCATOR_TYPE_MALLOC_FREE, // 转发到 malloc / free
ALLOCATOR_TYPE_VSG_ALLOCATOR // 使用 MemoryBlock 池(默认)
};
enum AllocatorAffinity : uint32_t
{
ALLOCATOR_AFFINITY_OBJECTS, // 普通 Object 派生类
ALLOCATOR_AFFINITY_DATA, // Data/Array/Buffer 的 CPU 侧数据
ALLOCATOR_AFFINITY_NODES, // Node 派生类
ALLOCATOR_AFFINITY_PHYSICS, // 物理/仿真数据(16 字节对齐)
ALLOCATOR_AFFINITY_LAST = ALLOCATOR_AFFINITY_PHYSICS + 1
};
class VSG_DECLSPEC Allocator
{
public:
static std::unique_ptr<Allocator>& instance();
virtual void* allocate(std::size_t size, AllocatorAffinity allocatorAffinity = ALLOCATOR_AFFINITY_OBJECTS) = 0;
virtual bool deallocate(void* ptr, std::size_t size) = 0;
virtual size_t deleteEmptyMemoryBlocks() = 0;
virtual size_t totalAvailableSize() const = 0;
virtual size_t totalReservedSize() const = 0;
virtual size_t totalMemorySize() const = 0;
AllocatorType allocatorType = ALLOCATOR_TYPE_VSG_ALLOCATOR;
virtual void setBlockSize(AllocatorAffinity allocatorAffinity, size_t blockSize) = 0;
virtual void report(std::ostream& out) const = 0;
mutable std::mutex mutex;
size_t defaultAlignment = 8;
protected:
std::unique_ptr<Allocator> nestedAllocator;
};
2.1.1 AllocatorType:不是"策略",是"释放语义"
四个类型里最容易误解的是 ALLOCATOR_TYPE_NO_DELETE(include/vsg/core/Allocator.h:25)。它不是"不分配",而是"分配了永不释放":
void* Allocator::allocate(...) // 正常分配
bool Allocator::deallocate(...) // NO_DELETE 时返回 false,什么都不做
这个模式在什么场景有用?
- 进程级缓存:字体图集、内置 shader 这类活到进程结束的数据,释放纯属浪费 CPU。
- 泄漏分析:把
Object::operator new指向NO_DELETE,退出时读totalReservedSize()就是峰值内存,不必操心析构顺序。 - A/B 对比:切换
allocatorType,测释放本身占多少时间(include/vsg/core/Allocator.h:71)。
ALLOCATOR_TYPE_NEW_DELETE 与 ALLOCATOR_TYPE_MALLOC_FREE(include/vsg/core/Allocator.h:26)是"逃生舱":内存池出问题、或需要用 valgrind/ASan 精确追踪时,切回系统分配器。内存池会把多个小分配合并成一次大分配,掩盖越界写,而 ASan 只在系统分配器上工作。
2.1.2 五个亲和性:为"访问模式"而不是"类型"分组
AllocatorAffinity 的五个值不是按 C++ 类型分的,而是按访问模式分的:
| 亲和性 | 谁用 | 访问模式 | 默认块大小 |
|---|---|---|---|
OBJECTS | allocator_affinity_objects(include/vsg/core/Allocator.h:126) | 随机、低频 | 1 MB |
DATA | Data/Array 的 CPU 缓冲 | 顺序、大块、流式 | 16 MB |
NODES | Node::operator new | 遍历时高频、按层级跳转 | 1 MB |
PHYSICS | 物理引擎/仿真 | 顺序、SIMD、要求 16 字节对齐 | 1 MB(16 对齐) |
为什么 NODES 要单独一块(src/vsg/core/IntrusiveAllocator.cpp:856)?因为节点是每帧遍历的热数据。如果节点和 Data(顶点数组,动辄几 MB)混在同一块里,节点的内存会被大数组冲散,遍历时 cache miss 率上升。分块之后,节点集中在一片连续区域,硬件预取器能沿着 children 指针的方向预取。
为什么 DATA 的块是 16 MB(src/vsg/core/IntrusiveAllocator.cpp:868)?因为顶点/索引数据通常是"一次分配几十 MB、顺序读一遍"的模式。小块会导致频繁申请新块(每块 1MB,10MB 的网格要 10 块),而大块能一次容纳,减少块间跳转。
为什么 PHYSICS 要 16 字节对齐?因为 SIMD(SSE/AVX)要求 16/32 字节对齐的加载。这个亲和性是给外部物理库(比如 Bullet)预留的,VSG 自己不用。
这些默认值在构造函数里写死(src/vsg/core/IntrusiveAllocator.cpp):
size_t Megabyte = size_t(1024) * size_t(1024);
size_t blockSize = size_t(1) * Megabyte;
allocatorMemoryBlocks.resize(vsg::ALLOCATOR_AFFINITY_LAST);
allocatorMemoryBlocks[vsg::ALLOCATOR_AFFINITY_OBJECTS].reset(new MemoryBlocks(this, "ALLOCATOR_AFFINITY_OBJECTS", blockSize, defaultAlignment));
allocatorMemoryBlocks[vsg::ALLOCATOR_AFFINITY_DATA].reset(new MemoryBlocks(this, "ALLOCATOR_AFFINITY_DATA", size_t(16) * blockSize, defaultAlignment));
allocatorMemoryBlocks[vsg::ALLOCATOR_AFFINITY_NODES].reset(new MemoryBlocks(this, "ALLOCATOR_AFFINITY_NODES", blockSize, defaultAlignment));
allocatorMemoryBlocks[vsg::ALLOCATOR_AFFINITY_PHYSICS].reset(new MemoryBlocks(this, "ALLOCATOR_AFFINITY_PHYSICS", blockSize, 16));
注意 PHYSICS 的最后一个参数是硬编码的 16(src/vsg/core/IntrusiveAllocator.cpp:857),不跟随 defaultAlignment。这是一个"面向未来"的假设:物理数据永远需要 16 字节对齐。
2.1.3 单例与可替换性
std::unique_ptr<Allocator>& Allocator::instance()
{
static std::unique_ptr<Allocator> s_allocator(new IntrusiveAllocator());
return s_allocator;
}
三个细节:
- 函数内静态变量:C++11 保证线程安全的惰性初始化,不需要显式加锁。
- 返回引用而不是指针:调用方可以
Allocator::instance() = std::make_unique<MyAllocator>();直接替换(unique_ptr的赋值会先销毁旧的),入口就是那行返回引用的instance()(src/vsg/core/Allocator.cpp:24)。这比"提供 setAllocator()"更简洁,也避免了"忘记初始化"的问题。 nestedAllocator:替换分配器时,旧分配器不能立刻销毁——它分配的内存还在用。所以构造函数接受std::unique_ptr<Allocator> in_nestedAllocator(include/vsg/core/Allocator.h:46),新分配器把旧分配器"套"在里面,负责在析构时释放它。
explicit Allocator(std::unique_ptr<Allocator> in_nestedAllocator, size_t in_defaultAlignment = 8) :
defaultAlignment(in_defaultAlignment), nestedAllocator(std::move(in_nestedAllocator)) {}
这是一个责任链模式:新分配器只负责"新分配",旧内存由嵌套的分配器负责释放。头文件注释写得很直白:
// if you are assigning a custom allocator you must retain the old allocator to manage the memory it allocated and needs to delete
陷阱:如果你直接 Allocator::instance().reset(new MyAllocator()) 而不传 nestedAllocator,旧分配器分配的所有内存都会在进程结束时"泄漏"(其实是未定义行为,因为 MemoryBlock 的析构会去释放已经被替换掉的块)。正确写法:
auto old = std::move(Allocator::instance());
Allocator::instance() = std::make_unique<MyAllocator>(std::move(old));
2.1.4 Object::operator new 如何路由到亲和性
上一章我们看到 Object 声明了:
static void* operator new(std::size_t count);
static void operator delete(void* ptr);
它的实现(src/vsg/core/Object.cpp)只有一行:
void* Object::operator new(std::size_t count)
{
return vsg::allocate(count, ALLOCATOR_AFFINITY_OBJECTS);
}
Node 同理,但亲和性是 NODES,释放侧同样只有一行转发(src/vsg/nodes/Node.cpp:36):
void* Node::operator new(std::size_t count)
{
return vsg::allocate(count, ALLOCATOR_AFFINITY_NODES);
}
而 vsg::allocate 又转发到单例(src/vsg/core/Allocator.cpp:34):
void* vsg::allocate(std::size_t size, AllocatorAffinity allocatorAffinity)
{
return Allocator::instance()->allocate(size, allocatorAffinity);
}
三层转发,每层都是内联或单次调用,起点是 Object 里那两行静态声明(include/vsg/core/Object.h:78)。为什么不用虚函数直接路由?因为 operator new 是静态函数,不能是虚函数——C++ 的对象分配发生在构造函数之前,此时还没有虚表。所以只能用"每个类自己声明 operator new"的方式,把亲和性硬编码在类型里。
这也意味着:如果你自定义一个节点类但忘了声明 operator new,它会走 Node::operator new(继承),亲和性仍然是 NODES——这是正确的默认行为。但如果你自定义一个非节点类,继承 Object 而没声明 operator new,它会走 Object::operator new(OBJECTS),也是合理的。
2.2 MemoryBlock:15 位相对偏移与三元素自由链表
这是全库最"硬核"的一段代码。它的目标是在零外部元数据的前提下,实现一个能分配、能合并、能复用的块内分配器。
2.2.1 Element:4 字节承载三种含义
struct Element
{
union
{
uint32_t index;
struct
{
unsigned int previous : 15;
unsigned int next : 15;
unsigned int status : 2;
};
};
using Offset = decltype(previous); // unsigned int(15 位有效)
using Status = decltype(status); // unsigned int(2 位有效)
using Index = decltype(index); // uint32_t
};
一个 4 字节的字,有两种解读:
- 作为
index:一个普通索引(用于自由链表的头、尾、计数)。 - 作为位域:
previous(15 位)+next(15 位)+status(2 位)。
三个 using 别名(Offset/Status/Index)就是这三种解读的入口(include/vsg/core/IntrusiveAllocator.h:95),status 的 2 位编码了槽的状态:空闲、已分配、以及"自由链表节点"的两种角色(头/中间),写入口就是 slot.status = 0 那一行(src/vsg/core/IntrusiveAllocator.cpp:229)。previous 和 next 不是绝对地址,而是相对偏移:
memory[position] = Element{(previous_position == 0) ? 0 : (position - previous_position),
next_position - position,
1};
这里存的是 position - previous_position(到前一个槽的距离)和 next_position - position(到后一个槽的距离),释放时反向减一次就还原成下标(src/vsg/core/IntrusiveAllocator.cpp:315)。为什么用相对偏移?因为15 位存不下绝对地址。一个 1MB 的块有 131,072 个对齐单元(src/vsg/core/IntrusiveAllocator.cpp:51 的 capacity),绝对索引需要 17 位。但相邻槽的距离通常很小(一个槽是几十到几百字节),15 位(最大 32,767 个单元)足够覆盖。
这是一个经典的空间换时间技巧:用相对偏移把索引压缩到 15 位,从而把三个字段塞进 4 字节。如果改用绝对地址(void*),每个槽的头部就要 24 字节(prev + next + size + status),在百万对象上就是 24MB 的额外开销。
2.2.2 一个空闲槽占三个 Element
注释里写得很清楚:
a minimum memory use per allocation of 12 bytes (3 Elements - 1 for the slot{previous, next, status}
and 2 for the previous and next free list indices.
为什么需要三个?
- 第 1 个
Element:槽头,记录"前一个槽多远、后一个槽多远、状态"。 - 第 2 个
Element:本槽在自由链表里的前驱索引(src/vsg/core/IntrusiveAllocator.cpp:77)。 - 第 3 个
Element:本槽在自由链表里的后继索引。
也就是说,空闲槽有一个双向链表:分配时按链表遍历找合适的槽,归还时 standalone() 插表头也是三条赋值(src/vsg/core/IntrusiveAllocator.cpp:469)。已分配的槽只占第 1 个 Element(4 字节),后两个还给用户数据——"每次分配只付 4 字节代价"就是这么来的。
算一下最小分配:
| 分配大小 | 实际占用(align=8) | 说明 |
|---|---|---|
| 1 字节 | 8 字节(1 个对齐单元)+ 4 字节槽头 = 12 字节 | 最小分配 |
24 字节(Object) | 24 字节 + 4 字节槽头 = 28 字节,向上对齐到 32 字节 | 槽头占 4 字节,数据从下一个对齐单元开始 |
| 64 字节 | 64 + 4 = 68 → 72 字节 | 对齐到 8 的倍数 |
对比 malloc:glibc 的最小 chunk 是 32 字节(含 8 字节 size 字段 + 8 字节 prev_size + 对齐),24 字节的请求实际占用 32 字节。VSG 的 24 字节对象占 32 字节——打平。但 VSG 的优势不在单次开销,而在"批量分配的局部性"和"零碎片"。
2.2.3 块的切分:为什么一个块里有多个自由链表节点
关键在于这两行:
Element::Index max_slot_size = (1 << 15); // 32768
Element::Index aligned_start = ((position + max_slot_size) / elementAlignment) * elementAlignment;
Element::Index next_position = std::min(aligned_start - 1, capacity);
因为相对偏移只有 15 位,单个空闲槽不能超过 32,768 个对齐单元(切分处用 std::min(aligned_start - 1, capacity) 截断,src/vsg/core/IntrusiveAllocator.cpp:74)(默认 alignment=8 时是 262,144 字节)。而一个 1MB 的块有 131,072 个对齐单元,所以必须切成 4 个槽:
块起始 块结束
├──────────────┬──────────────┬──────────────┬──────────────┤
│ 槽 0 (32K) │ 槽 1 (32K) │ 槽 2 (32K) │ 槽 3 (32K) │
└──────────────┴──────────────┴──────────────┴──────────────┘
↑ 每个槽头记录到相邻槽的相对距离,构成一个环形/链式结构
分配时,MemoryBlock::allocate 会遍历这 4 个槽(src/vsg/core/IntrusiveAllocator.cpp:131 的 while (freePosition != 0)),找到第一个足够大的。如果槽太大,就分裂(split):把槽切成"分配部分 + 剩余空闲部分",剩余部分插回自由链表。释放时合并(coalesce)由四条路径分派:三向合并 mergePCN(src/vsg/core/IntrusiveAllocator.cpp:348)、只并前邻 mergePC(src/vsg/core/IntrusiveAllocator.cpp:429)、只并后邻 mergeCN、孤立插入 standalone;前两者各减一次 freeList.count(src/vsg/core/IntrusiveAllocator.cpp:406),standalone 则加一次(src/vsg/core/IntrusiveAllocator.cpp:483),计数与链表长度由这一步配平。
这就是一个标准的 buddy-ish 分配器,但没有 buddy 的"必须是 2 的幂"限制——它用的是"最佳适配 + 分裂合并",判据就是 minimumAlignedEnd < nextPosition(src/vsg/core/IntrusiveAllocator.cpp:162)。
块的可用区由三个字段钉住:memoryEnd 指向块尾(src/vsg/core/IntrusiveAllocator.cpp:50),firstSlot 是第一个对齐槽的下标(src/vsg/core/IntrusiveAllocator.cpp:52,头文件里的初值是 1,include/vsg/core/IntrusiveAllocator.h:130),blockAlignment 至少被抬到 16 字节(src/vsg/core/IntrusiveAllocator.cpp:44 的 size_t{16}),随后作为 std::align_val_t 传给 operator new。槽有多大也不靠字段猜:slotSpace 直接取 slot.next(src/vsg/core/IntrusiveAllocator.cpp:143),slotSize 就是 sizeof(Element) * (slotSpace - 1)(src/vsg/core/IntrusiveAllocator.cpp:150)——减掉的那 1 个 Element 就是槽头。
2.2.4 单次分配上限:131,064 字节
static inline size_t computeMaxiumAllocationSize(size_t blockSize, size_t alignment)
{
return std::min(blockSize - alignment, size_t((1 << 15) - 2) * sizeof(Element));
}
代入默认值:min(1MB - 8, 32766 × 4) = min(1,048,568, 131,064) = 131,064 字节。
也就是说,**单次分配超过 131,064 字节(约 128KB)就走系统 operator new,因为 size > maximumAllocationSize 时块内分配直接 return nullptr(src/vsg/core/IntrusiveAllocator.cpp:122),不进入内存池。为什么?因为块内分配的索引是 15 位,超过这个尺寸的槽无法用相对偏移表示。
这个阈值对场景图意味着什么?
- 普通的
Object/Node:几十到几百字节,全部走池。 Array<vec3>的顶点数据:一个 10 万顶点的网格是 1.2MB,超过阈值,走系统new。UniformBuffer的小数据:几百字节,走池。
所以"大数据走系统分配、小对象走池"是一个自然的分层。Data/Array 的亲和性虽然是 DATA,但只有小于 128KB 的数组才真正进入 16MB 的块;大数组直接 operator new。
这是一个容易被忽略的性能特征:如果你的场景全是小网格(每个几百个三角形),它们会挤在 DATA 块里,局部性极好;如果全是高模(每个几 MB),它们各自独立分配,局部性差,但至少不会因为块碎片而浪费。
2.2.5 分配与释放的路径
allocate 的入口先看亲和性:allocatorMemoryBlocks[affinity] 没有条目就新建一个 MemoryBlocks,再交给它分配;尺寸超过 maximumAllocationSize 就直接 operator new,否则在块内遍历自由链表、找最佳适配槽、按需分裂、标记已分配并返回指针。deallocate 走反向:先按地址范围判断 ptr 是否真的属于某个 MemoryBlock,再标记空闲、与相邻槽合并、插回自由链表。
注意 deallocate 需要 size 参数(虽然默认值是 0,见 include/vsg/core/Allocator.h:57)。如果传 0,分配器只能靠槽头里记录的信息推断大小——这要求槽头在释放时仍然有效。VSG 的 operator delete 不带 size(C++ 的 operator delete(void*) 签名),所以实际上 deallocate 收到的是 0,靠槽头反推。这也是为什么槽头必须保留在已分配槽里。
2.2.6 一个具体的分配序列
假设一个 1MB 的 NODES 块,alignment=8,初始状态是 4 个各 32,768 单元的空闲槽。现在依次分配:
1. new Group() → 40 字节(Object 24 + children vector 16?实际更大,见下)
2. new MatrixTransform() → 200 字节(含 dmat4)
3. new Group() → 40 字节
4. delete (1)
5. new LOD() → 120 字节
分配 1 时,块内第一个槽被分裂成"已分配 40 字节 + 空闲 32,728 单元"。分配 2 时,从剩余空闲部分继续切。分配 4 释放后,那块 40 字节变成空闲槽,插回自由链表(可能成为一个小碎片)。分配 5 时,最佳适配会优先选那个 40 字节的碎片吗?不会——LOD 需要 120 字节,40 字节不够,于是跳过,从大槽里切。
这就是外部碎片的来源:释放的小块可能永远无法被复用(如果后续没有同样大小的分配),而合并只在前后邻居都空闲时发生(src/vsg/core/IntrusiveAllocator.cpp:493)。VSG 的缓解手段是"合并":如果释放的槽与相邻空闲槽相邻,就合并成更大的槽。但由于槽头记录的是相对偏移,合并需要更新相邻槽的指针,这是一次 O(1) 的操作。
(MemoryBlock 的完整 allocate/deallocate 实现有 400 多行,包含大量边界检查与 #if DEBUG_ALLOCATOR 的诊断输出。本节只讲结构与不变量,逐行分析留到 2.6 节的"调试与验证"。)
2.3 中途小结:三个数字
收三个数:槽头 4 字节、最小分配 12 字节(3 个 Element)、单次上限 131,064 字节。下一节换到 GPU 侧:同样的"子分配"问题,那边用三张 map。
2.4 MemorySlots:GPU 侧子分配为什么用 multimap
IntrusiveAllocator 管的是 CPU 内存。GPU 内存(VkDeviceMemory)的子分配用的是另一套实现:MemorySlots(include/vsg/core/MemorySlots.h、src/vsg/core/MemorySlots.cpp)。
为什么不用同一套?因为两者的约束完全不同:
| 维度 | CPU 侧(IntrusiveAllocator) | GPU 侧(MemorySlots) |
|---|---|---|
| 元数据位置 | 块内 intrusive(4 字节/次) | 堆上的 std::map(约 48 字节/节点) |
| 分配频率 | 每帧可能几万次 | 每帧几次(资源创建期) |
| 对齐要求 | 8/16 字节 | 由 VkPhysicalDeviceLimits 决定,可达 256 字节 |
| 生命周期 | 跟随 ref_ptr | 跟随 DeviceMemory,整块释放 |
| 碎片容忍度 | 低(长时间运行) | 中(重新分配代价高但可接受) |
一句话:CPU 侧要"快且省",GPU 侧要"对且可审计"。GPU 侧每次分配都要满足 Vulkan 的对齐规则,还要能报告"这块 64MB 设备内存被谁切成什么样",用 map 换来可读性和正确性是划算的。
2.4.1 三个 map 的分工
class VSG_DECLSPEC MemorySlots
{
public:
using OptionalOffset = std::pair<bool, size_t>;
OptionalOffset reserve(size_t size, size_t alignment);
bool release(size_t offset, size_t size);
bool full() const { return _availableMemory.empty(); }
size_t maximumAvailableSpace() const { return _availableMemory.empty() ? 0 : _availableMemory.rbegin()->first; }
protected:
std::multimap<size_t, size_t> _availableMemory; // size -> offset(按大小排序,best-fit)
std::map<size_t, size_t> _offsetSizes; // offset -> size(按偏移排序,合并用)
std::map<size_t, size_t> _reservedMemory; // offset -> size(已分配,审计用)
size_t _totalMemorySize;
};
三个容器,同一个事实的三种视图(总量记在 _totalMemorySize,include/vsg/core/MemorySlots.h:72):
_availableMemory(multimap<size, offset>):按大小排序,lower_bound(size)直接找到"第一个足够大的空闲槽",最大空闲则用rbegin()取(include/vsg/core/MemorySlots.h:52)。用multimap而不是map,是因为可能出现两个大小相同、偏移不同的空闲槽。_offsetSizes(map<offset, size>):按偏移排序,用于释放时找"前一个/后一个相邻槽"以合并,删除也按 offset 直接erase(src/vsg/core/MemorySlots.cpp:136)。_reservedMemory(map<offset, size>):已分配记录,用于审计、totalReservedSize()和"释放时校正 size"。
三个容器的起点只有一个动作:把整块内存登记成一个空闲槽,insertAvailableSlot(0, availableMemorySize)(src/vsg/core/MemorySlots.cpp:33),再把总量记进 _totalMemorySize(src/vsg/core/MemorySlots.cpp:35)。此后 _totalMemorySize 不再被分配器改写,只在 check() 里被 computedSize != _totalMemorySize 校验一次(src/vsg/core/MemorySlots.cpp:99)。
两个统计函数取的字段还不是同一个:totalAvailableSize() 累加 sizeOffset.first(src/vsg/core/MemorySlots.cpp:64,因为 _availableMemory 的 key 才是大小),totalReservedSize() 累加 sizeOffset.second(src/vsg/core/MemorySlots.cpp:74,因为 _reservedMemory 是 offset → size)。两个 map 的键值方向相反,抄错一处就恒得 0。
为什么"空闲槽"要同时存在两个 map 里?因为它们服务两个不同的查询:
- 分配时问"谁够大" → 按大小查(
_availableMemory) - 释放时问"谁挨着我" → 按偏移查(
_offsetSizes)
如果只用其中一个,另一类查询就要 O(n) 遍历;removeAvailableSlot 就是这种"按 size 定位、按 offset 核对"的混合查询(src/vsg/core/MemorySlots.cpp:138)。这是典型的用空间换查询复杂度:每个空闲槽多存一份 16 字节的 map 节点,换来 O(log n) 的分配与合并。
2.4.2 reserve:最佳适配 + 对齐检查
MemorySlots::OptionalOffset MemorySlots::reserve(size_t size, size_t alignment)
{
if (full()) return OptionalOffset(false, 0);
auto itr = _availableMemory.lower_bound(size); // 第一个 >= size 的槽
while (itr != _availableMemory.end())
{
size_t slotSize = itr->first;
size_t slotStart = itr->second;
size_t slotEnd = slotStart + slotSize;
size_t alignedStart = ((slotStart + alignment - 1) / alignment) * alignment;
size_t alignedEnd = alignedStart + size;
if (alignedEnd <= slotEnd) // 对齐后仍放得下
{
removeAvailableSlot(slotStart, slotSize); // 摘掉原槽
if (slotStart < alignedStart) // 前导碎片:对齐浪费的部分
insertAvailableSlot(slotStart, alignedStart - slotStart);
if (alignedEnd < slotEnd) // 尾部剩余
insertAvailableSlot(alignedEnd, slotEnd - alignedEnd);
_reservedMemory.emplace(alignedStart, size);
return {true, alignedStart};
}
else
{
++itr; // 这个槽对齐后放不下,试下一个
}
}
return {false, 0};
}
这段代码有四个值得注意的点:
(1)为什么用 lower_bound 而不是 upper_bound。
lower_bound(size) 返回第一个键 ≥ size 的槽,也就是"最小的、够大的槽"——这是最佳适配(best fit)。最佳适配的优点是碎片小(不会把一个大槽切成两半只用了 10%),缺点是会产生大量"刚好差一点"的小碎片。upper_bound 是"严格大于",会跳过大小完全相等的槽,没有意义——它在另一处才用得上:按大小定位同尺寸的槽再比对 offset(src/vsg/core/MemorySlots.cpp:137)。
(2)为什么 lower_bound 之后还要 ++itr(src/vsg/core/MemorySlots.cpp:193)。
因为对齐会吃掉空间:1000 字节的槽起始于 offset 100、要 900 字节、对齐 256 时,alignedStart = 256、alignedEnd = 1156 > 1100,失败——尽管槽有 1000 字节。
所以 reserve 必须继续往后找,直到找到一个"对齐后仍放得下"的槽。最坏情况是遍历所有空闲槽(O(n)),但因为空闲槽数量通常很少(十几个),实际开销可以忽略。
(3)前导碎片不浪费。
if (slotStart < alignedStart) 把对齐浪费的前几个字节重新插回空闲表。这些碎片很小(< alignment),几乎不可能被再分配,但保留它们能让 _offsetSizes 的"所有槽之和 = 总大小"这个不变量成立,从而让 check() 能验证正确性。
(4)返回值是 pair<bool, size_t> 而不是 size_t(include/vsg/core/MemorySlots.h:44)。
因为 offset 0 是合法的分配结果,不能用 0 表示失败。OptionalOffset 用 bool 显式表达成功与否。这是一个小而重要的 API 设计:不要用哨兵值表示错误。
2.4.3 对齐值从哪来
reserve 的 alignment 参数不是随便传的。以 BufferInfo.cpp 为例(src/vsg/state/BufferInfo.cpp 第 236–238 行):
if (descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER || ...)
alignment = device->getPhysicalDevice()->getProperties().limits.minUniformBufferOffsetAlignment;
else if (descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER || ...)
alignment = device->getPhysicalDevice()->getProperties().limits.minStorageBufferOffsetAlignment;
这是 Vulkan 规范要求的:uniform buffer 的绑定偏移必须是 minUniformBufferOffsetAlignment 的倍数,同一文件里 createHostVisibleBuffer 按 usage 分派这三档(src/vsg/state/BufferInfo.cpp:235)。这个值在硬件上从 4(部分 AMD)到 64(NVIDIA/Intel)到 256(Apple Silicon 经 MoltenVK)不等,minStorageBufferOffsetAlignment 普遍是 4–16,两者不能混用;不遵守时验证层报 VUID-vkBindDescriptorSets-pDescriptorSets-01979。
一个 256 字节的对齐意味着:每分配一个 UBO,平均浪费 128 字节。1 万个材质、每个 UBO 64 字节,用"每材质一个 buffer"会浪费 1.25MB;用 MemorySlots 塞进一个 64MB 的 VkDeviceMemory,浪费量级相同,但绑定次数不变(仍要 1 万次 vkCmdBindDescriptorSets)。
所以 VSG 的真正优化不是"省内存",而是第 8 章的 ResourceRequirements:把 1 万个小 UBO 合并成几个大 buffer,用一个动态偏移的 descriptor 绑定。MemorySlots 只是让这个合并成为可能的基础设施。
2.4.4 release:双向合并
bool MemorySlots::release(size_t offset, size_t size)
{
auto itr = _reservedMemory.find(offset);
if (itr == _reservedMemory.end()) return false; // 不是我们分配的
if (size != itr->second) size = itr->second; // 以记录为准
_reservedMemory.erase(itr);
if (_offsetSizes.empty()) { insertAvailableSlot(offset, size); return true; }
size_t slotStart = offset;
size_t slotEnd = offset + size;
auto next_slot_itr = _offsetSizes.lower_bound(slotStart);
if (next_slot_itr != _offsetSizes.end())
{
if (next_slot_itr != _offsetSizes.begin())
{
auto prev_slot_itr = next_slot_itr; --prev_slot_itr;
if (prev_slot_itr->first + prev_slot_itr->second == slotStart) // 与前一个相邻
{
slotStart = prev_slot_itr->first;
removeAvailableSlot(prev_slot_itr->first, prev_slot_itr->second);
}
}
if (next_slot_itr->first == slotEnd) // 与后一个相邻
{
slotEnd = next_slot_itr->first + next_slot_itr->second;
removeAvailableSlot(next_slot_itr->first, next_slot_itr->second);
}
}
else { /* 没有后继:只检查前一个 */ }
insertAvailableSlot(slotStart, slotEnd - slotStart);
return true;
}
三个细节:
-
size参数可以被忽略。如果调用方传的size与记录不符,代码用_reservedMemory里的记录值覆盖(src/vsg/core/MemorySlots.cpp:222)。这是"以分配器为准"的防御性设计:用户传错 size 不会破坏空闲表。默认参数size = 0就是这个意思——"我不确定,你查记录"。 -
合并在插入之前。先把前后相邻的空闲槽摘掉、扩展
[slotStart, slotEnd),再插入一个新槽(src/vsg/core/MemorySlots.cpp:283)。如果先插入再合并,就要处理"自己和自己相邻"的边界情况。 -
lower_bound(slotStart)的语义。它返回第一个 offset ≥slotStart的槽(src/vsg/core/MemorySlots.cpp:250),所以"前邻"要再--一次才拿到。如果恰好等于slotStart,说明有一个空闲槽的起点与被释放区间的起点重合——这在正常情况下不应该发生(重叠分配),但代码没有断言,而是继续处理(next_slot_itr->first == slotEnd为 false,不合并)。这是一个未定义行为的入口:如果调用方 double-free,空闲表会被破坏,check()会在下一次调用时报错。
2.4.5 三级内存追踪
MemoryTracking 有三个级别:
enum MemoryTracking
{
MEMORY_TRACKING_NO_CHECKS = 0,
MEMORY_TRACKING_REPORT_ACTIONS = 1,
MEMORY_TRACKING_CHECK_ACTIONS = 2,
MEMORY_TRACKING_DEFAULT = MEMORY_TRACKING_NO_CHECKS
};
NO_CHECKS:生产默认,零开销。REPORT_ACTIONS:每次reserve/release打印一行日志(含 offset/size),入口在构造函数第一句(src/vsg/core/MemorySlots.cpp:28)。CHECK_ACTIONS:每次操作后调用check(),验证"所有空闲槽 + 所有已分配槽 = 总大小"。
check() 的价值在于它是一个全局不变量检查:
bool MemorySlots::check() const
{
if (_availableMemory.size() != _offsetSizes.size())
warn("... _availableMemory.size() != _offsetSizes.size()");
size_t availableSize = 0;
for (auto& [offset, size] : _offsetSizes) availableSize += size;
size_t reservedSize = 0;
for (auto& [offset, size] : _reservedMemory) reservedSize += size;
size_t computedSize = availableSize + reservedSize;
if (computedSize != _totalMemorySize) { warn(...); return false; }
return true;
}
如果某个槽被"漏掉"(既不在空闲表也不在已分配表),computedSize 就会小于 _totalMemorySize;如果某个槽被重复插入,就会大于。这个检查能抓住 90% 的子分配器 bug,代价是 O(n) 遍历。
实践建议:在单元测试里把 memoryTracking 设为 CHECK_ACTIONS(include/vsg/core/MemorySlots.h:62),跑一遍"分配-释放-再分配"的序列。这比事后查"为什么显存泄漏"便宜得多。
2.4.6 两类分配器的对比总结
| 问题 | IntrusiveAllocator | MemorySlots |
|---|---|---|
| 元数据放哪 | 块内 4 字节槽头 | 堆上 map 节点(约 48 字节) |
| 查找结构 | 位域双向链表 + 4 个槽 | multimap 按大小 + map 按偏移 |
| 分配策略 | 首次适配(块内顺序扫描) | 最佳适配(lower_bound) |
| 合并时机 | 释放时立即合并 | 释放时立即合并(双向) |
| 对齐 | 固定(块创建时) | 每次分配传入 |
| 典型对象数 | 百万级 | 几十到几百 |
| 失败行为 | 申请新块,几乎不失败 | 返回 {false, 0},由调用方申请新 DeviceMemory |
2.5 Data/Array:stride、ModifiedCount 与 DataVariance
讲完分配器,回到"被分配的东西"。Data 是 VSG 里所有 CPU 侧数据的基类,它的设计回答了三个问题:数据长什么样、数据有没有变、数据什么时候该上传。
2.5.1 Properties:一个结构体装下所有格式信息
struct VSG_DECLSPEC Properties
{
VkFormat format = VK_FORMAT_UNDEFINED;
uint32_t stride = 0;
uint8_t mipLevels = 0;
uint8_t blockWidth = 1;
uint8_t blockHeight = 1;
uint8_t blockDepth = 1;
uint8_t origin = TOP_LEFT;
int8_t imageViewType = -1;
DataVariance dataVariance = STATIC_DATA;
AllocatorType allocatorType = ALLOCATOR_TYPE_VSG_ALLOCATOR;
};
逐字段解释,因为每个字段都对应一个 Vulkan 概念:
| 字段 | 对应 Vulkan | 说明 |
|---|---|---|
format | VkFormat | 像素/顶点格式。顶点数组通常留 UNDEFINED,由 VertexInputState 决定 |
stride | VkVertexInputBindingDescription::stride | 相邻元素间隔。0 表示"紧凑"(= sizeof(T)) |
mipLevels | VkImageCreateInfo::mipLevels | 0 表示只有一级 |
blockWidth/Height/Depth | 块压缩格式的块尺寸 | BC1 是 4×4×1,ASTC 可以是 8×8;类型层面的落点是 8 字节的 block64(include/vsg/core/Data.h:42)与 16 字节的 block128(include/vsg/core/Data.h:48) |
origin | 纹理坐标原点 | TOP_LEFT 对应 Vulkan 默认,BOTTOM_LEFT 需要翻转 V |
imageViewType | VkImageViewType | -1 表示"未指定",由 dimensions() 推断 |
dataVariance | 无(VSG 自己的概念) | 数据变化频率,决定上传策略 |
allocatorType(include/vsg/core/Data.h:136) | 无 | 这份数据用哪种分配器(可覆盖全局单例) |
注意 stride 的语义:它是"字节步长",不是"元素个数",stride() 在 0 时退回 valueSize()(include/vsg/core/Data.h:201)。Array<vec3> 的 valueSize() 是 12,如果 stride 是 32,说明每 32 字节取一个 vec3,中间 20 字节是别的属性(法线、UV)——这就是交错顶点缓冲(interleaved vertex buffer)。
bool contiguous() const { return valueSize() == properties.stride; }
uint32_t stride() const { return properties.stride ? properties.stride : static_cast<uint32_t>(valueSize()); }
contiguous() 是一个高频查询(include/vsg/core/Data.h:199):如果数据紧凑,可以直接 memcpy 上传;如果不紧凑,需要逐元素拷贝或让 GPU 按 stride 读。
2.5.2 stride_iterator:为什么 Array 的迭代器不是 T*
template<typename T>
struct stride_iterator
{
value_type* ptr;
uint32_t stride; // 字节步长
inline void advance()
{
ptr = reinterpret_cast<value_type*>(reinterpret_cast<uint8_t*>(ptr) + stride);
}
stride_iterator& operator++() { advance(); return *this; }
value_type& operator*() { return *reinterpret_cast<value_type*>(ptr); }
};
如果 Array<T> 的迭代器是 T*,那么 ++it 会前进 sizeof(T) 字节——只适用于紧凑数组,而 advance() 走的是 ptr + stride(include/vsg/core/Data.h:84)。stride_iterator 让同一个 Array<T> 既能表示紧凑数据,也能表示交错数据,还能表示"从某个大 buffer 的偏移处开始的视图"。
这就是 Array 的第四个构造函数的意义:
Array(ref_ptr<Data> data, uint32_t offset, uint32_t stride, uint32_t numElements,
const Properties& in_properties = {}, MipmapLayout* mipmapLayout = nullptr);
它不分配内存,只是指向 data 的 offset 处,用 stride 步长读 numElements 个元素(include/vsg/core/Array.h:274)。_data 的赋值需要看 assign() 的实现,但语义是明确的:这是一个视图(view),不拥有底层存储。
用途:
- 交错顶点缓冲:一个
Array<uint8_t>装整个 VBO,然后用多个Array<vec3>视图分别指向 position/normal/uv 的偏移。 - 索引子集:从一个大索引数组里取一段。
- 共享内存:多个
Data指向同一个ref_ptr<Data>,避免拷贝。
陷阱:视图对象的生命周期依赖底层 Data,因为 assign 会把 storage 存进 _storage(include/vsg/core/Array.h:269)。Array 的 _data 是裸指针 T* 还是 ref_ptr<Data>?如果是裸指针,底层 Data 被释放后视图就悬空了。VSG 的处理方式是:视图内部持有 ref_ptr<Data>(需要通过 assign 确认),但 dataPointer() 返回的仍是裸指针——调用方必须保证 Data 对象活着。这是"零拷贝"必然要付的代价。
2.5.3 ModifiedCount:三元组的变更检测
struct ModifiedCount
{
uint32_t count = 0;
bool operator==(const ModifiedCount& rhs) const { return count == rhs.count; }
void operator++() { ++count; }
};
void dirty() { ++_modifiedCount; }
bool getModifiedCount(ModifiedCount& mc) const
{
if (_modifiedCount != mc) { mc = _modifiedCount; return true; }
return false;
}
这是一个**版本号(version stamp)**模式。TransferTask 在每次上传前做:
ModifiedCount mc;
if (data->getModifiedCount(mc)) // 变了
{
// 重新上传,并把 mc 更新为当前值
}
为什么不用 bool _dirty?因为布尔标志需要"读后清",而 ModifiedCount 只有 operator++ 一个写入口(include/vsg/core/Data.h:38),而"读后清"在多线程下有竞态:两个线程都读到 true,都去上传;或者一个线程清了标志,另一个线程的修改被漏掉。版本号是只增不减的,读取方各自保存自己看到的版本,天然支持多读者。
接口上还有两个旁路值得分清:getModifiedCount 会顺手把版本写回调用方(include/vsg/core/Data.h:209),而 differentModifiedCount 只比较、不写回(include/vsg/core/Data.h:221)——前者适合"我要跟上它",后者适合"我只想知道变没变"。另一个常被忽略的是 dataRelease()(include/vsg/core/Data.h:185):纯虚函数,让数据在传完之后主动把自己交出去,STATIC_DATA_UNREF_AFTER_TRANSFER 就是靠它落地的。
代价是 ModifiedCount::count 会回绕(40 亿次修改后,include/vsg/core/Data.h:33)。对于一个每帧改几次的动画,这需要 1000 万帧(约 46 小时 @60fps)才回绕一次。回绕时可能出现"修改被漏掉",但实际上不可能有程序连续跑 46 小时还在改同一个数组的同一个数据。这是一个用概率换简洁的设计。
2.5.4 DataVariance:四种上传策略
enum DataVariance : uint8_t
{
STATIC_DATA = 0, // 永不变,上传一次
STATIC_DATA_UNREF_AFTER_TRANSFER = 1, // 上传后释放 CPU 数据
DYNAMIC_DATA = 2, // 每帧可能在 record 前改变
DYNAMIC_DATA_TRANSFER_AFTER_RECORD = 3 // 在 record 期间改变,record 后上传
};
四个值的区别在"什么时候上传"和"上传后 CPU 数据还留不留":
| 值 | 上传时机 | CPU 数据 | 典型用途 |
|---|---|---|---|
STATIC_DATA | 编译时一次 | 保留 | 静态模型顶点、纹理 |
STATIC_DATA_UNREF_AFTER_TRANSFER(include/vsg/core/Data.h:62) | 编译时一次 | 释放 | 大纹理、一次性加载的模型(省内存) |
DYNAMIC_DATA | 每帧 record 之前 | 保留 | 每帧更新的 UBO、粒子位置 |
DYNAMIC_DATA_TRANSFER_AFTER_RECORD | 每帧 record 之后 | 保留 | record 期间才算出最终值的 UBO |
dynamic() 的定义是 properties.dataVariance >= DYNAMIC_DATA(include/vsg/core/Data.h:171),也就是后两个值为 true。
这里有一个非常容易踩的坑:STATIC_DATA_UNREF_AFTER_TRANSFER 会在上传后调用 dataRelease() 把 CPU 数据释放掉。如果你之后还想读它(比如做拾取、做碰撞检测),会拿到空指针。这个标记适合"只用于渲染、不需要 CPU 回读"的数据——大纹理是典型。
另一个坑:DYNAMIC_DATA 每帧都要上传,数据量大时(100 万个粒子位置 = 每帧 12MB)会吃掉带宽。正确做法是 DYNAMIC_DATA + 持久映射的 staging buffer,或 device-local + vkCmdUpdateBuffer;BufferInfo 支持这些路径,但要显式配置(第 8 章)。
2.5.5 Array<T> 的内存布局
template<typename T>
class Array : public Data
{
T* _data;
uint32_t _size;
// 继承自 Data:Properties properties; ModifiedCount _modifiedCount;
// 继承自 Object:atomic_uint _referenceCount; Auxiliary* _auxiliary;
};
三个成员的分工要看清:_data 是裸数据指针(include/vsg/core/Array.h:380),_storage 只在"视图"场景非空,storage() 直接把它交出去(include/vsg/core/Array.h:337),而 clear() 会把 _size、_data、_storage 三者一起清零(include/vsg/core/Array.h:219)。释放路径的第一道判断因此是 if (!_storage && _data)(include/vsg/core/Array.h:366):有 _storage 说明这段内存属于别人,只清视图不释放;没有存储才按 allocatorType 走 delete[]、std::free 或 vsg::deallocate。
在 LP64 上估算一下 sizeof(Array<vec3>)(按成员逐个累加,含对齐填充;不同 ABI 可能差 4–8 字节):
| 部分 | 字节(估算) |
|---|---|
Object(vptr + refcount + auxiliary) | 24 |
Data(Properties 约 24 + ModifiedCount 4 + padding) | 32 |
Array 自身(T* _data 8 + uint32_t _size 4 + padding 4) | 16 |
| 合计 | 约 72 |
也就是说,一个"10 万个 vec3"的数组,对象头占 72 字节(sizeofObject() 报的就是这个数,include/vsg/core/Array.h:145),数据占 1.2MB。对象头可以忽略。
但如果你的场景有 100 万个小数组(比如每个粒子一个 Array<float>,只有 4 个元素),对象头就占了 72MB,比数据本身(16MB)还大 4 倍。这是 VSG 不适合"海量微小对象"的地方——它假设的是"少量大数组",而不是"海量小数组"。
2.5.6 大数组绕过内存池
回到 2.2.4 的结论:单次分配上限 131,064 字节。一个 Array<vec3> 有 10 万个元素,数据是 1.2MB,超过上限,走系统 operator new(std::align_val_t)。
这意味着:
- 大数组的对齐由
std::align_val_t保证(通常是 16 或 64 字节)。 - 大数组不受
DATA块的 16MB 限制,可以任意大。 - 大数组的局部性由操作系统决定,不在 VSG 的控制范围内。
一个有意思的推论:"中等大小"的数组(几十 KB 到 128KB)是最适合 VSG 内存池的。它们足够大,能摊薄 4 字节槽头的开销;又足够小,能塞进 DATA 块,享受连续布局。典型的例子是骨骼矩阵(每个骨骼 64 字节 × 100 个 = 6.4KB)、材质 UBO(几百字节)、小网格的索引(几 KB)。
2.6 ScratchMemory:给 Vulkan 创建结构体用的栈
ScratchMemory 是一个极简的栈式(bump)分配器,专门用来放"临时但需要地址稳定"的数据。
struct ScratchMemory : public Inherit<Object, ScratchMemory>
{
uint8_t* buffer = nullptr;
uint8_t* ptr = nullptr;
size_t size = 0;
ref_ptr<ScratchMemory> next; // 溢出时链到下一块
template<typename T>
T* allocate(size_t num = 1)
{
if (num == 0) return nullptr;
size_t allocate_size = sizeof(T) * num;
if ((ptr + allocate_size) <= (buffer + size))
{
T* allocated_ptr = reinterpret_cast<T*>(ptr);
ptr = align(ptr + allocate_size); // 对齐到 sizeof(void*)
return allocated_ptr;
}
if (!next) next = ScratchMemory::create(std::max(size, allocate_size));
return next->allocate<T>(num);
}
void release() { ptr = buffer; if (next) next->release(); }
};
2.6.1 它解决什么问题
Vulkan 的创建函数大量使用"结构体链":
VkGraphicsPipelineCreateInfo createInfo{};
createInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
VkPipelineVertexInputStateCreateInfo vertexInput{};
vertexInput.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
// ... 填充 vertexInput 的 pVertexBindingDescriptions / pVertexAttributeDescriptions
createInfo.pVertexInputState = &vertexInput;
// ... 还有 7 个 p*State 指针
这些结构体的特点是:
- 数量多:一条管线要 10 多个结构体,加上嵌套的数组(顶点绑定、属性描述),可能有几十个。
- 生命周期短:只在
vkCreateGraphicsPipelines调用期间有效。 - 地址必须稳定:Vulkan 持有的是指针,如果结构体被移动(比如
std::vector扩容),指针就悬空了。 - 不需要析构:全是 POD。
用 std::vector<VkPipelineVertexInputStateCreateInfo> 会有一个致命问题:扩容时元素被移动,之前取到的指针全部失效。你可以用 reserve() 规避,但代码会变得很脆弱(任何一次 push_back 都可能触发扩容)。
ScratchMemory 的方案是:一次分配一大块 uint8_t[](include/vsg/core/ScratchMemory.h:33),然后像栈一样往上"顶"。allocate<T>() 返回的指针在整个 ScratchMemory 生命周期内永不移动,因为没有任何操作会重排已有数据。
2.6.2 为什么不用 alloca 或 std::pmr
alloca:在栈上分配,函数返回即失效。Vulkan 的结构体链常跨多个辅助函数(createVertexInputState()返回VkPipelineVertexInputStateCreateInfo*),返回后内存就没了;而且默认栈只有 1–8MB,大量管线会爆栈。std::pmr::monotonic_buffer_resource:功能等价,但要 C++17<memory_resource>,每个allocate都带虚调用与异常路径。ScratchMemory是 30 行、零依赖、零异常。
这是一个"够用就好"的经典案例:不需要通用性,只需要"地址稳定 + 快 + 简单"。
2.6.3 链式溢出与 release
当当前块放不下时,allocate 会创建 next 块(大小取 max(size, allocate_size)),再递归下去(include/vsg/core/ScratchMemory.h:71)。这保证了大对象也能放下,但会浪费空间(一个新块只为一个大对象)。
allocate 还有三个决定行为边界的细节:num == 0 直接返回 nullptr 而不推进指针(include/vsg/core/ScratchMemory.h:55),allocate_size 由 sizeof(T) * num 算出且不检查乘法溢出(include/vsg/core/ScratchMemory.h:57),块内放不下就落到链上。块本身用 new uint8_t[bufferSize] 申请(include/vsg/core/ScratchMemory.h:33),析构时 delete[] buffer(include/vsg/core/ScratchMemory.h:42)——所以 ScratchMemory 一旦创建就不会缩容,链上每一节都常驻到根对象析构。
release() 把 ptr 重置到 buffer 开头,并递归重置所有 next(include/vsg/core/ScratchMemory.h:76)。注意它不释放内存——块还在,下次可以复用。这是"每帧重置"的典型用法:
scratch->release(); // 每帧开始
auto* ci = scratch->allocate<VkWriteDescriptorSet>(count);
2.6.4 一个容易忽略的细节:对齐
static uint8_t* align(uint8_t* p)
{
auto alignment = sizeof(p); // 8 字节(64 位)
return reinterpret_cast<uint8_t*>(((reinterpret_cast<size_t>(p) + alignment - 1) / alignment) * alignment);
}
对齐到 sizeof(void*)(8 字节),不是 alignof(std::max_align_t)(16 字节),实现里就是先取 alignment = sizeof(p) 再算出 new_p(include/vsg/core/ScratchMemory.h:48)。这意味着如果 T 需要 16 字节对齐(比如 __m128、dvec4),ScratchMemory 不保证。
对于 Vulkan 的创建结构体,8 字节对齐够用(它们只含指针和 uint32_t)。但如果有人用它分配 SIMD 数据,就会踩坑。这是一个"为特定用途优化"的取舍:省下 8 字节/次的对齐填充,换来一个隐含约束。
2.7 把分配器变成可观测对象:三行代码看清内存分布
前面六节讲的都是机制。这一节讲怎么验证——不是"相信它很快",而是量出"快多少、省多少、碎片在哪"。
2.7.1 report():分配器的自画像
Allocator 提供了一个纯虚的 report(std::ostream&),IntrusiveAllocator 的实现会打印每个 MemoryBlocks 的状态。最小用法:
#include <vsg/all.h>
#include <iostream>
int main()
{
{
// 构造 10 万个节点
auto group = vsg::Group::create();
for (int i = 0; i < 100000; ++i)
{
auto mt = vsg::MatrixTransform::create();
group->addChild(mt);
}
// 观察
vsg::Allocator::instance()->report(std::cout);
std::cout << "available = " << vsg::Allocator::instance()->totalAvailableSize() << "\n"
<< "reserved = " << vsg::Allocator::instance()->totalReservedSize() << "\n"
<< "total = " << vsg::Allocator::instance()->totalMemorySize() << std::endl;
}
// 作用域结束后再看一次
vsg::Allocator::instance()->report(std::cout);
return 0;
}
IntrusiveAllocator::report() 的实现会遍历 allocatorMemoryBlocks(按亲和性索引),对每个非空的 MemoryBlocks 调 report,最后调 validate():
void IntrusiveAllocator::report(std::ostream& out) const
{
out << "IntrusiveAllocator::report() " << allocatorMemoryBlocks.size() << std::endl;
for (const auto& memoryBlock : allocatorMemoryBlocks)
{
if (memoryBlock) memoryBlock->report(out);
}
validate();
}
输出大致长这样(不同版本格式略有差异):
IntrusiveAllocator::report() 5
MemoryBlocks::report() ALLOCATOR_AFFINITY_NODES
blockSize = 1048576, memory = 0x7f...
totalMemorySize = 1048576
totalReservedSize = 812344
totalAvailableSize = 236232
largestAvailableBlock = 131064
2.7.2 三个数字的含义
| 方法 | 含义 | 典型关系 |
|---|---|---|
totalMemorySize() | 所有块的总容量(向操作系统要了多少) | ≥ totalReservedSize |
totalReservedSize() | 已被应用占用的字节(含槽头) | 随对象数增长 |
totalAvailableSize() | 块内空闲字节(含碎片) | totalMemorySize - totalReservedSize |
三个数字满足一个恒等式:totalMemorySize = totalReservedSize + totalAvailableSize,三个方法各自独立遍历块内槽链,不共享缓存(include/vsg/core/Allocator.h:69)。
接口里还有个容易 grep 漏掉的细节:判断"块内还能否放下"的函数名拼错了——freeSlotsAvaible,available 少了个字母,声明在 include/vsg/core/IntrusiveAllocator.h:137,定义在 src/vsg/core/IntrusiveAllocator.cpp:104。更要紧的是它的判断口径:先挡掉 size > maximumAllocationSize(src/vsg/core/IntrusiveAllocator.cpp:106),再对每条自由链表只问 freeList.count > 0(src/vsg/core/IntrusiveAllocator.cpp:110)——只要存在任何空闲槽就返回 true,不比较槽大小。它回答的是"有没有空槽",不是"能不能放下这个 size"。
totalAvailableSize 大不代表"内存够用"——它可能全是碎片,因为它按 slot.next - 1 累加,不看连续性(src/vsg/core/IntrusiveAllocator.cpp:674)。真正该看的是 maximumAvailableSpace()(在 MemorySlots 里有,MemoryBlock 里叫 largestAvailableBlock),它告诉你"现在还能一次性分配多大的连续块"。如果这个值持续下降,说明碎片在累积。
2.7.3 块不会自动归还
一个常见困惑:"我删了 90% 的场景,为什么 RSS 没降?"
因为 IntrusiveAllocator 分配的是 1MB/16MB 的块,块内对象释放后,块本身不会还给操作系统——它只是变成"全空"。要让块归还,必须显式调用:
size_t released = vsg::Allocator::instance()->deleteEmptyMemoryBlocks();
这个函数遍历每个 MemoryBlocks,把 totalReservedSize() == 0 的块从局部 memoryBlocks 向量里 swap 出去(src/vsg/core/IntrusiveAllocator.cpp:799),返回的计数是这些块 totalAvailableSize() 之和(src/vsg/core/IntrusiveAllocator.cpp:801)。两处与名字不符:
- 块对象没有销毁。 建块时父类把
shared_ptr存进按地址索引的memoryBlocks表(src/vsg/core/IntrusiveAllocator.cpp:758),这是该表唯一的写入点,全文件没有配对的erase。memoryBlocks.swap只剪掉局部向量,引用计数不归零,~MemoryBlock()里的operator delete(memory, std::align_val_t{blockAlignment})就不会执行(src/vsg/core/IntrusiveAllocator.cpp:101)——进程 RSS 不降。 - 返回值不是块尺寸。
totalAvailableSize()累加slot.next - 1(src/vsg/core/IntrusiveAllocator.cpp:682),既不含槽头也不含块尾对齐余量,比operator new真正拿到的字节少。
它没有自动调用,还因为调用它本身不在锁内:allocate/deallocate 都持 std::scoped_lock(src/vsg/core/IntrusiveAllocator.cpp:910、src/vsg/core/IntrusiveAllocator.cpp:948),deleteEmptyMemoryBlocks() 不持(src/vsg/core/IntrusiveAllocator.cpp:1008)。并发调用等于在别人正在 resize 的向量上做 swap。能落地的结论是:把块表当只增结构,靠进程生命周期回收;真要还给 OS,只能切 ALLOCATOR_TYPE_NEW_DELETE,或自己持有 Allocator 实例——析构 IntrusiveAllocator 时 allocatorMemoryBlocks 整批释放,memoryBlocks 表随之销毁,块才真正 delete。
据此修正调用策略:
- 加载一个大场景后卸载:调用它只让
report()的数字变小,不改变 RSS;要压 RSS 得重启进程或换分配器类型。 - 每帧都在增删对象:不要调用,块马上又会被填满,而且多线程下这一步没有锁保护。
2.7.4 一个可复现的微基准
想量出"内存池 vs 系统分配"的差距,只需要两段相同的循环:一段用默认分配器连做 100 万次 vsg::Group::create(),一段把 Allocator::instance() 换成转发到 operator new/operator delete 的子类再跑一遍,两段都用 std::chrono::steady_clock 计时。VSG 没有内置这样的子类,20 行就能写出——这本身就是接口"容易替换"的证据:instance() 返回的是可写的 std::unique_ptr<Allocator>&(include/vsg/core/Allocator.h:51),而自定义子类只需实现六个纯虚函数(include/vsg/core/Allocator.h:54 起)。
有两个细节必须做对,否则测出来的数字没有意义:分配与释放要分开计时(内存池的优势主要在释放路径,混在一起会被分配路径的构造开销淹没);两组循环的对象数量、保留容量、销毁时机必须完全一致,否则测的是 std::vector 扩容而不是分配器。
真正值得记的不是倍数,而是差距发生在释放阶段:100 万个对象析构时,内存池只把它们插回空闲链表,系统分配器要走合并与 free 的慢路径。任何声称"快 N 倍"的微基准,如果不分别计时分配与释放,都不能作为选型依据。
2.7.5 不要用微基准代替真实测量
微基准能证明"分配器有优势",但不能告诉你"你的应用能快多少":真实瓶颈通常在 GPU 等待、描述符绑定、管线切换。只有 perf/VTune 显示 malloc/free 占比超过 3%、且 heaptrack 报出百万级小分配时,分配器才值得动。
2.8 并发:一把全局锁与它的代价
IntrusiveAllocator 的 allocate/deallocate 各有一把锁,而且这把锁是整个分配器共享的:
void* IntrusiveAllocator::allocate(std::size_t size, AllocatorAffinity allocatorAffinity)
{
if (size == 0) return nullptr;
std::scoped_lock<std::mutex> lock(mutex); // ← 所有线程、所有亲和性共用
// ...
}
这意味着:在多线程加载/编译场景下,内存分配是一个串行点。
这把锁不是 IntrusiveAllocator 自己的成员,而是基类 Allocator 里的 mutable std::mutex mutex(include/vsg/core/Allocator.h:78),所以同一进程内所有亲和性共用它。全文件只有三个加锁点:setBlockSize(src/vsg/core/IntrusiveAllocator.cpp:879)、allocate(src/vsg/core/IntrusiveAllocator.cpp:910)、deallocate(src/vsg/core/IntrusiveAllocator.cpp:948)。而 totalAvailableSize() 根本不加锁(src/vsg/core/IntrusiveAllocator.cpp:1018),它直接遍历 allocatorMemoryBlocks——偏偏 allocate 在遇到新亲和性时会对这同一个 vector 做 resize。一边扩容一边遍历,TSAN 会直接判 data race;这不是理论担忧,而是"统计线程读报表 + 加载线程首次分配 PHYSICS 块"这种顺序就能撞上的。
2.8.1 这把锁影响谁
VSG 的典型多线程场景有三个:
| 场景 | 线程数 | 分配频率 | 锁争用 |
|---|---|---|---|
多线程加载模型(Options::operationThreads) | 4–16 | 高(每解析一个节点一次) | 严重 |
多线程编译(多个 Context) | 2–8 | 中(每个资源一次) | 中等 |
多线程录制(RecordAndSubmitTask) | 2–4 | 低(几乎不分配) | 可忽略 |
第一种最要命:16 个线程同时解析 16 个模型,每个模型 10 万个节点,160 万次分配全部串行通过一把 mutex;一旦发生争用,线程被挂起/唤醒的代价远大于临界区本身。
2.8.2 为什么不分片(sharding)
一个自然的改进是"每个线程一个分配器"(thread-local arena),像 jemalloc/tcmalloc 那样。VSG 没有这么做,原因有三:
- 跨线程释放。A 线程分配的对象可能被 B 线程释放,独立空闲链表就得"归还给 A 的池",需加锁或延迟归还队列。
- 块归属。一个
MemoryBlock里混着多个线程分配的对象,要归还就得为每个槽记归属,又是一份元数据。 - 复杂度 vs 收益。VSG 的目标是"加载期多线程、运行期单线程",加载期多花的锁开销相对 IO 与解码可以忽略。
这是一个务实的判断:优化运行期的每帧路径,而不是加载期的一次性路径。如果你确实需要极速加载,可以自己实现 Allocator 子类(接口只有 6 个纯虚函数),用 thread-local 池。
2.8.3 大对象走的另一条路
注意 allocate 里的这个分支:
if (size <= blocks->maximumAllocationSize)
{
ptr = blocks->allocate(size);
if (ptr) return ptr;
}
ptr = operator new(size, std::align_val_t{blocks->alignment});
if (ptr) largeAllocations[ptr] = std::pair<size_t, size_t>(blocks->alignment, size);
return ptr;
超过 131,064 字节的分配,走 operator new,但仍然在这把锁的保护下,而且要把指针记进 largeAllocations(一个 std::map<void*, pair<size_t,size_t>>)。这意味着:
- 分配一个 10MB 的网格,要加锁 + 一次 map 插入。
- 这个 map 会随着大对象数量增长(10 万个网格 = 10 万个 map 节点 = 约 4.8MB 元数据)。
deallocate时先查这个 map(O(log n)),找不到才去查块。
这解释了为什么"大对象走系统分配"不等于"零开销":VSG 仍然要追踪它们,才能在 deallocate 时知道该用哪个 alignment 释放。
2.8.4 一个真实的争用场景
假设你用 vsg::Options::operationThreads 开了 8 个线程加载 8 个各含 5 万节点的模型:
线程 1..8: read() → 解析 → create Node → allocate(锁)→ ...
↑
所有线程在此排队
在 8 核机器上,你可能观察到 CPU 利用率只有 300%–400%(而不是 800%),剩余时间都花在等锁。用 perf lock 或 perf record -e contention 可以直接看到 vsg::Allocator::mutex 的争用。
缓解手段(不改库):
- 减少线程数。4 个线程往往比 8 个更快,因为锁争用是超线性的。
- 预分配。加载前用
setBlockSize把已有的blockSize改大(src/vsg/core/IntrusiveAllocator.cpp:883)(比如NODES设为 16MB),减少"块不够→申请新块"的次数(虽然每次新块也要加锁)。 - 分批加载。先加载元数据(轻量),再按需加载几何(重量),把并发放到 IO 上而不是分配上。
2.8.5 Object::ref() 的伪共享
还有一个隐蔽的并发问题:Object::_referenceCount 是 std::atomic_uint,位于对象开头(vptr 之后)。如果两个线程频繁 ref/unref 相邻的两个对象,它们可能落在同一个 64 字节缓存行里,导致缓存行在核心之间来回弹跳(false sharing)。
VSG 没有为 _referenceCount 做 padding(那会让每个对象多 60 字节,不可接受)。缓解方式是让对象按创建顺序紧凑排列——这恰好是 IntrusiveAllocator 做的事:连续分配的节点在内存里相邻,但正因为相邻,它们的 refcount 也在同一缓存行。
这是一个无法两全的权衡:
- 紧凑排列 → 遍历快(预取友好),但 refcount 伪共享严重。
- 分散排列 → refcount 独立,但遍历慢。
VSG 选择前者,因为它假设"遍历比引用计数更频繁"。在单线程运行期,这个假设成立;在多线程加载期,refcount 的争用确实存在,但被全局锁掩盖了(都在等锁,伪共享反而不是主要矛盾)。
2.9 从 CPU 数组到 GPU 内存:七步链路
前面讲的是"内存怎么分配"。这一节讲数据怎么从 Array 变成 VkBuffer 里的字节。这条链路有七个环节,每个环节都可能出错。
2.9.1 全景图
① vsg::Data(CPU 内存,可能是 Array<T> 或视图)
│ 绑定
▼
② vsg::BufferInfo(buffer + offset + range + data)
│ 编译
▼
③ vsg::Buffer(VkBuffer 句柄,per-device)
│ 分配
▼
④ vsg::DeviceMemory(VkDeviceMemory + MemorySlots 子分配)
│ 上传
▼
⑤ 映射写入(host-visible)或 staging buffer + vkCmdCopyBuffer(device-local)
│ 同步
▼
⑥ vsg::TransferTask(独立队列 + 信号量)
│ 使用
▼
⑦ vkCmdBindVertexBuffers / vkCmdBindDescriptorSets
2.9.2 ①→②:BufferInfo 是"绑定关系",不是"缓冲区"
class VSG_DECLSPEC BufferInfo : public Inherit<Object, BufferInfo>
{
public:
explicit BufferInfo(Data* in_data);
BufferInfo(Buffer* in_buffer, VkDeviceSize in_offset, VkDeviceSize in_range, Data* in_data = nullptr);
ref_ptr<Buffer> buffer; // 哪个 VkBuffer
VkDeviceSize offset = 0; // 从哪开始
VkDeviceSize range = 0; // 多长
ref_ptr<Data> data; // CPU 侧数据(可能为空)
ref_ptr<BufferInfo> parent; // 父 BufferInfo(用于子分配)
};
BufferInfo 对应 Vulkan 的 VkDescriptorBufferInfo(buffer + offset + range),但它多了一个 ref_ptr<Data> data。这个设计很关键:BufferInfo 同时持有"CPU 数据"和"GPU 绑定"两端,是这条链路的枢纽。
它提供的三个查询把"是否需要工作"变成了可判定问题:
bool requiresAllocation(uint32_t deviceID) const
{
return !buffer || buffer->getDeviceMemory(deviceID) == nullptr;
}
bool requiresCopy(uint32_t deviceID) const
{
return data && data->differentModifiedCount(copiedModifiedCounts[deviceID]);
}
bool syncModifiedCounts(uint32_t deviceID)
{
return data && data->getModifiedCount(copiedModifiedCounts[deviceID]);
}
注意 copiedModifiedCounts 的类型:
vk_buffer<ModifiedCount> copiedModifiedCounts;
这正是第一章 1.1.3 讲的 vk_buffer<T> 特化。单设备构建时,它是一个裸的 ModifiedCount(4 字节);多设备时是一个 std::array<ModifiedCount, N>。每个设备各自记录"我上传到了哪个版本"——这是多 GPU 场景下必须的,因为两个设备的传输时机可能不同。
2.9.3 ②→③:Buffer 是 per-device 的
vsg::Buffer 包装 VkBuffer,但它不是"一个 VkBuffer",而是"每个设备一个 VkBuffer":
class Buffer : public Inherit<Object, Buffer>
{
vk_buffer<VkBuffer> _buffer; // 单设备时就是一个 VkBuffer
// ...
};
这就是为什么 BufferInfo::requiresAllocation(deviceID) 要传 deviceID:同一个 Buffer 对象在不同设备上可能有不同的分配状态。
Buffer 的创建需要 VkBufferCreateInfo:
VkBufferCreateInfo bufferInfo{};
bufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
bufferInfo.size = totalSize;
bufferInfo.usage = usageFlags; // VK_BUFFER_USAGE_VERTEX_BUFFER_BIT 等
bufferInfo.sharingMode = sharingMode; // EXCLUSIVE 或 CONCURRENT
usageFlags 和 sharingMode 不是随便给的:
usageFlags决定这块内存能怎么用。VERTEX_BUFFER | TRANSFER_DST是顶点缓冲的典型组合;漏了TRANSFER_DST,vkCmdCopyBuffer会失败(VUID-vkCmdCopyBuffer-dstBuffer-00024)。sharingMode = CONCURRENT允许跨队列族访问,但可能插入额外同步;EXCLUSIVE更快,代价是VkBufferMemoryBarrier里要做所有权转移。
2.9.4 ③→④:DeviceMemory 与 MemorySlots
VkBuffer 创建后还没有内存。分配流程是:
VkMemoryRequirements memRequirements;
vkGetBufferMemoryRequirements(device, vkBuffer, &memRequirements);
// VSG 的封装
DeviceMemoryOffset offset = memoryBufferPools->reserveMemory(memRequirements, memoryProperties);
vkBindBufferMemory(device, vkBuffer, offset.deviceMemory->vk(deviceID), offset.offset);
reserveMemory 内部做三件事:
- 选内存类型。按
memoryProperties与memRequirements.memoryTypeBits,在VkPhysicalDeviceMemoryProperties里找匹配索引。 - 找或建
VkDeviceMemory。MemoryBufferPools维护几块大设备内存,块内用MemorySlots子分配。 - 返回 offset。调用方拿它绑定
VkBuffer/VkImage。
DeviceMemory.cpp 里的类型选择逻辑是标准的 Vulkan 套路:
uint32_t typeFilter = memRequirements.memoryTypeBits;
// 遍历 memoryTypes,找到 (typeFilter & (1<<i)) && (properties & required) == required 的第一个
这一步最容易出的错是"要了 DEVICE_LOCAL 却忘了 HOST_VISIBLE",然后用 vkMapMemory 去写——验证层会报 VUID-vkMapMemory-memory-00678。
2.9.5 ④→⑤:三条上传路径
VSG 支持三条上传路径,选择取决于数据大小、更新频率、内存属性:
路径 A:host-visible 直接映射(小数据、频繁更新)
void BufferInfo::copyDataToBuffer()
{
// 假设 buffer 的内存是 HOST_VISIBLE | HOST_COHERENT
void* mapped = buffer->getDeviceMemory(deviceID)->map(offset, range);
std::memcpy(mapped, data->dataPointer(), data->dataSize());
// 如果是 HOST_COHERENT,不需要 flush
}
零拷贝、无命令缓冲是优点;host-visible 内存通常不是 device-local,带宽低,只适合"每帧几 KB"的 UBO。
路径 B:staging buffer + vkCmdCopyBuffer(中等数据、一次性上传)
ref_ptr<BufferInfo> copyDataToStagingBuffer(Context& context, const Data* data);
bool createBufferAndTransferData(Context& context, const BufferInfoList& bufferInfoList,
VkBufferUsageFlags usage, VkSharingMode sharingMode);
流程是:创建 host-visible 的 staging buffer → memcpy → vkCmdCopyBuffer 到 device-local buffer → 用 fence 等待完成。中间多了一次拷贝,但 GPU 读 device-local 内存的带宽是系统内存的 5–10 倍。
路径 C:大块预留 + 批量上传(MemoryBufferPools::reserve)
VkResult reserve(const BufferInfoList& bufferInfoList, VkDeviceSize alignment,
VkBufferUsageFlags bufferUsageFlags, VkSharingMode sharingMode,
VkMemoryPropertyFlags memoryProperties);
VkResult reserve(ResourceRequirements& requirements);
这是编译阶段的主力路径:把 BufferInfo 按 usageFlags/sharingMode/memoryProperties 分组,每组一个大 VkDeviceMemory,用 MemorySlots 切成小块,每个 BufferInfo 拿一个 offset。一次 vkAllocateMemory 服务上百个 buffer,正是 Vulkan 的最佳实践(避免每个 buffer 一次分配,撞上驱动的分配上限)。
三条路径的对比:
| 路径 | 拷贝次数 | 适用数据 | 典型大小 |
|---|---|---|---|
| A 直接映射 | 1(memcpy 到映射区) | 每帧更新的 UBO/SSBO | < 64KB |
| B staging | 2(memcpy + vkCmdCopyBuffer) | 一次性加载的网格/纹理 | 64KB – 几十 MB |
| C 批量预留 | 2 + 合并分配 | 编译期所有资源 | 全部 |
2.9.6 ⑤→⑥:TransferTask 为什么要独立队列
上传是"拷贝",不是"渲染"。如果上传和渲染在同一个队列上,就必须串行:拷贝 → 等待 → 渲染。用一个独立的 transfer 队列,可以让上传与上一帧的渲染重叠:
时间 →
主队列: [渲染帧 N-1] [渲染帧 N]
传输队列: [上传帧 N 的资源]
↑ 与渲染并行
TransferTask 持有自己的 VkQueue(从 VK_QUEUE_TRANSFER_BIT 或 GRAPHICS 队列族选)、命令池、fence。它与 RecordAndSubmitTask 通过信号量协调:上传完成 → 渲染等待。
注意:如果设备只有一个队列族(很多集成显卡如此),"独立队列"其实是同一个队列,并行性消失。这时 TransferTask 仍然有用(它把上传命令集中管理),但不会带来实际重叠。
2.9.7 ⑥→⑦:绑定时的 offset 陷阱
最后一步是绑定。顶点缓冲:
VkDeviceSize offsets[] = { bufferInfo->offset };
vkCmdBindVertexBuffers(commandBuffer, 0, 1, &vkBuffer, offsets);
注意 offsets 是字节偏移,不是"第几个顶点"。而且它必须是 VkPhysicalDeviceLimits::minVertexInputBindingStrideAlignment(通常 4)的倍数。
描述符集:
VkDescriptorBufferInfo descriptorInfo{};
descriptorInfo.buffer = vkBuffer;
descriptorInfo.offset = bufferInfo->offset;
descriptorInfo.range = bufferInfo->range;
这里的 offset 必须是 minUniformBufferOffsetAlignment(2.4.3 节)的倍数。这就是为什么 BufferInfo 在子分配时要按描述符类型选对齐:
if (descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER)
alignment = limits.minUniformBufferOffsetAlignment;
else
alignment = limits.minStorageBufferOffsetAlignment;
一个 64 字节的 UBO,在 256 对齐的设备上会占 256 字节;10 万个 UBO 就是 25.6MB 而不是 6.4MB。这是"对齐成本"最容易被低估的地方。
2.9.8 ImageInfo 比 BufferInfo 多出来的三件事
纹理的上传路径比缓冲复杂,因为多了三件事:
- 布局转换。创建时是
VK_IMAGE_LAYOUT_UNDEFINED,上传前转TRANSFER_DST_OPTIMAL,上传后转SHADER_READ_ONLY_OPTIMAL,每次都是一次vkCmdPipelineBarrier。 - 行对齐。
bufferRowLength要满足optimalBufferCopyRowPitchAlignment(通常 256):1920 宽的 RGBA8 每行 7680 字节正好是 256 的倍数,1919 宽则是 7676,要 padding 到 7936,每行浪费 260 字节。 - mipmap 生成。
properties.mipLevels > 1时数据里要含所有 mip 层;computeValueCountIncludingMipmaps()算总元素数,MipmapLayout处理块压缩格式的 mip 尺寸不整除块尺寸的情况。
算一笔账:4K RGBA8 纹理 = 3840×2160×4 = 33.2MB。上传需要:
- CPU 侧
Array<uint8_t>:33.2MB - staging buffer:33.2MB(device memory,host-visible)
- device-local image:33.2MB
- 峰值:约 100MB
如果标了 STATIC_DATA_UNREF_AFTER_TRANSFER,上传后 CPU 侧 33.2MB 由 dataRelease() 交出去(include/vsg/core/Data.h:185),峰值降到约 66MB。这是那个枚举值存在的真正理由——不是为了"省一点内存",而是为了"4K 纹理不要爆内存"。
2.10 内存问题排查手册
这一节是"症状 → 原因 → 手段"的速查表,全部来自 VSG 的实际代码路径。
2.10.1 症状:内存只涨不降
可能原因 1:块没有归还。
IntrusiveAllocator 的块在全空后不会自动释放。调用 deleteEmptyMemoryBlocks()。
可能原因 2:Auxiliary 泄漏。
getOrCreateAuxiliary() 不是线程安全的(1.12.5 节),并发调用会创建两个,其中一个永远不释放。表现为"每帧涨几十字节",很难发现。用 report() 看 OBJECTS 块的 totalReservedSize 是否单调增长。
可能原因 3:largeAllocations 的 map 条目。
大对象(>128KB)走系统分配,但指针记在 largeAllocations 里。如果某个大对象被 release_nodelete() 而不是 unref(),map 条目不会被删除,表现为"每泄漏一个大对象,多 48 字节 + 对象本身"。
可能原因 4:Data 的 STATIC_DATA_UNREF_AFTER_TRANSFER 没生效。
如果你期望上传后释放 CPU 数据,但数据仍被别处 ref_ptr 持有(比如场景图里还有引用),dataRelease() 不会真正释放。检查引用计数。
2.10.2 症状:上传后花屏/错位
原因 A:stride 与 sizeof(T) 不一致。
Array<vec3> 的 properties.stride 为 0 时 stride() 返回 12(紧凑)。手工设成 stride = 16 后,每 16 字节只有前 12 字节有效,后 4 字节是垃圾;若 VertexInputState 仍写 12,就错位。
原因 B:dirty() 没调用。
BufferInfo::requiresCopy() 依赖 ModifiedCount。如果你直接改了 dataPointer() 指向的内存而没调 dirty(),requiresCopy() 返回 false,数据不会上传。这是最常见的"改了没生效"。
原因 C:视图的 offset 没算对。
Array<vec3>(data, offset, stride, count) 的 offset 是字节偏移。如果传了"第几个元素",就会指到错误的位置。
原因 D:range 太大或太小。
BufferInfo::range 决定 vkCmdCopyBuffer 拷贝多少字节。如果 range 大于实际数据,会读到未初始化内存(可能触发验证层);如果小于,数据被截断。
2.10.3 症状:vkMapMemory 失败
原因:内存不是 HOST_VISIBLE。
MemoryBufferPools 按 memoryProperties 分池。如果你从一个 DEVICE_LOCAL 池里拿了内存,再 map,就会失败。检查 BufferInfo 创建时传的 memoryProperties。
在独显上,DEVICE_LOCAL | HOST_VISIBLE 通常存在(Resizable BAR / SAM),但带宽远低于纯 DEVICE_LOCAL。不要因为"能 map"就一直用映射写,那只适合小数据。
2.10.4 症状:ASan 报 heap-use-after-free,但代码看起来没问题
原因:STATIC_DATA_UNREF_AFTER_TRANSFER + 延迟读取。
数据在上传后释放,但你后来做拾取/碰撞检测时又读了它。ASan 会指向 dataRelease() 之后的某次访问。
原因:视图对象比底层 Data 活得久。 Array 用 ref_ptr<Data> _storage 吊住存储(include/vsg/core/Array.h:382),
Array<T>(data, offset, stride, count) 是视图。如果底层 Data 被释放,视图的 dataPointer() 就是悬空指针。这类 bug 在 ref_ptr 的自动管理下很隐蔽,因为视图对象本身是有效的。
2.10.5 症状:验证层报 VUID-VkDescriptorBufferInfo-offset-00342
原因:offset 不是 minUniformBufferOffsetAlignment 的倍数。
见 2.4.3。检查 BufferInfo 分配时的 alignment 参数,以及 MemorySlots::reserve 的返回值是否被正确使用(不要自己加偏移)。
2.10.6 症状:多线程加载时随机崩溃
原因 1:getOrCreateAuxiliary 并发。
见上。
原因 2:Data::dirty() 的 ModifiedCount 是非原子的。
struct ModifiedCount { uint32_t count = 0; };
void dirty() { ++_modifiedCount; }
如果两个线程同时 dirty(),会丢一次自增(读-改-写竞态)。后果是"某次修改没被检测到",表现为"偶尔少上传一帧数据"。VSG 的约定是"数据修改只在单线程(update 阶段)",但如果你在加载线程里改数据,就会踩到。
原因 3:跨线程释放 ref_ptr。
ref_ptr 的 unref 是原子的,本身安全。但如果最后一个 ref_ptr 在非主线程析构,对象会在那个线程被 delete,触发 Allocator::deallocate(加锁,安全)以及可能的 GPU 资源销毁(不安全)。正确做法是用 DeleteQueue 延迟到主线程(第 17 章)。
2.10.7 三个诊断工具的组合
| 工具 | 能回答 | 局限 |
|---|---|---|
Allocator::report() | 各亲和性的总量/峰值/碎片 | 看不到"谁分配的" |
VK_LAYER_KHRONOS_validation | 对齐/属性/生命周期错误 | 不检查 CPU 内存 |
| ASan / heaptrack | CPU 侧越界、泄漏、分配热点 | 与内存池冲突(块内越界检测不到) |
| RenderDoc | GPU 侧 buffer/image 的实际内容 | 看不到 CPU 侧分配 |
perf lock | 分配器锁争用 | 需要 root 权限 |
关键提醒:ASan 与 VSG 的内存池不兼容,因为默认 allocatorType 就是池(include/vsg/core/Allocator.h:28)。内存池一次分配 1MB,池内对象的越界写不会触发 ASan(因为整块是合法的)。要检测池内越界,必须把分配器切成 ALLOCATOR_TYPE_NEW_DELETE(每个对象一次 new),或者用 MemorySlots 的 CHECK_ACTIONS 做逻辑校验。
2.11 布局之战:AoS、SoA 与 Array 视图
内存分配解决"有没有地方放",布局解决"放得对不对"。这一节讨论一个看似微小、实测能差 20%–40% 帧时间的问题:顶点数据该交错存放,还是分开存放?
2.11.1 两种布局
假设每个顶点有 position(vec3)、normal(vec3)、uv(vec2),共 32 字节。
AoS(Array of Structures,交错):
[pos.x pos.y pos.z | nrm.x nrm.y nrm.z | u v | pos.x pos.y pos.z | nrm... ]
└────────── 顶点 0(32B)──────────┘ └────────── 顶点 1 ──────────┘
SoA(Structure of Arrays,分离):
positions: [pos0 | pos1 | pos2 | ...] 每顶点 12B
normals: [nrm0 | nrm1 | nrm2 | ...] 每顶点 12B
uvs: [uv0 | uv1 | uv2 | ...] 每顶点 8B
GPU 的顶点取数(vertex fetch)会为每个属性独立地按 stride 读取。两种布局在功能上完全等价,差别在缓存行利用率。
2.11.2 算一笔缓存账
一个 64 字节的缓存行能装:
| 布局 | 缓存行内容 | 一次 miss 能服务的顶点数 |
|---|---|---|
| AoS(32B/顶点) | 2 个完整顶点 | 2 |
| SoA(position 12B) | 5.33 个 position | 5(剩余 4 字节浪费) |
如果着色器只读 position(阴影 pass 的深度渲染、GPU 剔除),SoA 的效率是 AoS 的 2.5 倍:AoS 每个顶点读 32 字节只用前 12,有效带宽利用率 37.5%;SoA 每顶点读 12 字节,利用率接近 100%。
反过来,如果着色器读所有属性(PBR 主 pass),AoS 更好:一次 miss 拿到完整顶点,下一个顶点大概率已在缓存里;SoA 则要三次独立 miss(position、normal、uv)。
这就是为什么没有绝对正确的布局:
| 场景 | 推荐布局 | 原因 |
|---|---|---|
| 主渲染 pass(读全部属性) | AoS | 一次 miss 服务整个顶点 |
| 阴影/深度 pass(只读 position) | SoA | 带宽利用率高 |
| 计算着色器(只读某一属性) | SoA | 同上 |
| 蒙皮/形变(读 position + 写 position) | SoA | 读写都只碰一个属性 |
2.11.3 VSG 怎么同时支持两种
Array 的视图构造函数是关键:
Array(ref_ptr<Data> data, uint32_t offset, uint32_t stride, uint32_t numElements,
const Properties& in_properties = {}, MipmapLayout* mipmapLayout = nullptr);
AoS 的做法:用一个 Array<uint8_t>(或 Array<Vertex>,如果定义了 POD 结构)装整个 VBO,然后用三个视图指向不同偏移:
struct Vertex { vsg::vec3 position; vsg::vec3 normal; vsg::vec2 uv; }; // 32 字节
auto vertices = vsg::Array<Vertex>::create(count);
// 填数据...
// 三个视图,stride = 32
auto positions = vsg::Array<vsg::vec3>::create(vertices, offsetof(Vertex, position), sizeof(Vertex), count);
auto normals = vsg::Array<vsg::vec3>::create(vertices, offsetof(Vertex, normal), sizeof(Vertex), count);
auto uvs = vsg::Array<vsg::vec2>::create(vertices, offsetof(Vertex, uv), sizeof(Vertex), count);
每个视图的 stride 都是 32,offset 分别是 0/12/24,走的都是同一个 assign(storage, offset, stride, count)(include/vsg/core/Array.h:107)。GPU 看到的是三个绑定,指向同一个 VkBuffer 的不同偏移。
SoA 的做法:三个独立的 Array,各自紧凑:
auto positions = vsg::Array<vsg::vec3>::create(count);
auto normals = vsg::Array<vsg::vec3>::create(count);
auto uvs = vsg::Array<vsg::vec2>::create(count);
每个 Array 的 stride 是 sizeof(T)(12/12/8),contiguous() 返回 true。VertexInputState 里声明三个 binding,各自指向独立的 VkBuffer。
VSG 不强制你选。VertexInputState 只描述"有几个 binding、每个 binding 的 stride 是多少、属性怎么映射",布局由你构造的 Array 决定。这是一个正确的抽象层次:库管机制,你管策略。
2.11.4 vec3 的 16 字节陷阱
vsg::vec3 是 12 字节(三个 float),不是 16。AoS 里 32 字节一个顶点时(pos 12 + nrm 12 + uv 8),顶点 1 的 position 从 [32,44) 开始,不跨行。
如果 stride 是 32,顶点 1 的 position 在 [32, 44),仍在 [0,64) 这一行内。但 stride 是 36 时,顶点 1 的 position 落在 [36,48)、顶点 2 的落在 [72,84)——跨行,每次取 position 可能两次 miss。
这就是为什么很多引擎把顶点 stride 对齐到 16 或 32 的倍数。stride = 48 是一个常见的折中:浪费 16 字节,但保证每个顶点不跨 64 字节行,且所有属性 16 字节对齐(SIMD 友好)。
2.11.5 布局的代价与边界
两条路都要付代价:SoA 在"只读一个属性"的 pass 上省带宽,在"读全部属性"的 pass 上却多付 miss;想两头都占,就得把同一份几何存两遍。VSG 在这个问题上的立场是"不替你选":VertexInputState 只描述 binding 与 stride,布局由你构造的 Array 决定,代价也由你承担。
2.12 实战:写一个可统计的分配器
前面十一节都在读分配器。这一节写一个:一个能按亲和性统计分配次数、峰值、当前占用的 Allocator 子类。这段代码不长,但能暴露所有接口约定。
2.12.1 接口清单
要实现的纯虚函数只有六个:
virtual void* allocate(std::size_t size, AllocatorAffinity allocatorAffinity = ALLOCATOR_AFFINITY_OBJECTS) = 0;
virtual bool deallocate(void* ptr, std::size_t size) = 0;
virtual size_t deleteEmptyMemoryBlocks() = 0;
virtual size_t totalAvailableSize() const = 0;
virtual size_t totalReservedSize() const = 0;
virtual size_t totalMemorySize() const = 0;
virtual void setBlockSize(AllocatorAffinity allocatorAffinity, size_t blockSize) = 0;
virtual void report(std::ostream& out) const = 0;
(report 也是纯虚,所以是七个,见 include/vsg/core/Allocator.h:76。)
设计选择:不重写内存管理,只做统计。真正的分配交给 IntrusiveAllocator,我们的类只记录数字。这就是 nestedAllocator 的用途。
2.12.2 完整实现
#include <vsg/core/Allocator.h>
#include <vsg/core/IntrusiveAllocator.h>
#include <atomic>
#include <iostream>
#include <mutex>
class TrackingAllocator : public vsg::Allocator
{
public:
explicit TrackingAllocator(std::unique_ptr<vsg::Allocator> nested) :
vsg::Allocator(std::move(nested))
{
}
void* allocate(std::size_t size, vsg::AllocatorAffinity affinity) override
{
void* ptr = nestedAllocator->allocate(size, affinity);
if (!ptr) return nullptr;
auto& stats = _stats[static_cast<size_t>(affinity)];
stats.count.fetch_add(1, std::memory_order_relaxed);
size_t current = stats.current.fetch_add(size, std::memory_order_relaxed) + size;
size_t peak = stats.peak.load(std::memory_order_relaxed);
while (current > peak && !stats.peak.compare_exchange_weak(peak, current)) {}
return ptr;
}
bool deallocate(void* ptr, std::size_t size) override
{
if (!ptr) return false;
// 关键:size 为 0 时无法把字节数退回去,见 2.12.3
if (size == 0) return nestedAllocator->deallocate(ptr, 0);
// 即便拿到 size,也不知道 ptr 属于哪个亲和性,只能整体转发
return nestedAllocator->deallocate(ptr, size);
}
size_t deleteEmptyMemoryBlocks() override { return nestedAllocator->deleteEmptyMemoryBlocks(); }
size_t totalAvailableSize() const override { return nestedAllocator->totalAvailableSize(); }
size_t totalReservedSize() const override { return nestedAllocator->totalReservedSize(); }
size_t totalMemorySize() const override { return nestedAllocator->totalMemorySize(); }
void setBlockSize(vsg::AllocatorAffinity affinity, size_t blockSize) override
{
nestedAllocator->setBlockSize(affinity, blockSize);
}
void report(std::ostream& out) const override
{
const char* names[] = {"OBJECTS", "DATA", "NODES", "PHYSICS"};
for (size_t i = 0; i < _stats.size(); ++i)
out << names[i] << " allocs=" << _stats[i].count.load()
<< " current=" << _stats[i].current.load()
<< " peak=" << _stats[i].peak.load() << std::endl;
nestedAllocator->report(out);
}
private:
struct Stats
{
std::atomic<size_t> count{0};
std::atomic<size_t> current{0};
std::atomic<size_t> peak{0};
};
std::array<Stats, vsg::ALLOCATOR_AFFINITY_LAST> _stats;
};
安装:
auto old = std::move(vsg::Allocator::instance());
vsg::Allocator::instance() = std::make_unique<TrackingAllocator>(std::move(old));
注意最后一行:把旧分配器作为 nested 传进去。如果不传,旧分配器分配的所有内存都会在 TrackingAllocator 析构时变成孤儿。
2.12.3 这个实现暴露的三个接口问题
问题一:deallocate 拿不到亲和性。 归属只能靠地址反查,也就是 memoryBlocks.upper_bound(ptr) 那一行(src/vsg/core/IntrusiveAllocator.cpp:960),
deallocate(void* ptr, size_t size) 没有 affinity 参数。这意味着我们的统计只能加、不能减——current 会一直增长,peak 也会失真。
为什么接口这样设计?因为 operator delete(void*) 本来就只有指针,没有类型信息。VSG 的 deallocate 内部靠"在哪个 MemoryBlock 的地址范围内"来推断归属:
auto itr = memoryBlocks.upper_bound(ptr); // 找 ptr 所属的块
但这是 IntrusiveAllocator 的内部知识,Allocator 接口层拿不到。所以一个"完美统计"的包装器必须自己维护 ptr → affinity 的映射——那会把每次分配变成一次 map 插入,性能损失远大于统计收益。
这是一个典型的"抽象泄漏":接口设计时假设"释放只需要指针",但统计需求需要更多信息。VSG 的选择是"接口简单、统计受限",而不是"接口复杂、统计完美"。
问题二:size == 0 的语义模糊。 默认值是接口的一部分(include/vsg/core/Allocator.h:90),
vsg::deallocate(ptr, size = 0) 的默认参数是 0。如果调用方不传 size,包装器无法更新统计。而 VSG 内部的 operator delete 确实不传 size(C++ 的 operator delete(void*) 只有一个参数),所以大部分释放都会走到 size == 0 的分支。
结论:在 VSG 上做精确的内存统计,只能统计"分配",不能统计"当前占用"。想看"当前占用",只能用 nestedAllocator->totalReservedSize()——那是块级别的统计,准确但不精确到对象。
问题三:_stats 的索引越界。
AllocatorAffinity 的最大值是 ALLOCATOR_AFFINITY_LAST(= PHYSICS + 1 = 4),但 allocate 可能被传入任意 uint32_t(枚举没有强类型约束)。IntrusiveAllocator::allocate 里有这个防御:
if (allocatorAffinity > allocatorMemoryBlocks.size())
{
// 动态扩展
allocatorMemoryBlocks.resize(allocatorAffinity + 1);
}
我们的 _stats 是 std::array<Stats, 4>,如果传入 5 就会越界。正确的写法是用 std::vector 并按需扩容,或者在入口做 if (affinity >= ALLOCATOR_AFFINITY_LAST) return nestedAllocator->allocate(...)。
2.12.4 一个更有用的变体:泄漏追踪器
如果目标不是"统计"而是"找出谁没释放",就在包装器的 allocate 里记 _live[ptr] = {size, affinity, capture_stack()},deallocate 里 _live.erase(ptr)。三条约束绕不开:capture_stack() 每次几微秒,只能临时开;erase 对非本分配器来的指针静默失败,报告只覆盖安装之后分配的对象;加锁会把竞态挤走。所以这类工具只能临时插桩,不能常驻——它的成本结构与分配器正好相反。
2.12.5 什么时候值得自己写分配器
满足下面任意两条才值得动手,否则先用 report() 与 setBlockSize() 调优:
perf显示malloc/free/Allocator::allocate占比 > 5%。- 分配次数 > 100 万次/秒。
- 有明显的多线程锁争用(
perf lock显示Allocator::mutex是热点)。 - 需要按"帧"整体释放(帧分配器),而 VSG 没有提供。
否则,先用 report() 和 setBlockSize() 调优,成本低得多。
2.13 十个关于内存的常见误解
这一节收集的是"看起来对、实际错"的说法。每条都给出反例或源码依据。
误解一:vsg::ref_ptr 比 std::shared_ptr 快,是因为它不用原子操作
错。 ref_ptr::ref() 用的是 fetch_add(1, relaxed),unref() 用的是 fetch_sub(1, seq_cst)——都是原子操作。shared_ptr 的计数也是原子的。
真正的差别在三个地方:
- 尺寸:
ref_ptr8 字节,shared_ptr16 字节(对象指针 + 控制块指针),指针数组小一半。 - 零控制块:
ref_ptr的计数在对象内部;shared_ptr(new T)要两次分配(除非make_shared)。 - 无别名指针:
shared_ptr支持 aliasing constructor,必须同时存对象与控制块指针;ref_ptr只存一个。
所以"快"来自内存布局,不是"少了原子操作"。
误解二:用了内存池就不会有碎片
错。 碎片有两种,且都比 malloc 规整:内部碎片下界是每槽 12 字节(3 个 Element),分配 1 字节也占满;外部碎片来自"被已分配槽隔开"的两个空闲槽,相邻的能合并,隔着的不能。内存池真正解决的是分配速度与局部性,不是碎片。想少碎片,应该按生命周期分组分配(同一帧创建的对象放一起、整批释放),而不是指望分配器。
误解三:对象越小,内存效率越高
错。 小对象的问题是每个对象都有固定开销:
| 对象 | 有效数据 | 固定开销 | 效率 |
|---|---|---|---|
Array<float> × 4 元素 | 16 B | 72 B 对象头 + 4 B 槽头 | 17% |
Array<float> × 4000 元素 | 16 KB | 72 B + 4 B | 99.5% |
100 万个"4 元素数组"会消耗 76MB 来存 16MB 数据。正确做法是合并成一个大数组 + 偏移索引,而不是"每个小东西一个对象"。
误解四:reserve() 之后指针就稳定了
只对 ScratchMemory 成立,对 std::vector 不成立。
std::vector::reserve(n) 只保证"容量至少 n 时不重新分配"。一旦 push_back 超过 n,就会扩容、移动所有元素,之前取到的指针全部失效。
ScratchMemory 没有"移动"操作——它只会向后 bump 或新开一块,已有数据永不移位。这就是它能安全承载 Vulkan pNext 链的原因。
推论:如果你的代码里出现 std::vector<SomeVkStruct> 然后取 &vec[i] 传给 Vulkan,就要警惕扩容;正确做法是 reserve 足够大,或者改用 std::deque(不保证连续,但引用稳定),或者干脆用 ScratchMemory。
误解五:dirty() 是给渲染线程发信号
错。 dirty() 只是把 ModifiedCount 加一,没有内存序保证、没有唤醒机制、没有线程安全:
struct ModifiedCount { uint32_t count = 0; };
void dirty() { ++_modifiedCount; }
它的唯一作用是在 TransferTask 下一次检查时,让 BufferInfo::requiresCopy() 返回 true。如果 TransferTask 已经跑过这一帧,你的 dirty() 只会让下一帧上传。
如果两个线程同时 dirty(),可能丢一次自增(读-改-写竞态)。后果不是崩溃,而是"某次修改被合并"——表现为数据偶尔不对,极难复现。
误解六:标了 STATIC_DATA 就永远不会再上传
错。 STATIC_DATA 只是"提示",不是"锁"。如果你改了数据并调用 dirty(),requiresCopy() 依然返回 true,依然会上传。
STATIC_DATA 的真正含义是"我承诺不会改",让 VSG 可以做一些优化(比如不做每帧的 modifiedCount 检查、把数据放到 device-local 而不保留 staging 副本)。违背承诺不会崩溃,只会让优化失效。
误解七:vkAllocateMemory 失败就是显存不够
不一定。 三个常见原因:
- 碎片:总空闲够,但没有足够大的连续块。用
MemorySlots::maximumAvailableSpace()看最大连续空闲。 - 内存类型不匹配:要
DEVICE_LOCAL | HOST_VISIBLE,设备却只有DEVICE_LOCAL。该换上传路径,而不是重试。 - 超过
maxMemoryAllocationCount:部分驱动限制单次分配数量(常见 4096),MemoryBufferPools用大块分配正是为了绕开它。
误解八:对齐只会浪费"一点点"内存
错。 对齐浪费与对象数量成正比,而且系数可能很大。
以 256 字节对齐(Apple Silicon 的 UBO 对齐)为例,每个 64 字节的 UBO 占 256 字节,浪费 192 字节(75%):
| UBO 数量 | 紧凑排列 | 256 对齐 | 浪费 |
|---|---|---|---|
| 1,000 | 64 KB | 256 KB | 192 KB |
| 100,000 | 6.4 MB | 25.6 MB | 19.2 MB |
这就是为什么第 8 章的 ResourceRequirements 要把"同类型、同对齐"的数据合并到一个 buffer,用动态偏移访问——一次对齐,多次复用。
误解九:对象析构了,内存立刻可以复用
对 CPU 成立,对 GPU 不成立。
CPU 侧:ref_ptr 归零 → _attemptDelete() → 判 signalConnectedObjectToBeDeleted() 后 delete this(src/vsg/core/Object.cpp:90) → Allocator::deallocate → 槽标记为空闲。下一次分配可以立刻复用。
GPU 侧:VkBuffer 销毁了,但上一帧的命令缓冲区可能还在引用它。GPU 是异步的,vkDestroyBuffer 只保证"CPU 不再使用",不保证"GPU 已经用完"。Vulkan 的规则是:销毁对象前必须确保"所有使用它的命令都已完成"(通过 fence 或 vkDeviceWaitIdle)。
VSG 的解法是 DeleteQueue + Auxiliary 的删除否决(第一章 1.4.3、第 17 章):对象在 CPU 侧"死了",但真正释放推迟到安全帧边界。这就是为什么 ref_ptr 归零不等于内存立刻可用。
误解十:多线程加载一定更快
错,而且常常更慢。
IntrusiveAllocator::allocate 有一把全局锁(2.8 节)。8 个线程同时分配时,大部分时间在排队。实测中,4 线程往往比 8 线程快 10%–20%,因为锁争用是超线性的(争用概率 ∝ 线程数的平方)。
正确的做法是:
- 先测单线程加载时间,确认瓶颈在 CPU 还是 IO。
- 如果瓶颈是 IO(磁盘/网络),多线程有效,因为线程在等 IO 时不持锁。
- 如果瓶颈是分配/解析,减少线程数,或者用"每线程独立文件 + 最后合并"的策略(避免同时分配)。
2.14 追踪一次分配:从 Group::create() 到 deallocate()
抽象讲完,最后做一次逐字节追踪。目标是把前面所有机制串成一个可复述的故事:一行 auto g = vsg::Group::create(); 到底发生了什么。
2.14.1 第一次分配:对象本身
auto g = vsg::Group::create();
步骤 1:进入 Inherit::create。
template<typename... Args>
static ref_ptr<Subclass> create(Args&&... args)
{
return ref_ptr<Subclass>(new Subclass(std::forward<Args>(args)...));
}
Subclass 是 Group,无参构造。new Group() 先调用 operator new,再调用构造函数。
步骤 2:operator new 走哪条路。
Group 没有声明 operator new,但 Node 声明了:
void* Node::operator new(std::size_t count)
{
return vsg::allocate(count, ALLOCATOR_AFFINITY_NODES);
}
所以这次分配走 NODES 亲和性。count 是多少?算一下 sizeof(Group):
| 部分 | 字节 |
|---|---|
Object:vptr 8 + atomic_uint 4 + padding 4 + Auxiliary* 8 | 24 |
Node:无新增成员 | 0 |
Group:Children children(std::vector 在 libstdc++ 上是 24 字节) | 24 |
| 合计 | 48 |
步骤 3:进入 IntrusiveAllocator::allocate(48, NODES)(src/vsg/core/IntrusiveAllocator.cpp:908 先挡掉 size 0)。
void* IntrusiveAllocator::allocate(std::size_t size, AllocatorAffinity allocatorAffinity)
{
if (size == 0) return nullptr;
std::scoped_lock<std::mutex> lock(mutex); // 加锁
auto& blocks = allocatorMemoryBlocks[allocatorAffinity];
if (blocks)
{
if (size <= blocks->maximumAllocationSize) // 48 ≤ 131064
{
ptr = blocks->allocate(size); // 走块内分配
if (ptr) return ptr;
}
// 否则走 operator new ...
}
}
步骤 4:MemoryBlock::allocate(48) 的算术。
- 块是 1MB,alignment 8,capacity = 131,072 个对齐单元。
- 需要 48 字节数据 + 4 字节槽头 = 52 字节,向上对齐到 8 的倍数 = 56 字节 = 7 个对齐单元。
- 从自由链表里找一个 ≥ 7 单元的槽(初始槽有 32,768 单元),分裂:
分裂前:[空闲 32768 单元]
分裂后:[已分配 7 单元][空闲 32761 单元]
- 已分配槽的头部写入
Element{previous, next, status=已分配},返回槽起始 + 4 字节(跳过槽头)。
步骤 5:构造函数与 ref_ptr 接管。
Object::Object() 把 _referenceCount 置 0、_auxiliary 置 nullptr(src/vsg/core/Object.cpp:26);构造成功后 ref_ptr 的构造函数调用 _ptr->ref(),把计数从 0 推到 1(include/vsg/core/ref_ptr.h:53)。顺序不能反:ref_ptr 构造在 new 表达式返回值之后,所以构造函数抛异常时清理走的是编译器生成的异常路径,而不是 ref_ptr 的析构。
2.14.2 第二次分配:children 的存储
g->addChild(child);
void addChild(vsg::ref_ptr<Node> child) { children.push_back(child); }
children 的类型是:
using Children = std::vector<ref_ptr<Node>, allocator_affinity_nodes<ref_ptr<Node>>>;
注意第二个模板参数:自定义分配器。push_back 第一次触发扩容时,std::vector 会向 allocator_affinity_nodes 申请内存,而它又转发到:
static value_type* allocate(std::size_t n)
{
return static_cast<value_type*>(vsg::allocate(n * sizeof(value_type), A));
}
A 是 ALLOCATOR_AFFINITY_NODES,转发点就是 allocator_affinity_adapter 的 allocate(include/vsg/core/Allocator.h:110)。所以子节点指针数组和节点对象在同一个 NODES 池里,局部性一致。
第一次 push_back 申请 1 个 ref_ptr<Node>(8 字节)+ 4 字节槽头 = 12 字节,走最小分配。第二次 push_back 扩容到 2,第三次到 4,依此类推(libstdc++ 的 vector 按 2 倍增长)。
这就是为什么"一次 addChild 可能触发一次分配":vector 的扩容策略决定了它会在 1、2、4、8、16… 时分配。如果你的场景是"边加载边加子节点",会有大量"分配-拷贝-释放"的抖动。
优化手段:预先 children.reserve(n)(Group 没有暴露这个接口,但你可以直接操作 children 成员——它是 public 的)。
2.14.3 释放:反向的三步
g.reset(); // 或作用域结束
步骤 1:ref_ptr::~ref_ptr → unref()。
if (_referenceCount.fetch_sub(1, std::memory_order_seq_cst) <= 1) _attemptDelete();
计数从 1 变 0,返回 1,<= 1 成立 → _attemptDelete()。
步骤 2:_attemptDelete → delete this。
if (_auxiliary == nullptr || _auxiliary->signalConnectedObjectToBeDeleted())
delete this;
如果对象有 Auxiliary 且它"拒绝删除"(GPU 还在用),这里就不会 delete——对象进入 DeleteQueue,稍后重试(第 17 章)。
步骤 3:析构链。
~Group() → children 析构 → 每个 ref_ptr<Node> 析构 → 子节点 unref
→ ~Node() → ~Object() → _auxiliary->unref()
→ operator delete(this) → vsg::deallocate(ptr) → MemoryBlock::deallocate
MemoryBlock::deallocate 做三件事:
- 把槽标记为空闲。
- 检查前一个/后一个槽是否空闲,能合并就合并。
- 插回自由链表。
注意释放顺序是"先子后父",因为 ~Group() 先析构成员 children,~Array() 才轮到 _delete()(include/vsg/core/Array.h:347):children 是 Group 的成员,在 ~Group() 里被析构,所以子节点先被释放,父对象的槽后释放。这在块内会形成"子对象的槽先空出来、父对象的槽后空出来"的模式,合并时可能产生较大的连续空闲块。
2.14.4 一次完整的字节账
创建 1 个 Group + 1 个子节点(MatrixTransform,约 176 字节,含 dmat4):
| 分配 | 请求 | 槽头 | 对齐后 | 说明 |
|---|---|---|---|---|
Group 对象 | 48 | 4 | 56 | 7 个对齐单元 |
MatrixTransform 对象 | 176 | 4 | 184 | 23 个单元 |
children 数组(1 个 ref_ptr) | 8 | 4 | 16 | 2 个单元 |
| 合计 | 232 | 12 | 256 | 有效利用率 90.6% |
如果走系统 malloc:48→48+16=64,176→192,8→32,合计 288 字节,有效利用率 80.6%。内存池省了约 11% 的空间,更重要的是省了三次 malloc 的元数据管理和缺页。
这个比例在"小对象多"时更高,在"大数组为主"时接近 0。
2.14.5 三个可以带走的结论
三件事可以带走:每个 create() 都是一次 operator new + 一次构造,槽会复用但对象要重新构造,所以"对象池"在 VSG 里不存在;vector 扩容是隐形分配源,一次 addChild 可能触发分配 + memcpy + 释放;释放顺序影响碎片,先子后父的析构会形成"子槽先空、父槽后空",与创建顺序相反时合并最容易成功。
2.15 全章小结:七个数字、四条规则与一张对照表
2.15.1 七个数字
| 数字 | 含义 | 出处 |
|---|---|---|
| 4 字节 | CPU 侧每次分配的槽头开销(已分配槽只用 1 个 Element) | include/vsg/core/IntrusiveAllocator.h:95 |
| 12 字节 | CPU 侧最小分配(空闲槽 3 个 Element) | src/vsg/core/IntrusiveAllocator.cpp:124 |
| 131,064 字节 | CPU 侧单次分配上限 (2^15-2)×4 | include/vsg/core/IntrusiveAllocator.h:173 |
| 32,768 | 单槽最大单元数(1<<15),决定 1MB 块切 4 段 | src/vsg/core/IntrusiveAllocator.cpp:54 |
| ≈48 字节 | GPU 侧每个空闲槽的 map 元数据 | include/vsg/core/MemorySlots.h:65 |
| 8 字节 | ScratchMemory 的对齐粒度(sizeof(void*),不是 16) | include/vsg/core/ScratchMemory.h:47 |
| 1 MB / 16 MB | NODES/OBJECTS 与 DATA 的默认块大小 | src/vsg/core/IntrusiveAllocator.cpp:851 |
2.15.2 四条规则
- 小对象走池,大对象走系统,128KB 是分界线。 大数组进不了池,也别让小对象走
malloc。 - 数据变化频率决定上传策略。
STATIC_DATA一次;STATIC_DATA_UNREF_AFTER_TRANSFER传完就放掉 CPU 数据;DYNAMIC_DATA每帧;DYNAMIC_DATA_TRANSFER_AFTER_RECORD在 record 之后。 - 临时结构体用
ScratchMemory。 地址稳定是创建结构体的硬需求,vector扩容会让pNext链悬空。 - 改数据必须
dirty()。ModifiedCount是唯一触发器;只改dataPointer()不dirty(),数据永远到不了 GPU。
2.15.3 一张对照表:四个内存区域
| 区域 | 谁管理 | 分配粒度 | 典型大小 | 释放时机 |
|---|---|---|---|---|
CPU 对象(Object/Node) | IntrusiveAllocator(src/vsg/core/IntrusiveAllocator.cpp:854) | 4 字节槽头 + 对齐 | 24–200 B | ref_ptr 归零 → _attemptDelete |
CPU 数据(Array<T>) | IntrusiveAllocator(≤128KB)或系统 new | 同上 | B – MB | ref_ptr 归零 |
GPU 缓冲/图像(VkBuffer/VkImage) | MemoryBufferPools + MemorySlots | 按 VkMemoryRequirements 对齐 | KB – 百 MB | DeviceMemory 整块释放 |
| 临时创建结构体 | ScratchMemory(include/vsg/core/ScratchMemory.h:64) | 8 字节 bump(按 allocate_size 前进) | KB | release() 或作用域结束 |
这张表的用法:当你遇到内存问题时,先定位"是哪一类",再查对应的机制。四类的排查手段完全不同——CPU 对象看 report(),GPU 内存看 DeviceMemory 统计,临时内存看 ScratchMemory 的链长。
2.15.4 与后续章节的接口
这一章是后面几章的地基,明确一下接口:
| 后续章节 | 用到的本章概念 |
|---|---|
| 第 6 章 数据结构 | Data/Array/Properties/stride_iterator(include/vsg/core/Data.h:68)/DataVariance |
| 第 8 章 资源需求收集 | BufferInfo 分组、MemoryBufferPools::reserve、MemorySlots 对齐 |
| 第 9 章 管线状态 | Properties::format 如何映射到 VertexInputState |
| 第 12 章 记录遍历 | dirty() 与 requiresCopy() 的时机 |
| 第 13 章 编译遍历 | Context 如何驱动 BufferInfo::compile |
| 第 17 章 同步与延迟删除 | _attemptDelete + Auxiliary 的删除否决 |
2.15.5 本章验证记录
以下结论在 1.1.16 源码上逐条核对:
AllocatorType四值、AllocatorAffinity五值(ALLOCATOR_AFFINITY_LAST是计数不是可用值)—include/vsg/core/Allocator.h:37。vsg::allocate只是Allocator::instance()->allocate的转发,默认亲和性OBJECTS—src/vsg/core/Allocator.cpp:36。- 默认块大小:
DATA16MB、PHYSICS1MB 且对齐硬编码 16 —src/vsg/core/IntrusiveAllocator.cpp:855、src/vsg/core/IntrusiveAllocator.cpp:857。 - 位域
previous:15 / next:15 / status:2,存相对偏移 —include/vsg/core/IntrusiveAllocator.h:90、include/vsg/core/IntrusiveAllocator.h:91。 - 建块时把整块切成
max_slot_size大小的槽并写Element{...}—src/vsg/core/IntrusiveAllocator.cpp:76。 computeMaxiumAllocationSize的定义式 —include/vsg/core/IntrusiveAllocator.h:170。allocatorAffinity越界时的动态扩容,守卫用>而不是>=—src/vsg/core/IntrusiveAllocator.cpp:916。MemorySlots三个容器:_availableMemory、_offsetSizes、_reservedMemory—include/vsg/core/MemorySlots.h:67。reserve里alignedStart的计算与"对齐后放不下就++itr" —src/vsg/core/MemorySlots.cpp:163。- 前导碎片重新插回空闲表 —
src/vsg/core/MemorySlots.cpp:170。 check()只比"和相等";表长度不一致仅warn—src/vsg/core/MemorySlots.cpp:98。- UBO 对齐的兜底值 4,以及两条
limits分支 —src/vsg/state/BufferInfo.cpp:234。 Properties::format默认VK_FORMAT_UNDEFINED、dataVariance默认STATIC_DATA—include/vsg/core/Data.h:127、include/vsg/core/Data.h:135。differentModifiedCount与内部_modifiedCount—include/vsg/core/Data.h:221、include/vsg/core/Data.h:235。- 视图构造把
_storage与_data一起记下,_allocate走ALLOCATOR_AFFINITY_DATA—include/vsg/core/Array.h:265、include/vsg/core/Array.h:361。 ptr + allocate_size与buffer + size的比较,以及next的懒创建 —include/vsg/core/ScratchMemory.h:59、include/vsg/core/ScratchMemory.h:69。BufferInfo::requiresCopy与syncModifiedCounts的差别(前者只看不写)—include/vsg/state/BufferInfo.h:71、include/vsg/state/BufferInfo.h:77。- 分裂阈值取
max(请求单元数, 3),所以每个已分配槽至少占3 个Element—src/vsg/core/IntrusiveAllocator.cpp:156。 freeList.count在建块循环里自增,等于初始槽数 —src/vsg/core/IntrusiveAllocator.cpp:81。validate()用previous_position = position - slot.previous反算邻居并核对 —src/vsg/core/IntrusiveAllocator.cpp:609。IntrusiveAllocator::validate()遍历每个MemoryBlocks,任一失败即整体失败 —src/vsg/core/IntrusiveAllocator.cpp:1001。report()末尾调validate(),但丢弃其返回值 —src/vsg/core/IntrusiveAllocator.cpp:903。deleteEmptyMemoryBlocks()的返回值来自count累加,统计的是可用量 —src/vsg/core/IntrusiveAllocator.cpp:810。
统计类数字(100 万次分配耗时、AoS/SoA 差异)是量级估计,随硬件、编译器、场景而变化,文中已标注"预期/典型",不作为绝对结论。
2.16 后验:四条规则在第 03–27 章的兑现与反例
2.15 的四条规则不是本章内部的自洽陈述,而是对全库其余各章的约束。把它们逐条拿去对照后续章节实测到的源码事实,分界线很清楚:分配器本身遵守规则,使用分配器的上层模块大量绕过规则。
2.16.1 规则一:容器必须有上界,回收必须配平
MemorySlots::release() 的双向合并与 MemorySlots::check()(src/vsg/core/MemorySlots.cpp:79)的不变量校验,是全库唯一显式维护「总量守恒」的地方。后续章节里至少五处容器只增不减:
| 容器 | 位置 | 累积来源 | 破坏本章规则的方式 |
|---|---|---|---|
_availableSemaphores | src/vsg/app/Window.cpp:399–402 | 每次 swapchain 重建追加 | Window::clear()(:52)不清,等价于一株永不 release() 的 slot 树 |
overridePipelineStates | src/vsg/app/RenderGraph.cpp:204 | 每次 MSAA resize emplace_back | 按类型去重掩盖容量增长,合并循环线性变长 |
bufferInfosToCopy | src/vsg/vk/Context.cpp:419–420 | 编译期 insert 追加 | Context::reset()(:170–183)漏清,与 imageInfosToCopy 同源 |
frameIndices / gpuStats | src/vsg/utils/Profiler.cpp:225/277 | 每帧 push_back | 无上限,插桩本身成为内存增长源 |
_vkGeometries 等三容器 | src/vsg/raytracing/BottomLevelAccelerationStructure.cpp:29–41 | 每次 compile 追加 | _geometryPrimitiveCounts 与几何数失配 |
这五处的共同点不是「忘了 clear()」,而是没有把容器长度写进任何不变量检查。本章 check() 用三个 map 交叉校验兜底,上层模块连一个 size() <= cap 的断言都没有。
2.16.2 规则二:分配前必须校验容量与边界
IntrusiveAllocator 在落位前先比上界(src/vsg/core/IntrusiveAllocator.cpp:925 的 size <= blocks->maximumAllocationSize),MemorySlots::reserve() 在摘槽前先比 alignedEnd <= slotEnd(src/vsg/core/MemorySlots.cpp:165)。上层把这一步省掉的四处,各自独立成立,不是同一个缺陷的复述:
Array::data(size_t i)直接算_data + i * properties.stride,at()只是它的转发,两者都没有与_size比较(include/vsg/core/Array.h:326)。JointSampler::apply用同一个joint.index同时索引jointMatrices->set与offsetMatrices[],index来自模型文件,前面没有上界比较(src/vsg/animation/JointSampler.cpp:120)。BinaryInput::_read(std::string&)从流里读uint32_t size之后直接value.resize(size, 0),size未与剩余字节数比较(src/vsg/io/BinaryInput.cpp:29)。StateStack的Stack定长为std::array<const T*, STATESTACK_SIZE>(include/vsg/vk/State.h:38),而push无条件执行stack[++pos](include/vsg/vk/State.h:64),第 16 次push写到的正是紧随stack之后的pos。
四处的共同点是「先写后判」甚至「只写不判」,与本章「先算上界再落位」相反;差别在于越界目标——前两处踩到堆上的邻居对象,第三处踩到 std::string 的容量,第四处踩到自己的成员变量。
2.16.3 规则三:临时内存的生命周期必须闭合
ScratchMemory::allocate<T>() / release() 在第九章 GraphicsPipeline::Implementation 里用得正确:九个 Vk*StateCreateInfo 落在 scratch 上,vkCreateGraphicsPipelines 返回后立即 release()——驱动已拷贝结构体。反面两例:
TransferTask::transferData在 staging 内存map失败后返回TransferResult{VK_SUCCESS, {}},调用方据VK_SUCCESS认为缓冲可用,buffer_data却是空指针(src/vsg/app/TransferTask.cpp:487)。DeleteQueue::advance在取锁之后直接读frameStamp->frameCount,形参是ref_ptr<FrameStamp>,空值不会在解引用前被拦住(src/vsg/threading/DeleteQueue.cpp:36)。
临时内存与对象生命周期的差别在于:前者失败可立即观测(返回值、空指针),后者要等几帧后回收时才以 vkDestroyBuffer 崩溃的形式暴露。
2.16.4 规则四:比较语义必须覆盖全部影响分配的字段
本章 MemorySlots 把 offset 与 size 一起当键(include/vsg/core/MemorySlots.h:45),键里少一个字段就会把两块内存判成同一块。后续章节的同类缺陷逐处独立:
ShaderStage有Mask mask = MASK_ALL(include/vsg/state/ShaderStage.h:36),而compare比到specializationConstants就结束(src/vsg/state/ShaderStage.cpp:79),mask不参与。BindDescriptorSets有dynamicOffsets(include/vsg/state/BindDescriptorSet.h:53),而compare的最后一比是descriptorSets,随后直接return(src/vsg/state/BindDescriptorSet.cpp:52)。ShaderSet::compare比到geometryHints就结束,defaultShaderHints与variants两个成员不在比较序列里(src/vsg/utils/ShaderSet.cpp:298)。TextGroup::compare只比children,而read()会从流里读font/shaderSet/technique三个ref_ptr(src/vsg/text/TextGroup.cpp:24)。
SharedObjects::share() 以 compare() 为去重键,所以这些漏字段不是「少存一点信息」,而是让两份不同配置共享同一份 GPU 资源;代价在共享发生之后才显现:两个 ShaderStage 只有 mask 不同,去重后只剩一个,剔除语义随之错位。
2.16.5 后验结论
四条规则在 core/ 内部成立,在 app/、state/、io/、utils/ 里被绕过十余处(本节 5+3+2+4 条,另有 Context::reset() 的不对称清理、CompileResult::add 的 break 截断、vkQueuePresentKHR 返回值丢弃)。VSG 的内存工程不是强制机制,而是只在分配器边界内生效的约定。
本章复现命令
想自己核对本章的结构性结论,跑这六条命令即可:
# 1. 分配器的类型与亲和性枚举
grep -n "enum AllocatorType" -A 8 include/vsg/core/Allocator.h
grep -n "enum AllocatorAffinity" -A 8 include/vsg/core/Allocator.h
# 2. 位域布局与单次分配上限
grep -n "previous : 15" -B 4 -A 6 include/vsg/core/IntrusiveAllocator.h
grep -n "computeMaxiumAllocationSize" -A 4 include/vsg/core/IntrusiveAllocator.h
# 3. 默认块大小(1MB / 16MB / 16 字节对齐)
grep -n "ALLOCATOR_AFFINITY_DATA" include/vsg/core/IntrusiveAllocator.cpp
# 4. 全局锁的位置
grep -n "scoped_lock<std::mutex> lock(mutex)" src/vsg/core/IntrusiveAllocator.cpp
# 5. GPU 侧三个 map
grep -n "_availableMemory\|_offsetSizes\|_reservedMemory" include/vsg/core/MemorySlots.h
# 6. UBO/SSBO 对齐来源
grep -n "minUniformBufferOffsetAlignment" -B 3 -A 3 src/vsg/state/BufferInfo.cpp
如果想验证 MemorySlots 的正确性,最直接的办法是写一个小测试:
vsg::MemorySlots slots(1024, vsg::MEMORY_TRACKING_CHECK_ACTIONS);
auto [ok1, off1] = slots.reserve(100, 16); // 成功,off1 = 0
auto [ok2, off2] = slots.reserve(100, 16); // 成功,off2 = 112(对齐到 16 后)
slots.release(off1, 100); // 释放第一块
auto [ok3, off3] = slots.reserve(50, 16); // 复用第一块,off3 = 0
slots.release(off2, 100);
slots.release(off3, 50); // 全部释放
assert(slots.totalAvailableSize() == slots.totalMemorySize());
MEMORY_TRACKING_CHECK_ACTIONS 会在每次 reserve/release 后调用 check(),任何"漏记/重记"都会立刻打印警告。这是验证子分配器行为最省力的方式,比读 400 行 reserve 代码快得多。
2.17 九组命令:把本章每条断言钉到行上
下面每组命令都在源码根目录执行,只读不写。命令的注释写明"这一组证什么",输出与正文不符即为正文出错。
# 1. 位域宽度:4 字节里塞了 15+15+2 位
sed -n '81,93p' include/vsg/core/IntrusiveAllocator.h
# 2. 上限算式:min(blockSize - alignment, (2^15-2) * sizeof(Element))
sed -n '170,173p' include/vsg/core/IntrusiveAllocator.h
python -c "print('limit =', ((1<<15)-2)*4)"
# 3. 1MB 块按 alignment=8 得 131072 个对齐单元,单槽上限 32768,故必须切 4 段
python -c "cap=1024*1024//8; print('capacity', cap, 'segments', -(-cap//(1<<15)))"
# 4. 建块循环里 next_position 被 min 到 capacity,说明最后一段是截断的
sed -n '71,82p' src/vsg/core/IntrusiveAllocator.cpp
# 5. 四个亲和性的默认块大小与对齐(PHYSICS 的 16 是硬编码,不跟 defaultAlignment)
sed -n '853,857p' src/vsg/core/IntrusiveAllocator.cpp
# 6. 谁持锁:只有 allocate / deallocate / setBlockSize 三处 scoped_lock
grep -n "scoped_lock<std::mutex> lock(mutex)" src/vsg/core/IntrusiveAllocator.cpp
# 7. 亲和性守卫的边界:`>` 而非 `>=`,size()==4 时传 4 会落到 resize 之后仍越界
sed -n '913,918p' src/vsg/core/IntrusiveAllocator.cpp
python -c "size=4; a=4; print('guard passes when a>size:', a>size, '| index used:', a, '| valid max:', size-1)"
# 8. 块表只增不减:父类 memoryBlocks 只有写入点,全文件 0 次 erase
grep -n "parent->memoryBlocks" src/vsg/core/IntrusiveAllocator.cpp
grep -c "memoryBlocks.erase" src/vsg/core/IntrusiveAllocator.cpp || true
# 9. deleteEmptyMemoryBlocks 只 swap 局部向量,并返回 totalAvailableSize
sed -n '793,811p' src/vsg/core/IntrusiveAllocator.cpp
# 10. 账本不含槽头:reservedSize 累加 slot.next - 1,槽头那一个 Element 被排除
sed -n '688,700p' src/vsg/core/IntrusiveAllocator.cpp
python -c "n=1000000; print('slots', n, 'unaccounted header bytes', n*4)"
# 11. 释放路径不读 size,且 double free 抛的是字符串字面量而非标准异常
sed -n '273,276p' src/vsg/core/IntrusiveAllocator.cpp
sed -n '302,312p' src/vsg/core/IntrusiveAllocator.cpp
# 12. MemorySlots 不校验 alignment:为 0 时 alignedStart 那行就是除零
sed -n '157,165p' src/vsg/core/MemorySlots.cpp
# 13. check() 的宽松处:表长度不一致只 warn,和相等就返回 true
sed -n '79,110p' src/vsg/core/MemorySlots.cpp
# 14. GPU 侧默认 16MB 粒度与 16MB 最小 buffer,不是"几十 MB"
grep -n "minimumBufferSize\|minimumDeviceMemorySize" include/vsg/vk/MemoryBufferPools.h
# 15. UBO/SSBO 对齐取自设备 limits,兜底值 4
sed -n '234,239p' src/vsg/state/BufferInfo.cpp
源码索引
| 结论 | 文件:行 | 关键位置 |
|---|---|---|
| 分配器接口 | include/vsg/core/Allocator.h:23、include/vsg/core/Allocator.h:31 | AllocatorType 四值、AllocatorAffinity 五值 |
| 默认单例 | src/vsg/core/Allocator.cpp:26 | s_allocator 默认 new IntrusiveAllocator() |
| 可替换性与嵌套 | include/vsg/core/Allocator.h:51、include/vsg/core/Allocator.h:83 | instance() 返回引用;nestedAllocator |
| 全局锁 | src/vsg/core/IntrusiveAllocator.cpp:910、src/vsg/core/IntrusiveAllocator.cpp:948 | allocate/deallocate 各一把 scoped_lock |
| 大对象表 | src/vsg/core/IntrusiveAllocator.cpp:933 | largeAllocations[ptr] 记 alignment 与 size |
| 块内位域 | include/vsg/core/IntrusiveAllocator.h:81、include/vsg/core/IntrusiveAllocator.h:116 | struct Element、struct FreeList |
| 块切分 | src/vsg/core/IntrusiveAllocator.cpp:54、src/vsg/core/IntrusiveAllocator.cpp:73 | max_slot_size、aligned_start |
| 单次上限 | include/vsg/core/IntrusiveAllocator.h:172 | computeMaxiumAllocationSize |
| 默认块大小 | src/vsg/core/IntrusiveAllocator.cpp:854 | ALLOCATOR_AFFINITY_OBJECTS 用 1MB |
| 亲和性路由 | src/vsg/core/Object.cpp:238、src/vsg/nodes/Node.cpp:31 | 两个 operator new 各写死一个枚举 |
| GPU 子分配结构 | include/vsg/core/MemorySlots.h:65 | _availableMemory 等三个容器 |
| 最佳适配 | src/vsg/core/MemorySlots.cpp:157、src/vsg/core/MemorySlots.cpp:158 | lower_bound 与 ++itr 分支 |
| 双向合并 | src/vsg/core/MemorySlots.cpp:247、src/vsg/core/MemorySlots.cpp:264 | prev_slot_itr/next_slot_itr |
| 不变量检查 | src/vsg/core/MemorySlots.cpp:79 | check() 只比"和相等" |
| 内存追踪级别 | include/vsg/core/MemorySlots.h:26 | MemoryTracking 三档 |
| UBO 对齐来源 | src/vsg/state/BufferInfo.cpp:236、src/vsg/state/BufferInfo.cpp:238 | minUniformBufferOffsetAlignment |
| 绑定与版本追踪 | include/vsg/state/BufferInfo.h:63、include/vsg/state/BufferInfo.h:80 | requiresAllocation、copiedModifiedCounts |
| 数据结构属性 | include/vsg/core/Data.h:120、include/vsg/core/Data.h:59 | Properties 与 DataVariance |
| 变更检测 | include/vsg/core/Data.h:31、include/vsg/core/Data.h:206 | ModifiedCount 与 dirty() |
| 数组布局 | include/vsg/core/Array.h:83、include/vsg/core/Array.h:380 | 视图构造函数与 _data/_size |
| 临时分配 | include/vsg/core/ScratchMemory.h:45、include/vsg/core/ScratchMemory.h:53 | align 到 8 字节、allocate<T> |
| 内存池预留 | include/vsg/vk/MemoryBufferPools.h:56、include/vsg/vk/MemoryBufferPools.h:34 | reserveMemory;minimumBufferSize 16MB |
2.18 陷阱表:二十二条会真实咬人的行为
每一行都能在源码里指到具体那一行,触发条件写的是"什么样的调用会踩到",不是"可能有问题"。
| 陷阱 | 触发条件 | 后果 | 源码坐标 | 规避 |
|---|---|---|---|---|
| 上限不是块大小 | 单次请求超过 maximumAllocationSize | 静默转 operator new,局部性归零,largeAllocations 多一条 | src/vsg/core/IntrusiveAllocator.cpp:932 | 大数组按 128KB 以下切片 |
| 亲和性守卫 off-by-one | 传 ALLOCATOR_AFFINITY_LAST(值 4) | 4 > 4 为假,不扩容,allocatorMemoryBlocks[4] 越界 | src/vsg/core/IntrusiveAllocator.cpp:913 | 只用 0–3,或先 setBlockSize 建槽 |
| 释放不读 size | 上游传错 size | 无警告,尺寸全由槽头反推 | src/vsg/core/IntrusiveAllocator.cpp:273 | 不把 size 当校验手段 |
| double free 抛字面量 | 同一指针释放两次 | throw "...",catch(std::exception&) 抓不到 | src/vsg/core/IntrusiveAllocator.cpp:308 | 自己加重复释放断言 |
| 越界指针沉默 | 释放别处来的指针 | 返回 false,而 vsg::deallocate 丢弃返回值 | src/vsg/core/Allocator.cpp:39 | 直接调实例方法并检查 bool |
| 合并被上限挡住 | 相邻槽总长超过 maxSize | 保持分裂,碎片永久化 | src/vsg/core/IntrusiveAllocator.cpp:497 | 调大 blockSize,或分阶段重建 |
| 块表只增不减 | 反复申请新块 | 每块一条 map 记录,永不 erase | src/vsg/core/IntrusiveAllocator.cpp:758 | 长跑进程定期重建分配器 |
| 回收 API 不回收 | 调 deleteEmptyMemoryBlocks() | 只剪局部向量,块不析构,RSS 不降 | src/vsg/core/IntrusiveAllocator.cpp:799 | 以 RSS 而非返回值判断 |
| 回收 API 不持锁 | 与分配并发调用 | 在别人 resize 的 vector 上 swap | src/vsg/core/IntrusiveAllocator.cpp:1008 | 只在单线程窗口调用 |
| 账本少算槽头 | 用 totalReservedSize() 估占用 | 每槽少 4 字节,百万对象低估 4MB | src/vsg/core/IntrusiveAllocator.cpp:696 | 加 4 × 槽数,或用 RSS 校准 |
| 可用量含链表 | 用 totalAvailableSize() 判"能放多大" | 每空闲槽高估 8 字节,且忽略合并上限 | src/vsg/core/IntrusiveAllocator.cpp:682 | 看单块最大空闲,不看总和 |
| 对齐除零 | reserve(size, 0) | alignedStart 那行除以 0 | src/vsg/core/MemorySlots.cpp:163 | 只传设备 limits 里的值 |
| 未知 offset 静默 | double free 或跨池释放 | 直接返回 false,跳过 check() | src/vsg/core/MemorySlots.cpp:215 | 打开 CHECK_ACTIONS 并查返回值 |
| size 不符被纠正 | 释放时 size 传错 | 以 _reservedMemory 为准,不报错 | src/vsg/core/MemorySlots.cpp:229 | 同上,别依赖传参 |
check() 放过错位 | _availableMemory 与 _offsetSizes 长度不一致但总和相等 | 只 warn,仍返回 true | src/vsg/core/MemorySlots.cpp:81 | 读日志,不只看返回值 |
| 前导碎片不可用 | 槽起始未按 alignment 对齐 | 小于 alignment 的碎片插回表里占位 | src/vsg/core/MemorySlots.cpp:170 | 让底层 buffer 自身按最大对齐分配 |
| 只保证 8 字节对齐 | 用 allocate<T>() 放 dvec4/__m128 | 16 字节对齐类型错位 | include/vsg/core/ScratchMemory.h:47 | SIMD 数据另走 vsg::allocate |
| 溢出链只增不减 | 单帧出现大结构体 | next 块常驻,峰值等于历史最大 | include/vsg/core/ScratchMemory.h:69 | 大结构体放独立 buffer |
视图没有 dataRelease | 对视图调 dataRelease() | 返回 nullptr,底层存储不释放 | include/vsg/core/Array.h:292 | 释放 _storage 而不是视图 |
at() 不查边界 | 索引大于等于 size() | data(i) 直接算地址,越界可写 | include/vsg/core/Array.h:332 | 调用前自比 _size |
dirty() 非原子 | 两线程同时改同一 Data | 丢自增,某帧不上传 | include/vsg/core/Data.h:206 | 修改集中在 update 线程 |
release_nodelete 漏删 | 取走裸指针后忘记 delete | 计数已减、对象永不析构 | include/vsg/core/ref_ptr.h:175 | 只在上交所有权时用 |
2.19 批判性结论
本章的结论按证据强度分三层:能由单行代码判定的、需要两处对照才能判定的、以及属于取舍而非缺陷的。三层分开写,是因为它们的"反驳成本"完全不同——第一层错了就是读错代码,第三层错了往往是立场不同。
一、deleteEmptyMemoryBlocks() 的命名与行为不符,这是可判定的错误,不是风格问题。 证据链有三环:建块时把 shared_ptr 存进父类按地址索引的表(src/vsg/core/IntrusiveAllocator.cpp:758),这是该表在全文件唯一的写入点;回收时只对局部 memoryBlocks 向量做 swap(src/vsg/core/IntrusiveAllocator.cpp:799);析构函数里才 operator delete(memory, std::align_val_t{blockAlignment})(src/vsg/core/IntrusiveAllocator.cpp:101)。三环连起来,结论是"引用计数不归零,块不会析构"。更麻烦的是返回值:它累加的是 totalAvailableSize()(src/vsg/core/IntrusiveAllocator.cpp:801),而后者按 slot.next - 1 计(src/vsg/core/IntrusiveAllocator.cpp:682),既不含槽头也不含块尾对齐余量。代价分两层:运维层看到的是"调用了回收、拿回了一个正数、RSS 没变";观测层更糟——totalMemorySize() 遍历的是被剪过的向量,回收之后报表反而变小,把"没还"显示成"已还"。规避只有一条:把块表当只增结构,用进程生命周期回收;要在同一进程里压 RSS,只能切 ALLOCATOR_TYPE_NEW_DELETE 让每次分配各自 free。
二、账本口径与真实占用之间差一个槽头,而且这个差是可计算的,不是模糊的"一些开销"。 totalReservedSize() 累加 slot.next - 1(src/vsg/core/IntrusiveAllocator.cpp:696),totalMemorySize() 同口径(src/vsg/core/IntrusiveAllocator.cpp:710),槽头那一个 Element 被排除在两侧之外。于是恒等式 total = reserved + available 成立,但它描述的是"扣掉全部槽头之后的世界"。100 万个 48 字节对象对应 100 万个槽,账面与 RSS 的差至少 4MB;若每个槽还带着对齐填充,差得更多。这个偏差之所以值得单列,是因为它系统地偏小:偏小的报表会让容量规划偏乐观,而偏乐观的容量规划在长时间运行的服务里表现为"某天突然 OOM"。规避是给每个统计值补一项 4 × 槽数,而槽数只能从 report() 逐块累加,不能从总量反推。
三、并发契约是不对称的:写路径持锁,读路径与回收路径不持锁。 allocate 与 deallocate 的第一条语句都是 std::scoped_lock(src/vsg/core/IntrusiveAllocator.cpp:910、src/vsg/core/IntrusiveAllocator.cpp:948),setBlockSize 也持锁(src/vsg/core/IntrusiveAllocator.cpp:879);而 deleteEmptyMemoryBlocks()(src/vsg/core/IntrusiveAllocator.cpp:1008)、totalReservedSize()(src/vsg/core/IntrusiveAllocator.cpp:1028)、report()(src/vsg/core/IntrusiveAllocator.cpp:894)都直接遍历 allocatorMemoryBlocks。写路径会 resize 这个向量(src/vsg/core/IntrusiveAllocator.cpp:916),读路径则可能在扩容过程中读到半旧半新的指针。这不是"理论上"的竞争:只要有一个线程在加载、另一个线程在打印统计,就成立。代价取决于运气——多数时候读到的是旧值,偶尔是已释放的 unique_ptr。规避是把统计调用集中到帧边界或加载结束点,别把它当线程安全的观测手段。
四、错误处理的方向也是不对称的:多释放会终止进程,少释放永远不会被报出来。 MemoryBlock::deallocate 对两种异常状态直接 throw 字符串字面量(src/vsg/core/IntrusiveAllocator.cpp:305、src/vsg/core/IntrusiveAllocator.cpp:311),而 throw "..." 抛的是 const char*,catch (const std::exception&) 接不住,未捕获时直接 std::terminate。反方向则完全沉默:块查找失败返回 false(src/vsg/core/IntrusiveAllocator.cpp:995),而自由函数 vsg::deallocate 的返回类型是 void,把 bool 丢掉(src/vsg/core/Allocator.cpp:39)。于是同一类错误,一边是崩溃,一边是泄漏,中间没有"警告"这一档。代价是排查成本的不对等:崩溃有栈,泄漏只有 RSS 曲线。规避是绕开自由函数,直接对 Allocator 实例调 deallocate 并检查返回值;或者装一个包装分配器,在 deallocate 里对 false 计数。
五、ALLOCATOR_AFFINITY_LAST 是枚举里的第 5 个值,但不是可用值。 构造函数按 ALLOCATOR_AFFINITY_LAST 扩容到 4 个槽(src/vsg/core/IntrusiveAllocator.cpp:853),而分配入口的守卫写成 allocatorAffinity > allocatorMemoryBlocks.size()(src/vsg/core/IntrusiveAllocator.cpp:913)。当亲和性恰为 4 时,4 > 4 为假,扩容不执行,随后 allocatorMemoryBlocks[4](src/vsg/core/IntrusiveAllocator.cpp:922)在长度 4 的向量上越界。名字叫 LAST 却不满足"最后一个可用值"的语义,恰好是 off-by-one 最容易被误用的形状:调用方看名字会以为 4 合法。代价是未定义行为——operator[] 不检查,读到的是相邻堆内存,通常表现为亲和性随机落到某个池上,或者干脆崩溃在别处。规避是把 4 当成"计数"而不是"取值",需要第 5 个池就走 setBlockSize(src/vsg/core/IntrusiveAllocator.cpp:889 会先 resize)。
六、GPU 侧把对齐的责任推给调用方,却不校验参数。 MemorySlots::reserve 收到 alignment 后直接算 alignedStart(src/vsg/core/MemorySlots.cpp:163),既没有断言非零,也没有检查是否 2 的幂;alignment == 0 就是一次除零。而真正决定这个值的是 BufferInfo 的构造路径,它从设备 limits 取 minUniformBufferOffsetAlignment(src/vsg/state/BufferInfo.cpp:236),兜底值写死 4(src/vsg/state/BufferInfo.cpp:234)。这形成一个奇怪的分布:正常路径永远传对,错误路径直接崩在离错误很远的 MemorySlots 里。代价是定位成本——崩溃栈里看不到"谁传了 0",只能反查所有 reserve 调用点。规避是在 MemorySlots 外面包一层:alignment = std::max<size_t>(alignment, 4) 再取整到下一个 2 的幂。
七、MemorySlots::check() 校验的是"和",不是"结构"。 两张空闲表长度不一致时只 warn 后继续(src/vsg/core/MemorySlots.cpp:81),只要 computedSize == _totalMemorySize 就返回 true(src/vsg/core/MemorySlots.cpp:99)。而 insertAvailableSlot 用 emplace 分别插入两张表(src/vsg/core/MemorySlots.cpp:130、src/vsg/core/MemorySlots.cpp:131),同一个 offset 重复插入时,其中一张会静默失败——此时两张表已经错位,但"和"可能仍然相等。代价是把一个结构错误伪装成通过:打开 MEMORY_TRACKING_CHECK_ACTIONS 得到的"全部通过"并不保证空闲表能被正确遍历。规避是把 warn 的分支也当失败处理,或者自己按 offset 排序遍历一遍两张表做对账。
八、紧凑布局的收益与伪共享的成本同源,本章无法两全。 头文件注释把设计意图写得很清楚:按类型分块是为了"nodes etc. are packed in adjacent memory"(include/vsg/core/IntrusiveAllocator.h:35),而 _referenceCount 就放在对象开头(include/vsg/core/Object.h:190)。两者叠在一起,遍历变快的同时,相邻对象的计数器落进同一条缓存行。ref() 用 relaxed 已是最便宜的原子操作(include/vsg/core/Object.h:122),真正的成本不在指令而在缓存行归属权。代价可以估:多线程每帧对相邻节点做 ref/unref 时,一条缓存行会在核间来回迁移,吞吐随核数下降。规避是一个真实的两难——插 padding 能让计数器独立,但每个对象多 60 字节,百万对象是 60MB;不插就只能限制"只在单线程改引用计数"。本章选的是后者,它假设遍历比引用计数频繁;这个假设在加载期不成立,而加载期又被全局锁挡着,于是问题被推迟而不是被解决。
九、四条规则只在 core/ 内部是规则。 2.16 列出的十余处绕过不是疏忽,而是分层的结果:Allocator 管块内地址,ref_ptr 管计数,容器上界、键完整、生命周期闭合没有任何一层负责。代价落在长期运行的应用上:一次 resize、一次编译、一次 MSAA 重建都会留下不可回收的条目,report() 还看不见——它只统计 CPU 侧的块。规避是把 2.16.1 的五处容器当清单逐项加上界,并把"重编译后跑一次 RSS 对比"写进回归测试。指望分配器代劳,等于让它去管跨模块的容量。
九条里有七条是"能由代码判定"的,两条是取舍。这个比例本身说明了本章的写作前提:把内存工程讲清楚,靠的不是"设计很精巧"这类评价,而是把每一处边界条件、每一个 off-by-one、每一条沉默的失败路径都指到行上。
还有一个反直觉的分布:本章被验证得最充分的部分,恰恰是最不容易出错的部分(位域宽度、上限算式、默认块大小),因为它们能在头文件里一眼看完;而代价最大的部分——回收、并发、账本口径——都埋在 .cpp 的条件分支里,只有顺着调用链读完才看得见。比如"deleteEmptyMemoryBlocks() 不还内存"这条,要把建块处写 map(src/vsg/core/IntrusiveAllocator.cpp:758)、剪向量处(src/vsg/core/IntrusiveAllocator.cpp:799)、析构处释放(src/vsg/core/IntrusiveAllocator.cpp:101)三处串起来才成立,任何单独一处都看不出问题。这个分布决定了读 VSG 内存栈的顺序:先读头文件里的接口约定,再读 .cpp 里每个 if 的反面——每个失败分支都是一条没写进文档的行为契约。
对使用方而言,本章的净收益可以压成三条可执行检查:report() 报的占用与 RSS 的差额是否等于 4 × 槽数;调回收 API 前后 RSS 是否变化;多线程下的统计调用是否都发生在帧边界。三条都过,才谈得上在这一层做优化;有一条不过,先修那一层,别改分配器。
下一章预告
第三章进入 Visitor:那 267 个 apply 重载到底怎么组织、ConstVisitor 与 Visitor 为什么是两套、Visitor::apply(Object&) 为空实现的设计意图、traverseMask/overrideMask 如何实现"部分遍历"、以及 vsg::visit<ComputeTransform>(...) 这种一行式工具背后的模板技巧。
我们会回答一个具体问题:为什么 RecordTraversal 不继承 Visitor,而是自己声明了一套 apply? 答案藏在"剔除需要修改状态栈、而普通访问者不应该有状态栈"这个约束里。