第6章：优化内存性能

概述

本章聚焦于优化性能和微调内存管理的方法，深入探讨在C++中控制系统资源和内存分配的方方面面。我们首先学习如何创建自定义内存分配器，它能让你精确控制内存的分配和释放方式及时间。接下来，我们将研究缓存感知编程（cache-aware programming），其重点在于如何在内存中组织数据，以充分利用现代CPU缓存架构。通过使数据访问模式与缓存行（cache lines）对齐，我们可以提高程序性能并减少缓存未命中的情况。

最后，我们将探讨定位新表达式（placement new）和对齐分配（aligned allocations）这些强大的概念。这些技术能让你明确控制内存的分配位置和方式，从而在高性能环境中实现更精确的内存管理。在本章中，我们将通过实际示例和这些方法的应用，帮助你理解C++中的内存优化。

设计自定义分配器

在C++中，内存分配通常由默认分配器处理，它是一种通用分配器，针对大多数情况进行了优化。然而，当高性能应用程序需要对内存管理进行细粒度控制时，默认分配器可能就不够用了。这时，自定义分配器就发挥作用了。通过构建自定义分配器，你可以针对特定用例最大化速度，因为它能让你直接控制内存的分配、释放和管理。

自定义分配器在因频繁分配和释放、内存碎片化导致性能瓶颈，或采用特定内存管理策略可降低开销的情况下特别有用。例如，游戏引擎、实时系统和大规模数据处理应用程序通常需要自定义内存分配器，以确保可预测且高效的内存处理。

自定义分配器的过程

自定义分配器的核心是一个类，它提供用于分配和释放内存的方法。C++标准库允许你将自定义分配器传递给标准容器，如std::vector或std::list，使它们使用你定义的分配器而非默认分配器。要创建自定义分配器，你需要通过以下关键函数定义如何管理内存：

• allocate(size_t n)：为给定类型的n个对象分配内存。
• deallocate(pointer p, size_t n)：释放由p指向的n个对象的内存。
• construct()和destroy()：这两个函数是可选的，但可以定义它们在已分配内存中构造和销毁对象。

此外，自定义分配器可以包含一些优化措施，比如为特定对象大小的内存进行池化管理、根据特定硬件要求对齐内存，或者通过智能分配策略减少内存碎片化。

何时使用自定义分配器？

自定义分配器在以下情况很有用：

1. 在对可预测性能要求极高的实时应用程序中，如视频游戏、机器人技术或音频处理，自定义分配器可确保内存分配和释放快速且可确定。
2. 在性能至上的应用程序中，如大规模模拟、科学计算或金融系统，自定义分配器有助于减少动态内存管理的开销并优化内存使用。
3. 在内存有限的系统中，如嵌入式设备或物联网（IoT）应用程序，自定义分配器能让你精细管理和优化内存使用，减少浪费并提高效率 。

示例程序：一个简单的自定义分配器

我们将从构建一个简单的自定义分配器开始，它以大块（或“池”）的方式分配内存，以减少频繁内存分配的开销。这个分配器对于频繁分配和释放相同大小对象的应用程序特别有用，比如我们正在编写的程序中的粒子系统。

我们将构建一个基本的内存池分配器，它预先分配一大块内存，然后根据需要分配较小的部分。当所有已分配的内存都被使用后，分配器将请求另一块内存。

#include <iostream>
#include <memory>
#include <vector>
// 一个使用内存池的简单自定义分配器
template <typename T>
class PoolAllocator {
public:
    using value_type = T;
    // 构造函数，用于初始化内存池
    PoolAllocator(size_t poolSize = 1024) : poolSize(poolSize) {
        allocatePool();
    }
    // 析构函数，用于释放内存池
    ~PoolAllocator() {
        for (auto block : memoryPool) {
            ::operator delete(block);
        }
    }
    // 为n个对象分配内存
    T* allocate(size_t n) {
        if (n > poolSize) {
            throw std::bad_alloc();
        }
        if (freeList.empty()) {
            allocatePool();
        }
        T* ptr = freeList.back();
        freeList.pop_back();
        return ptr;
    }
    // 释放内存
    void deallocate(T* p, size_t n) {
        freeList.push_back(p);
    }
    // 在已分配的内存中构造一个对象
    template <typename... Args>
    void construct(T* p, Args&&... args) {
        new (p) T(std::forward<Args>(args)...);
    }
    // 在已分配的内存中销毁一个对象
    void destroy(T* p) {
        p->~T();
    }
private:
    size_t poolSize;
    std::vector<T*> freeList;
    std::vector<void*> memoryPool;
    // 分配一个新的内存池
    void allocatePool() {
        void* block = ::operator new(poolSize * sizeof(T));
        memoryPool.push_back(block);
        // 用指向新分配内存的指针填充空闲列表
        for (size_t i = 0; i < poolSize; ++i) {
            freeList.push_back(static_cast<T*>(block) + i);
        }
    }
};

