生产者-消费者在超级兄弟与非超级兄弟之间共享内存位置的延迟和吞吐量成本是多少？

单个进程中的两个不同线程可以share通过读取和/或写入来获取公共内存位置。

通常，这种（有意的）共享是使用原子操作来实现的lockx86 上的前缀，其成本众所周知lock前缀本身（即无竞争成本）以及缓存行时的额外一致性成本实际上共享（真实或false https://en.wikipedia.org/wiki/False_sharing共享）。

在这里，我对单线程的生产者-消费者成本感兴趣P写入内存位置，另一个线程`C 从内存位置读取，两者都使用plain读取和写入。

在同一插槽上的不同内核上执行此类操作时，与在最新 x86 内核上的同一物理内核上的同级超线程上执行时相比，该操作的延迟和吞吐量是多少。

在标题中，我使用术语“超级同级”来指代在同一核心的两个逻辑线程上运行的两个线程，使用术语“核心同级”来指代在不同物理核心上运行的两个线程的更常见情况。

好吧，我找不到任何权威来源，所以我想我自己尝试一下。

#include <pthread.h>
#include <sched.h>
#include <atomic>
#include <cstdint>
#include <iostream>


alignas(128) static uint64_t data[SIZE];
alignas(128) static std::atomic<unsigned> shared;
#ifdef EMPTY_PRODUCER
alignas(128) std::atomic<unsigned> unshared;
#endif
alignas(128) static std::atomic<bool> stop_producer;
alignas(128) static std::atomic<uint64_t> elapsed;

static inline uint64_t rdtsc()
{
    unsigned int l, h;
    __asm__ __volatile__ (
        "rdtsc"
        : "=a" (l), "=d" (h)
    );
    return ((uint64_t)h << 32) | l;
}

static void * consume(void *)
{
    uint64_t    value = 0;
    uint64_t    start = rdtsc();

    for (unsigned n = 0; n < LOOPS; ++n) {
        for (unsigned idx = 0; idx < SIZE; ++idx) {
            value += data[idx] + shared.load(std::memory_order_relaxed);
        }
    }

    elapsed = rdtsc() - start;
    return reinterpret_cast<void*>(value);
}

static void * produce(void *)
{
    do {
#ifdef EMPTY_PRODUCER
        unshared.store(0, std::memory_order_relaxed);
#else
        shared.store(0, std::memory_order_relaxed);
#enfid
    } while (!stop_producer);
    return nullptr;
}



int main()
{
    pthread_t consumerId, producerId;
    pthread_attr_t consumerAttrs, producerAttrs;
    cpu_set_t cpuset;

    for (unsigned idx = 0; idx < SIZE; ++idx) { data[idx] = 1; }
    shared = 0;
    stop_producer = false;

    pthread_attr_init(&consumerAttrs);
    CPU_ZERO(&cpuset);
    CPU_SET(CONSUMER_CPU, &cpuset);
    pthread_attr_setaffinity_np(&consumerAttrs, sizeof(cpuset), &cpuset);

    pthread_attr_init(&producerAttrs);
    CPU_ZERO(&cpuset);
    CPU_SET(PRODUCER_CPU, &cpuset);
    pthread_attr_setaffinity_np(&producerAttrs, sizeof(cpuset), &cpuset);

    pthread_create(&consumerId, &consumerAttrs, consume, NULL);
    pthread_create(&producerId, &producerAttrs, produce, NULL);

    pthread_attr_destroy(&consumerAttrs);
    pthread_attr_destroy(&producerAttrs);

    pthread_join(consumerId, NULL);
    stop_producer = true;
    pthread_join(producerId, NULL);

    std::cout <<"Elapsed cycles: " <<elapsed <<std::endl;
    return 0;
}

使用以下命令进行编译，替换定义：

gcc -std=c++11 -DCONSUMER_CPU=3 -DPRODUCER_CPU=0 -DSIZE=131072 -DLOOPS=8000 timing.cxx -lstdc++ -lpthread -O2 -o timing

Where:

• CONSUMER_CPU 是运行消费者线程的 cpu 编号。
• PRODUCER_CPU 是运行生产者线程的 cpu 编号。
• SIZE 是内部循环的大小（与缓存有关）
• LOOPS 是，嗯...

以下是生成的循环：

消费者线程

  400cc8:       ba 80 24 60 00          mov    $0x602480,%edx
  400ccd:       0f 1f 00                nopl   (%rax)
  400cd0:       8b 05 2a 17 20 00       mov    0x20172a(%rip),%eax        # 602400 <shared>
  400cd6:       48 83 c2 08             add    $0x8,%rdx
  400cda:       48 03 42 f8             add    -0x8(%rdx),%rax
  400cde:       48 01 c1                add    %rax,%rcx
  400ce1:       48 81 fa 80 24 70 00    cmp    $0x702480,%rdx
  400ce8:       75 e6                   jne    400cd0 <_ZL7consumePv+0x20>
  400cea:       83 ee 01                sub    $0x1,%esi
  400ced:       75 d9                   jne    400cc8 <_ZL7consumePv+0x18>

生产者线程，带有空循环（不写入shared):

  400c90:       c7 05 e6 16 20 00 00    movl   $0x0,0x2016e6(%rip)        # 602380 <unshared>
  400c97:       00 00 00 
  400c9a:       0f b6 05 5f 16 20 00    movzbl 0x20165f(%rip),%eax        # 602300 <stop_producer>
  400ca1:       84 c0                   test   %al,%al
  400ca3:       74 eb                   je     400c90 <_ZL7producePv>

生产者线程，写入shared:

  400c90:       c7 05 66 17 20 00 00    movl   $0x0,0x201766(%rip)        # 602400 <shared>
  400c97:       00 00 00 
  400c9a:       0f b6 05 5f 16 20 00    movzbl 0x20165f(%rip),%eax        # 602300 <stop_producer>
  400ca1:       84 c0                   test   %al,%al
  400ca3:       74 eb                   je     400c90 <_ZL7producePv>

该程序计算消费者核心上消耗的 CPU 周期数，以完成整个循环。我们将第一个生产者（除了消耗 CPU 周期之外什么都不做）与第二个生产者（通过重复写入来扰乱消费者）进行比较。shared.

我的系统有 i5-4210U。即2个核心，每个核心2个线程。它们被内核公开为Core#1 → cpu0, cpu2 Core#2 → cpu1, cpu3.

根本没有启动生产者的结果：

CONSUMER    PRODUCER     cycles for 1M      cycles for 128k
    3          n/a           2.11G              1.80G

生产者为空的结果。对于 1G 操作（1000*1M 或 8000*128k）。

CONSUMER    PRODUCER     cycles for 1M      cycles for 128k
    3           3            3.20G              3.26G       # mono
    3           2            2.10G              1.80G       # other core
    3           1            4.18G              3.24G       # same core, HT

正如预期的那样，由于两个线程都占用了 cpu 并且都获得了公平的份额，因此生产者销毁周期使消费者的速度减慢了大约一半。这只是 cpu 争用。

对于生产者在 cpu#2 上，由于没有交互，消费者的运行不会受到在另一个 cpu 上运行的生产者的影响。

通过 cpu#1 上的生产者，我们可以看到超线程正在发挥作用。

颠覆性生产者的结果：

CONSUMER    PRODUCER     cycles for 1M      cycles for 128k
    3           3            4.26G              3.24G       # mono
    3           2           22.1 G             19.2 G       # other core
    3           1           36.9 G             37.1 G       # same core, HT

• 当我们将两个线程调度到同一核心的同一线程上时，不会产生任何影响。再次预期，因为生产者写入保持在本地，不会产生同步成本。

• 我无法真正解释为什么超线程的性能比两个核心的性能差得多。欢迎咨询。