最近，我正在研究一个计算泊松分布的函数的多线程实现（amath_pdist）。目标是将工作负载分配到多个线程以提高性能，特别是对于大型阵列。然而，我注意到随着数组大小的增加，速度明显减慢，而不是达到预期的加速。

经过一番调查，我发现了罪魁祸首：虚假分享。在这篇文章中，我将解释什么是错误共享，展示导致问题的原始代码，并分享导致性能大幅提升的修复方法。

---

问题：多线程代码中的错误共享

错误共享当多个线程在共享数组的不同部分工作时发生，但它们的数据驻留在同一个缓存行中。高速缓存行是内存和 cpu 高速缓存之间传输的最小数据单元（通常为 64 字节）。如果一个线程写入缓存行的一部分，就会使其他线程的该行无效，即使它们正在处理逻辑上独立的数据。由于重复重新加载缓存行，这种不必要的失效会导致性能显着下降。

这是我的原始代码的简化版本：

void *calculate_pdist_segment(void *data) {
    struct pdist_segment *segment = (struct pdist_segment *)data;
    size_t interval_a = segment->interval_a, interval_b = segment->interval_b;
    double lambda = segment->lambda;
    int *d = segment->data;

    for (size_t i = interval_a; i < interval_b; i++) {
        segment->pdist[i] = pow(lambda, d[i]) * exp(-lambda) / tgamma(d[i] + 1);
    }
    return null;
}

double *amath_pdist(int *data, double lambda, size_t n_elements, size_t n_threads) {
    double *pdist = malloc(sizeof(double) * n_elements);
    pthread_t threads[n_threads];
    struct pdist_segment segments[n_threads];
    size_t step = n_elements / n_threads;

    for (size_t i = 0; i < n_threads; i++) {
        segments[i].data = data;
        segments[i].lambda = lambda;
        segments[i].pdist = pdist;
        segments[i].interval_a = step * i;
        segments[i].interval_b = (i == n_threads - 1) ? n_elements : (step * (i + 1));
        pthread_create(&threads[i], null, calculate_pdist_segment, &segments[i]);
    }

    for (size_t i = 0; i < n_threads; i++) {
        pthread_join(threads[i], null);
    }

    return pdist;
}

---

问题发生在哪里

上面的代码中：

• 数组 pdist 在所有线程之间共享。
• 每个线程写入特定范围的索引（interval_a 到interval_b）。
• 在段边界，相邻索引可能驻留在同一缓存行中。例如，如果 pdist[249999] 和 pdist[250000] 共享一个缓存行，则线程 1（处理 pdist[249999]）和线程 2（处理 pdist[250000]）会使彼此的缓存行无效。

这个问题对于较大的数组来说扩展性很差。虽然边界问题看起来很小，但迭代的绝对数量放大了缓存失效的成本，导致数秒的不必要的开销。

---

解决方案：将内存与缓存行边界对齐

为了解决该问题，我使用 posix_memalign 来确保 pdist 数组与 64 字节边界 对齐。这保证了线程在完全独立的缓存行上运行，消除了错误共享。

AI舌诊面诊问诊医疗系统+诊疗商城系统源码

AI 舌诊面诊问诊医疗系统 + 诊疗商城系统源码是一套结合 AI 辅助诊断与商品转化的健康类程序，基于浩创云、ThinkPHP（PHP）开发，支持微信服务号与 H5 端，适合做中医舌诊面诊问答、健康建议推送以及配套诊疗商品的运营。

下载

这是更新后的代码：

double *amath_pdist(int *data, double lambda, size_t n_elements, size_t n_threads) {
    double *pdist;
    if (posix_memalign((void **)&pdist, 64, sizeof(double) * n_elements) != 0) {
        perror("Failed to allocate aligned memory");
        return NULL;
    }

    pthread_t threads[n_threads];
    struct pdist_segment segments[n_threads];
    size_t step = n_elements / n_threads;

    for (size_t i = 0; i < n_threads; i++) {
        segments[i].data = data;
        segments[i].lambda = lambda;
        segments[i].pdist = pdist;
        segments[i].interval_a = step * i;
        segments[i].interval_b = (i == n_threads - 1) ? n_elements : (step * (i + 1));
        pthread_create(&threads[i], NULL, calculate_pdist_segment, &segments[i]);
    }

    for (size_t i = 0; i < n_threads; i++) {
        pthread_join(threads[i], NULL);
    }

    return pdist;
}

---

为什么这有效？

1. 对齐内存:

   • 使用 posix_memalign，数组从缓存行边界开始。
   • 每个线程分配的范围与缓存行整齐对齐，防止重叠。

2. 无缓存线共享:

   • 线程在不同的缓存行上运行，消除了错误共享导致的失效。

3. 提高缓存效率:

   • 顺序内存访问模式与 cpu 预取器很好地配合，进一步提高性能。

---

结果和要点

应用修复后，amath_pdist 函数的运行时间显着下降。对于我正在测试的数据集，挂钟时间从 10.92 秒下降到 0.06 秒。

主要经验教训：

1. 错误共享是多线程应用程序中一个微妙但关键的问题。即使段边界处的微小重叠也会降低性能。
2. 内存对齐使用posix_memalign是解决错误共享的简单有效的方法。将内存与缓存行边界对齐可确保线程独立运行。
3. 在处理大型数组或并行处理时，始终分析代码是否存在与缓存相关的问题。 perf 或 valgrind 等工具可以帮助查明瓶颈。

感谢您的阅读！

对于任何对代码感兴趣的人，您可以在这里找到它