// 使用自定义分配器的粒子类
struct Particle {
    double x, y, z; // 位置
    double vx, vy, vz; // 速度
    Particle(double x, double y, double z, double vx, double vy, double vz)
        : x(x), y(y), z(z), vx(vx), vy(vy), vz(vz) {
        std::cout << "Particle created at (" << x << ", " << y << ", "
                  << z << ")\n";
    }
    ~Particle() {
        std::cout << "Particle destroyed\n";
    }
};
int main() {
    // 为Particle对象使用自定义的PoolAllocator
    std::vector<Particle, PoolAllocator<Particle>> particles(PoolAllocator<Particle>(1024));
    // 使用自定义分配器创建粒子
    particles.emplace_back(1.0, 2.0, 3.0, 0.1, 0.2, 0.3);
    particles.emplace_back(4.0, 5.0, 6.0, 0.4, 0.5, 0.6);
    // 程序退出时，Particle对象将自动被销毁
    return 0;
}

在上述程序中：

• PoolAllocator类管理一个内存池，它预先分配一大块内存以供将来使用。每次创建新对象时，分配器不是从系统中分配内存，而是从内存池中分配指向预先分配内存块的指针。这大大减少了频繁分配的开销。
• allocate()函数从空闲列表中获取一个指针，空闲列表存储当前未使用的内存块。如果空闲列表为空，则分配一个新的内存块，并使用新的内存块重新填充空闲列表。deallocate()函数将内存块添加回空闲列表，确保该内存可用于未来的分配。
• construct()和destroy()方法处理已分配内存中对象的构造和销毁。这使我们能够安全地创建和销毁对象，而无需担心内存泄漏或未初始化的内存。
• 然后，我们将PoolAllocator作为模板参数传递给std::vector，这使得vector可以使用自定义分配器来管理其内存。在这里，std::vector使用自定义内存池为Particle对象分配内存，减少了与动态内存分配相关的开销。

简而言之，对于实时系统或高性能计算等对性能和资源控制至关重要的场景，我们可以显著减少与动态内存分配相关的开销，并优化内存使用。

利用缓存感知编程提升性能

在现代系统中，缓存性能在决定程序访问数据的速度方面起着重要作用。缓存未命中（cache miss）会导致CPU不得不从速度较慢的主内存中获取数据，这可能会导致显著的性能延迟。缓存感知编程侧重于优化数据的访问和存储方式，以充分利用现代CPU缓存架构。CPU缓存是位于CPU和主系统内存（随机存取存储器，RAM）之间的一个小型快速存储空间，用于存储频繁访问的数据。通过优化程序以适应缓存的特性，你可以减少缓存未命中的情况（即所需数据在缓存中未找到的情况），从而提高整体性能。

CPU缓存的工作原理

CPU缓存被组织成缓存行（cache line），通常大小为64字节。当CPU访问一个内存地址时，一整个缓存行会被加载到缓存中。如果后续的内存访问落在同一缓存行内，CPU可以快速从缓存中检索数据，避免访问速度较慢的主内存。

缓存感知编程采用以下原则：

• 空间局部性（Spatial locality）：确保一起被访问的数据元素在内存中存储得彼此靠近。
• 时间局部性（Temporal locality）：频繁访问的数据应在缓存中保留尽可能长的时间，以降低其被逐出的可能性。

通过以利用空间局部性和时间局部性的方式来组织数据，你可以提升程序的性能，并大幅减少缓存未命中的情况。

示例程序：应用缓存感知编程

