测量CCNUMA系统上的带宽

Question

在CCNUMA系统上测试内存带宽

1. 我试图用2x Intel（R）Xeon（R）Platinum 8168： 24核心 @ 2.70 GHz，
2. L1 Cache 32 KB，L2 Cache 1 Mb和L3 Cache 33 MB

。作为参考，我使用的是Intel Advisor的屋顶图，该图描述了每个CPU数据路径的带宽。据此，带宽为230 GB/s。

为了对此进行基准测试，我正在使用自己的小基准辅助工具，该工具在循环中执行定时实验。 API提供了一个抽象类，称为persiment_functor 看起来这样：

class experiment_functor
{
public:
    
    //+/////////////////
    // main functionality
    //+/////////////////
    
    virtual void init() = 0;
    
    virtual void* data(const std::size_t&) = 0;
    
    virtual void perform_experiment() = 0;
    
    virtual void finish() = 0;
};

然后，用户（我自己）可以定义数据初始化，定时进行的工作和清理例程，以便每个实验都可以使用新鲜分配的数据。可以将派生类的实例提供给API函数：

perf_stats perform_experiments(experiment_functor& exp_fn, const std::size_t& data_size_in_byte, const std::size_t& exp_count)

这是SchönauerVectorTriad的类实现：

class exp_fn : public experiment_functor
{
    //+/////////////////
    // members
    //+/////////////////
    
    const std::size_t data_size_;
    double* vec_a_ = nullptr;
    double* vec_b_ = nullptr;
    double* vec_c_ = nullptr;
    double* vec_d_ = nullptr;
    
public:
    
    //+/////////////////
    // lifecycle
    //+/////////////////
    
    exp_fn(const std::size_t& data_size)
        : data_size_(data_size) {}
    
    //+/////////////////
    // main functionality
    //+/////////////////
    
    void init() final
    {
        // allocate
        const auto page_size = sysconf(_SC_PAGESIZE) / sizeof(double);
        posix_memalign(reinterpret_cast<void**>(&vec_a_), page_size, data_size_ * sizeof(double));
        posix_memalign(reinterpret_cast<void**>(&vec_b_), page_size, data_size_ * sizeof(double));
        posix_memalign(reinterpret_cast<void**>(&vec_c_), page_size, data_size_ * sizeof(double));
        posix_memalign(reinterpret_cast<void**>(&vec_d_), page_size, data_size_ * sizeof(double));
        if (vec_a_ == nullptr || vec_b_ == nullptr || vec_c_ == nullptr || vec_d_ == nullptr)
        {
            std::cerr << "Fatal error, failed to allocate memory." << std::endl;
            std::abort();
        }

        // apply first-touch
        #pragma omp parallel for schedule(static)
        for (auto index = std::size_t{}; index < data_size_; index += page_size)
        {
            vec_a_[index] = 0.0;
            vec_b_[index] = 0.0;
            vec_c_[index] = 0.0;
            vec_d_[index] = 0.0;
        }
    }
    
    void* data(const std::size_t&) final
    {
        return reinterpret_cast<void*>(vec_d_);
    }
    
    void perform_experiment() final
    {
        #pragma omp parallel for simd safelen(8) schedule(static)
        for (auto index = std::size_t{}; index < data_size_; ++index)
        {
            vec_d_[index] = vec_a_[index] + vec_b_[index] * vec_c_[index]; // fp_count: 2, traffic: 4+1
        }
    }
    
    void finish() final
    {
        std::free(vec_a_);
        std::free(vec_b_);
        std::free(vec_c_);
        std::free(vec_d_);
    }
};

注意：函数data在它试图取消NUMA平衡的影响。在随机迭代中，函数persion_experiments经常以随机的方式使用所有线程写入此功能提供的数据。

问题：使用它，我一直在获得最大值。 201 GB/s的带宽。为什么我无法达到230 GB/s的规定？

如果需要，我很高兴提供任何额外的信息。非常感谢您的回答。

---

更新：

按照@Victoreijkhout的建议，我现在对仅阅读带宽进行了强大的缩放实验。

如您所见，峰带宽的确是平均217 GB/s，最大225 GB/s。值得注意的是，在某个时刻，添加CPU实际上会降低有效的带宽。

Answer 1

带宽性能取决于您执行的操作类型。读取＆amp;写道，您确实不会得到峰值数字。如果您只阅读，您将变得更近。

我建议您阅读“流基准”的文档，并查看已发布的数字。

进一步注意：希望您将线程与OMP_PROC_BIND将其绑定在一起？此外，您的架构在核心用完之前就没有带宽。您的最佳带宽性能可能会少于核心总数。