More Effective C++ 条款18：分期摊还预期的计算成本（Amortize the Cost of Expected Computations）
More Effective C++ 条款18：分期摊还预期的计算成本（Amortize the Cost of Expected Computations）
核心思想：超急评估（over-eager evaluation）通过提前执行计算或预分配资源来分摊预期的计算成本，从而减少后续操作的开销。这种策略与缓式评估相反，它主动承担前期成本以避免未来的延迟，特别适用于那些预期会被频繁使用的操作。
🚀 1. 问题本质分析
1.1 超急评估的核心概念：
- 缓式评估 (Lazy Evaluation)：延迟计算直到真正需要，避免不必要的计算
- 超急评估 (Over-eager Evaluation)：提前计算可能需要的的结果，以便在需要时能立即提供
1.2 重复操作的开销示例：
// ❌ 每次需要时都进行计算
class SimpleCalculator {
public:double compute(int input) const {return expensiveCalculation(input); // 每次调用都计算}
};// ✅ 超急评估：预计算并缓存结果
class PrecomputedCalculator {
public:PrecomputedCalculator() {// 构造函数中预计算所有可能输入的结果for (int i = 0; i < MAX_INPUT; ++i) {cache_[i] = expensiveCalculation(i);}}double compute(int input) const {return cache_[input]; // 直接返回预计算结果}private:std::vector<double> cache_;
};
📦 2. 问题深度解析
2.1 超急评估的适用场景：
// 场景1：预计算常用数据
class PrecomputedMath {
public:PrecomputedMath() {// 预计算三角函数表for (int i = 0; i < 360; ++i) {sineTable_[i] = std::sin(i * M_PI / 180.0);cosineTable_[i] = std::cos(i * M_PI / 180.0);}}double fastSin(int degrees) const {return sineTable_[degrees % 360];}double fastCos(int degrees) const {return cosineTable_[degrees % 360];}private:std::array<double, 360> sineTable_;std::array<double, 360> cosineTable_;
};// 场景2：预分配资源避免重复分配
class ResourceManager {
public:ResourceManager() {// 预先分配一批资源preallocateResources(1000);}Resource* acquireResource() {if (freeResources_.empty()) {// 如果空闲资源不足，再分配一批preallocateResources(100);}auto resource = freeResources_.back();freeResources_.pop_back();return resource;}void releaseResource(Resource* resource) {freeResources_.push_back(resource);}private:std::vector<Resource*> freeResources_;std::vector<Resource*> allResources_;void preallocateResources(size_t count) {for (size_t i = 0; i < count; ++i) {auto resource = new Resource();freeResources_.push_back(resource);allResources_.push_back(resource);}}
};
2.2 超急评估的多种应用形式：
// 形式1：缓存（Caching）
template<typename Key, typename Value>
class PredictiveCache {
public:Value get(const Key& key) {// 先检查缓存auto it = cache_.find(key);if (it != cache_.end()) {return it->second;}// 计算并缓存结果Value value = computeValue(key);cache_[key] = value;// 预测并预缓存相关值precomputeRelated(key);return value;}private:std::unordered_map<Key, Value> cache_;Value computeValue(const Key& key) {// 昂贵的计算return Value{};}void precomputeRelated(const Key& key) {// 基于使用模式预测并预计算可能需要的相关值for (const auto& relatedKey : predictRelatedKeys(key)) {if (cache_.find(relatedKey) == cache_.end()) {cache_[relatedKey] = computeValue(relatedKey);}}}std::vector<Key> predictRelatedKeys(const Key& key) {// 基于历史使用模式预测相关键return {};}
};// 形式2：预取（Prefetching）
class DataPrefetcher {
public:void processData(const std::vector<int>& indices) {// 预取可能需要的数据prefetchData(indices);// 处理数据（此时数据可能已在缓存中）for (int index : indices) {processSingle(index);}}private:void prefetchData(const std::vector<int>& indices) {// 基于访问模式预取数据到缓存for (int index : indices) {prefetchSingle(index);}}void prefetchSingle(int index) {// 平台相关的预取指令#ifdef __GNUC____builtin_prefetch(getDataAddress(index), 0, 0);#endif}
};
⚖️ 3. 解决方案与最佳实践
3.1 实现超急评估的模式：
// ✅ 使用预计算查找表
class PrecomputedLookupTable {
public:PrecomputedLookupTable() {// 初始化时预计算所有值for (int i = 0; i < TABLE_SIZE; ++i) {table_[i] = computeEntry(i);}}double get(int index) const {return table_[index];}private:static constexpr int TABLE_SIZE = 1000;std::array<double, TABLE_SIZE> table_;static double computeEntry(int index) {// 昂贵的计算return std::sqrt(index) * std::log(index + 1);}
};// ✅ 使用对象池预分配对象
template<typename T>
class ObjectPool {
public:ObjectPool(size_t initialSize = 100) {preallocate(initialSize);}template<typename... Args>T* acquire(Args&&... args) {if (freeList_.empty()) {// 如果没有可用对象，预分配更多preallocate(growthFactor_ * freeList_.capacity());}T* obj = freeList_.back();freeList_.pop_back();// 在预分配的内存上构造对象new (obj) T(std::forward<Args>(args)...);return obj;}void release(T* obj) {// 调用析构函数但不释放内存obj->~T();freeList_.push_back(obj);}void preallocate(size_t count) {size_t previousCapacity = freeList_.capacity();freeList_.reserve(previousCapacity + count);for (size_t i = 0; i < count; ++i) {T* memory = static_cast<T*>(::operator new(sizeof(T)));freeList_.push_back(memory);}}private:std::vector<T*> freeList_;size_t growthFactor_ = 2;
};
3.2 内存预分配策略：
// ✅ 自定义向量类实现指数级增长策略
template<typename T>
class AmortizedVector {
public:AmortizedVector() : size_(0), capacity_(0), data_(nullptr) {}void push_back(const T& value) {if (size_ >= capacity_) {// 容量不足时，按指数增长策略重新分配reserve(capacity_ == 0 ? 1 : capacity_ * 2);}// 在预分配的内存中构造新元素new (&data_[size_]) T(value);++size_;}void reserve(size_t newCapacity) {if (newCapacity <= capacity_) return;// 分配新内存T* newData = static_cast<T*>(::operator new(newCapacity * sizeof(T)));// 移动现有元素for (size_t i = 0; i < size_; ++i) {new (&newData[i]) T(std::move(data_[i]));data_[i].~T();}// 释放旧内存::operator delete(data_);data_ = newData;capacity_ = newCapacity;}private:size_t size_;size_t capacity_;T* data_;
};
3.3 使用现代C++特性实现超急评估：
// ✅ 使用constexpr在编译期计算
constexpr std::array<double, 100> precomputeConstants() {std::array<double, 100> result{};for (int i = 0; i < 100; ++i) {result[i] = std::sqrt(i) * std::log(i + 1);}return result;
}// 编译期计算的表
static constexpr auto constantsTable = precomputeConstants();// ✅ 使用线程局部存储预计算线程特定数据
class ThreadSpecificPrecomputation {
public:double compute(int input) {// 每个线程有自己的预计算缓存thread_local std::unordered_map<int, double> cache;thread_local bool initialized = false;if (!initialized) {// 线程第一次使用时预计算常用值precomputeCommonValues(cache);initialized = true;}auto it = cache.find(input);if (it != cache.end()) {return it->second;}// 计算并缓存新值double result = expensiveCalculation(input);cache[input] = result;return result;}private:void precomputeCommonValues(std::unordered_map<int, double>& cache) {// 预计算最常用的值for (int i = 0; i < 100; ++i) {cache[i] = expensiveCalculation(i);}}double expensiveCalculation(int input) {// 昂贵的计算return input * 3.14159;}
};
3.4 基于使用模式的预测性预计算：
// ✅ 基于历史访问模式预测未来需求
class PredictivePrecomputation {
public:void recordAccess(int key) {accessHistory_.push_back(key);if (accessHistory_.size() > MAX_HISTORY) {accessHistory_.pop_front();}}double get(int key) {recordAccess(key);// 检查缓存auto it = cache_.find(key);if (it != cache_.end()) {return it->second;}// 计算并缓存double result = compute(key);cache_[key] = result;// 预测并预计算可能需要的值precomputePredictedValues(key);return result;}private:std::unordered_map<int, double> cache_;std::deque<int> accessHistory_;static constexpr size_t MAX_HISTORY = 1000;double compute(int key) {// 昂贵的计算return key * 2.71828;}void precomputePredictedValues(int currentKey) {// 基于历史模式预测下一步可能需要的值auto predictedKeys = predictNextKeys(currentKey);for (int key : predictedKeys) {if (cache_.find(key) == cache_.end()) {cache_[key] = compute(key);}}}std::vector<int> predictNextKeys(int currentKey) {// 简单的预测算法：返回最近常与currentKey一起访问的键std::unordered_map<int, int> cooccurrence;for (size_t i = 0; i < accessHistory_.size(); ++i) {if (accessHistory_[i] == currentKey && i + 1 < accessHistory_.size()) {int nextKey = accessHistory_[i + 1];cooccurrence[nextKey]++;}}// 返回最常一起出现的键std::vector<int> result;for (const auto& pair : cooccurrence) {if (pair.second > 2) { // 至少共同出现3次result.push_back(pair.first);}}return result;}
};
💡 关键实践原则
-
识别适合超急评估的场景
在以下情况下考虑使用超急评估：void identifyOverEagerOpportunities() {// 1. 频繁使用的计算for (int i = 0; i < 1000; ++i) {auto result = compute(i); // 重复计算相同输入}// 2. 可预测的访问模式std::vector<int> data;// 已知要添加1000个元素，应预分配for (int i = 0; i < 1000; ++i) {data.push_back(i); // 可能导致多次重新分配}// 3. 启动时间可接受预计算PrecomputedCache cache; // 启动时预计算 } -
权衡超急评估的利弊
超急评估需要权衡：class OverEagerTradeOff { public:// 优点：减少运行时计算延迟int getPrecomputed(int index) const {return precomputedTable_[index]; // 快速访问}// 缺点：可能预计算了从不使用的数据void precomputeEverything() {for (int i = 0; i < MAX_INDEX; ++i) {precomputedTable_[i] = computeForIndex(i); // 可能浪费}}// 缺点：增加启动时间和内存使用OverEagerTradeOff() {precomputeEverything(); // 构造函数中预计算，增加启动时间}private:std::vector<int> precomputedTable_; }; -
提供灵活的预计算策略
让用户可以根据需要控制预计算：class FlexiblePrecomputation { public:// 允许用户选择预计算级别enum class PrecomputationLevel {None, // 不预计算Basic, // 基本预计算Full // 完全预计算};FlexiblePrecomputation(PrecomputationLevel level) {switch (level) {case PrecomputationLevel::None:break;case PrecomputationLevel::Basic:precomputeBasic();break;case PrecomputationLevel::Full:precomputeFull();break;}}int compute(int input) {if (basicCache_.contains(input)) {return basicCache_[input];}if (fullCache_.contains(input)) {return fullCache_[input];}return computeDirectly(input);}private:void precomputeBasic() {// 预计算常用输入for (int i = 0; i < 100; ++i) {basicCache_[i] = computeDirectly(i);}}void precomputeFull() {// 预计算所有可能输入for (int i = 0; i < MAX_INPUT; ++i) {fullCache_[i] = computeDirectly(i);}}std::unordered_map<int, int> basicCache_;std::unordered_map<int, int> fullCache_; };
现代C++中的超急评估工具：
// 使用constexpr和consteval进行编译期计算 constexpr auto precomputedTable = precomputeTable();// 使用std::array和编译期计算结合 template<size_t N> constexpr std::array<int, N> precomputeArray() {std::array<int, N> result{};for (size_t i = 0; i < N; ++i) {result[i] = i * i; // 示例计算}return result; }// 使用线程局部存储实现线程特定缓存 thread_local std::unordered_map<int, double> threadCache;double cachedCompute(int input) {auto it = threadCache.find(input);if (it != threadCache.end()) {return it->second;}double result = compute(input);threadCache[input] = result;return result; }// 使用内存映射文件预加载数据 #ifdef __linux__ #include <sys/mman.h> #endifvoid preloadData(const std::string& filename) {// 使用操作系统特性预加载数据到内存// 注意：这通常是平台特定的代码 }
代码审查要点：
- 检查超急评估是否应用于真正的性能热点
- 确认预计算的数据确实被频繁使用（避免浪费）
- 验证内存使用是否在可接受范围内（预计算可能增加内存开销）
- 检查线程安全性（如果预计算数据被多线程访问）
- 确认启动时间是否可接受（大量预计算可能增加启动时间）
总结：
超急评估是一种通过预计算和缓存来分摊预期计算成本的优化技术。它与缓式评估形成互补，适用于那些预期会被频繁使用的计算结果。实现超急评估有多种方式，包括预计算表、缓存、预分配资源等。现代C++提供了constexpr、consteval、线程局部存储等工具来帮助实现高效的超急评估。然而，超急评估也需要权衡利弊，它可能增加内存使用和启动时间，并可能预计算从不使用的数据。因此，应该只在已识别的性能热点上应用超急评估，并提供灵活的预计算策略让用户可以根据需要控制预计算级别。正确应用的超急评估可以显著提升程序性能，特别是在需要快速响应和可预测访问模式的场景中。