我们将考虑一个粒子模拟场景，在这个场景中，优化内存访问至关重要。我们将展示如何应用缓存感知编程技术，通过高效地组织粒子数据和访问模式来减少缓存未命中并提高性能。

在我们的示例中，Particle结构体包含位置和速度数据。我们将探索不同的方式来组织和访问这些数据，以优化缓存性能。

为提高缓存效率而构建数据结构

以下是Particle结构体的示例程序：

struct Particle {
    double x, y, z; // 位置
    double vx, vy, vz; // 速度
};

如果Particle对象存储在一个连续的数组中，CPU可以一次将多个粒子加载到缓存中。然而，内存中的数据布局可能并非对缓存性能最优。因此，我们首先模拟一个简单的情况，即我们将粒子存储在std::vector中，并在循环中更新它们的位置和速度。

#include <iostream>
#include <vector>

struct Particle {
    double x, y, z;   // 位置
    double vx, vy, vz; // 速度
    Particle(double px, double py, double pz, double pvx, double pvy, double pvz)
    : x(px), y(py), z(pz),vx(pvx), vy(pvy),vz(pvz) {} 
};

void update_particles(std::vector<Particle>& particles) {
    for (auto& particle : particles) {
        // 根据速度更新位置
        particle.x += particle.vx;
        particle.y += particle.vy;
        particle.z += particle.vz;
    } 
}

int main() {
    // 创建大量粒子
    std::vector<Particle> particles;
    for (int i = 0; i < 1000000; ++i) {
        particles.emplace_back(i * 0.1, i * 0.2, i * 0.3, 0.01, 0.01, 0.01);
    }
    // 运行模拟循环
    for (int iteration = 0; iteration < 100; ++iteration) {
        update_particles(particles);
    }

    return 0;
}

在这里，粒子在内存中是连续存储的，但位置和速度数据是交错的。当CPU将一个粒子加载到缓存中时，位置和速度数据都会被获取，即使只有位置数据会频繁更新。这可能导致缓存使用效率低下。

优化缓存效率

现在，为了提高缓存性能，我们可以将位置和速度数据分离到不同的数组中。这样，当我们更新位置时，CPU只将位置数据加载到缓存中。这种技术被称为数组结构（structure of arrays，SoA），与之前的方法（称为结构体数组，array of structures，AoS）形成对比。

以下是我们如何实现数组结构方法：

#include <iostream>
#include <vector>

struct Position {
    double x, y, z;
};

struct Velocity {
    double vx, vy, vz;
};

void update_positions(std::vector<Position>& positions, const std::vector<Velocity>& velocities) {
    for (size_t i = 0; i < positions.size(); ++i) {
        // 根据速度更新位置
        positions[i].x += velocities[i].vx;
        positions[i].y += velocities[i].vy;
        positions[i].z += velocities[i].vz;
    } 
}

int main() {
    // 为位置和速度创建单独的数组
    std::vector<Position> positions;
    std::vector<Velocity> velocities;

    for (int i = 0; i < 1000000; ++i) {
        positions.push_back({i * 0.1, i * 0.2, i * 0.3});
        velocities.push_back({0.01, 0.01, 0.01});
    }
    // 运行模拟循环
    for (int iteration = 0; iteration < 100; ++iteration) {
        update_positions(positions, velocities);
    }

    return 0;
}

在初始版本（AoS）中，每个Particle对象都包含位置和速度数据，这些数据在内存中是交错的。这导致缓存使用效率较低，因为即使只有位置数据被修改，位置和速度数据都会被加载到缓存中。相比之下，SoA方法将位置和速度分离到不同的数组中。当我们更新位置时，只有位置数据会被加载到缓存中，从而减少了缓存未命中的情况。使用SoA方法，与当前操作（更新位置）相关的更多数据可以放入每个缓存行中。由于一个缓存行通常可以容纳64字节，而一个Position结构体包含24字节，因此每个缓存行可以容纳两个Position对象。这增加了每次内存访问时获取到缓存中的有用数据点的数量，提高了缓存利用率并减少了缓存未命中的情况。

缓存感知的数据遍历

缓存感知编程的另一个重要方面是如何遍历数据。以可预测的线性方式访问数据可以提高缓存性能，因为CPU可以将数据预取到缓存中。

另一方面，随机或跨步的内存访问模式可能会导致缓存颠簸（cache thrashing），即有用数据不断从缓存中被逐出，从而导致更多的缓存未命中。

以下是一个内存访问模式不佳的示例程序，其中粒子是以不连续的顺序被访问的：

void update_positions_random(std::vector<Position>& positions, const std::vector<Velocity>& velocities, const std::vector<size_t>& random_indices) {
    for (size_t i = 0; i < positions.size(); ++i) {
        size_t index = random_indices[i]; // 以随机顺序访问粒子
        positions[index].x += velocities[index].vx;
        positions[index].y += velocities[index].vy;
        positions[index].z += velocities[index].vz;
    } 
}

在这个版本中，我们以随机顺序访问粒子，这可能会导致缓存性能不佳，因为CPU无法有效地预取下一个数据元素。结果，缓存未命中的数量增加，程序的整体性能下降。

总之，我们展示了与交错数据方法（AoS）相比，分离位置和速度数据（SoA）以及以线性、可预测的方式访问数据如何提高缓存性能。这在处理大型数据集或运行数百万次迭代模拟的场景中尤为重要。

利用定位放置式新对象创建（placement new）和对齐分配优化内存

内存分配通常通过使用new和delete进行动态内存管理，或者使用像std::vector这样的容器来实现，std::vector会在内部处理内存分配。对于性能关键型应用程序，或者在需要明确控制内存分配方式和位置的场景中，C++提供了两种高级技术：定位放置式新对象创建（placement new）和对齐内存分配。

placement new运算符简介

placement new 运算符允许在特定的内存位置构造对象，而不是从堆中动态分配新的内存。在内存已经分配的场景中，比如在内存池或预先分配的缓冲区中，并且你想要精确控制对象的构造位置时，这项技术就很有用。

定位放置式新对象创建（placement new）的语法如下：

void* buffer = ::operator new(sizeof(SomeClass)); // 分配原始内存
SomeClass* obj = new (buffer) SomeClass(); // 在已分配的内存中构造对象

在这里，对象是在buffer指向的内存中构造的，而不是动态分配新内存。构造完对象后，在不再使用它时，必须显式调用析构函数并释放内存：

obj->~SomeClass(); // 手动调用析构函数
::operator delete(buffer); // 释放原始内存

对齐分配简介

现代处理器通常要求数据在特定的内存边界（例如16、32或64字节）上对齐，以实现最佳性能。内存对齐（Memory alignment）可确保对象存储在所需对齐大小倍数的地址上，这样可以最小化检索数据所需的内存访问次数，并提高缓存性能。

在C++中，aligned_alloc()用于分配对齐到特定边界的内存：

void* aligned_memory =
std::aligned_alloc(alignof(SomeClass),sizeof(SomeClass));
SomeClass* obj = new (aligned_memory) SomeClass();  // 在对齐的内存中构造对象

或者，在C++11及更高版本中，可以使用alignas说明符来强制对象进行特定的对齐：

struct alignas(64) AlignedStruct { double x, y, z;
};

在这种情况下，AlignedStruct将始终在64字节边界上对齐，这在缓存行大小为64字节的系统中可能会提高性能。

示例程序：定位放置式新对象创建（placement new）和对齐分配

我们将考虑一个粒子模拟场景，其中某些操作对性能很敏感，并且要求Particle对象在32字节边界上对齐。我们将使用定位放置式新对象创建（placement new）和对齐分配，以确保Particle对象放置在合适的内存位置并满足对齐约束。

定义具有对齐要求的粒子结构体

我们首先指定Particle结构体应在32字节边界上对齐。这可确保每个Particle在内存中的对齐方式能优化缓存性能，并最小化内存访问开销。

#include <iostream>
#include <new>        // 用于定位放置式新对象创建（placement new）
#include <cstdlib>    // 用于aligned_alloc和free
#include <memory>     // 用于unique_ptr
#include <vector>
struct alignas(32) Particle {
    double x, y, z;    // 位置
    double vx, vy, vz; // 速度
    Particle(double px, double py, double pz, double pvx, double pvy, double pvz)
        : x(px), y(py), z(pz),vx(pvx), vy(pvy),vz(pvz) {
        std::cout << "Particle created at address: " << this << "\n";
    }
    ~Particle() {
        std::cout << "Particle destroyed at address: " << this << "\n";
    }
};

在这里，我们使用alignas(32)说明符来确保每个Particle对象在32字节边界上对齐。这种对齐方式确保数据对缓存友好，并且可以高效地加载到缓存行中。

分配对齐内存

现在，我们将分配在32字节边界上对齐的内存，并使用定位放置式新对象创建（placement new）在这片内存中构造Particle对象。

void* allocate_aligned_memory(size_t size, size_t alignment) {
    return std::aligned_alloc(alignment, size);
}
void free_aligned_memory(void* ptr) {
    std::free(ptr); // 使用free释放对齐的内存
}
int main() {
    // 我们想要创建的粒子数量
    const size_t num_particles = 3;
    // 为num_particles个Particle对象分配对齐内存
    void* aligned_memory =
        allocate_aligned_memory(num_particles * sizeof(Particle),
        alignof(Particle));
    if (!aligned_memory) {
        std::cerr << "Failed to allocate aligned memory!\n";
        return 1;
    }
    // 使用定位放置式新对象创建（placement new）在对齐的内存中构造粒子
    Particle* particles = static_cast<Particle*>(aligned_memory);
    for (size_t i = 0; i < num_particles; ++i) {
        new (&particles[i]) Particle(i * 1.0, i * 2.0, i * 3.0, 0.1, 0.2, 0.3);
    }
    // 模拟粒子相互作用（例如，打印粒子详细信息）
    for (size_t i = 0; i < num_particles; ++i) {
        std::cout << "Particle " << i << " at address: " << &particles[i] << "\n";
    }
    // 由于我们使用了定位放置式新对象创建（placement new），所以必须手动销毁粒子
    for (size_t i = 0; i < num_particles; ++i) {
        particles[i].~Particle();
    }
    // 释放对齐的内存
    free_aligned_memory(aligned_memory);
    return 0;
}

在这里，allocate_aligned_memory()函数接受要分配的内存大小和对齐要求（在这种情况下为32字节）。分配内存后，我们使用定位放置式新对象创建（placement new）语法（new (&particles[i]) Particle(...)）在预先分配的内存块中初始化每个粒子。

现在，由于我们使用定位放置式新对象创建（placement new）来构造粒子，所以必须手动为每个粒子调用析构函数（particles[i].~Particle()）。销毁粒子后，我们使用std::free()释放对齐的内存。这一步确保已分配的内存被正确释放。

验证对齐

我们可以通过打印Particle对象的内存地址来验证它们是否正确对齐。输出结果应该显示每个粒子的内存地址是32字节的倍数，这表明它们已正确对齐。

Particle created at address: 0x7fffe2000010
Particle created at address: 0x7fffe2000030
Particle created at address: 0x7fffe2000050

Particle 0 at address: 0x7fffe2000010
Particle 1 at address: 0x7fffe2000030
Particle 2 at address: 0x7fffe2000050

在这个输出中，粒子的内存地址是32字节的倍数（例如，0x7fffe2000010、0x7fffe2000030等），证实了对齐约束已得到满足。

因此，定位放置式新对象创建（placement new）的使用允许在预先分配的内存缓冲区中构造对象，让你完全控制对象在内存中的放置位置和方式。这些技术对于需要严格控制内存使用的应用程序至关重要，例如高性能模拟、实时系统和内存受限的环境。

总结

总之，我们研究了最先进的内存性能技术，以使C++应用程序的内存管理更加高效。首先，我们致力于开发自定义分配器来管理内存分配和释放过程。这项技术能够实现更可预测的性能，特别是在需要快速内存操作的实时应用程序中。接下来，我们讨论了缓存感知编程（cache-aware programming），通过改善空间局部性并增加缓存中获取的有用数据量，这种结构调整改善了数据与缓存行边界的对齐，从而显著减少了内存访问时间并提高了整体性能。

最后，我们掌握了定位放置式新对象创建（placement new）和对齐内存分配技术，用于在对象构造过程中管理其在内存中的位置。这些技术在具有严格对齐要求的系统中优化内存访问特别有用，例如在高性能模拟或特定硬件环境中。这些最先进的内存管理技术的结合提高了缓存利用率，让用户在内存分配方面有更多的控制权，并为需要快速、低延迟内存操作的程序提升了性能。