Почему потоки между процессами НЕ МОГУТ масштабироваться в пинг-понге? ⇐ Linux

[Anonymous]

Вопрос касается масштабируемости пинг-понговой связи с использованием потоков/процессов. Мы считаем, что пинг-понговая связь между потоками (CASE-1), принадлежащими двум процессам, обеспечивает 1/10 пропускной способности пинг-понговой связи между процессами (CASE-2), основанной на той же структуре данных.
Предположим, мы создаем только два процесса, оба случая обеспечивают пропускную способность 1,2 швабры. Однако, когда мы увеличиваем номер потока/процесса до N * 2, CASE-1 может обеспечить только 5 mops (с 96 потоками в двух процессах), тогда как CASE-2 может предложить 60 mops, когда номер процесса равен 96 x 2.
Почему это произошло или я ошибаюсь?
ping-side:
local variable count = 0;
while (true) {
ping++;
count++;
while (count > 0) {
if (!pong) sched_yield();
else break;
}
if (pong) {
pong--;
count--;
}
}

сторона понга:
while (true) {
while (!ping) {
sched_yield();
}
pong++;
ping--;
}

СЛУЧАЙ-1
pid_t t = fork();
if (t > 0) {
for (int t = 0; t < N; t++) {
thread([&](int tid){
ping-side operating on ping[tid]/pong[tid]
}, t);
}
} else if (t == 0) {
for (int t = 0; t < N; t++) {
thread([&](int tid){
pong-side operating on ping[tid]/pong[tid]
}, t);
}
}

СЛУЧАЙ-2
for (int t = 0; t < 2 * N; t++) {
pid_t tid = fork();
if (tid == 0) {
if (t < N)){
ping-side operating on ping[t % N]/pong[t % N]
} else {
pong-side operating on ping[t % N]/pong[t % N]
}
break;
} else if (t == 0) {
wait_all();
}
}

Минимальный пример выглядит следующим образом. Пожалуйста, скомпилируйте и оцените его на основе 96-ядерной платформы.
g++ -O3 -o test test.cpp -lnuma -lpthread -lrt
CASE-1 ./test 96 1000000 1 96
CASE-2 ./test 96 1000000 0 96

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include

#define USE_THREAD 0

#define preempt() sched_yield() //usleep(1) //sched_yield

class atomicPQ {
alignas(64) std::atomic ping{0};
alignas(64) std::atomic pong{0};
public:
atomicPQ() {
ping.store(0);
pong.store(0);
}

uint64_t ping_degrade(int num = -1) {
return ping.fetch_add(num);
}

uint64_t pong_degrade(int num = -1) {
return pong.fetch_add(num);
}

int64_t ping_fetch() { return ping.load(); }

int64_t pong_fetch() { return pong.load(); }

void ping_upgrade() { ping.fetch_add(1); }

void pong_upgrade() { pong.fetch_add(1); }
};

void ping(int id, int MAX_CORES, bool prod = true) {
cpu_set_t mask;
CPU_ZERO(&mask);
CPU_SET(id % MAX_CORES, &mask);
sched_setaffinity(0, sizeof(cpu_set_t), &mask);
}

void threadSwitch(int argc, char** argv) {
int work_num = std::atoi(argv[1]);
size_t total_round = std::atol(argv[2]);
int type = std::atoi(argv[3]);
int MAX_CORES = std::atoi(argv[4]);
constexpr uint64_t max_queue_depth = 1;
int commem = shm_open("fusecomplete", O_RDWR | O_CREAT | O_APPEND, S_IRUSR | S_IWUSR);
for (int i = 0; i 0) {
sem[tid].pong_degrade();
active--;
} else
preempt();
}
sem[work_num].ping_upgrade(); // communicate with consumer for quit notification
terminated.fetch_add(1);
total_count.fetch_add(count);
}, i);
}
for (auto& p: producers) {
p.join();
}
for (auto& t: calculators) t.join();
auto end_time = std::chrono::high_resolution_clock::now();
uint64_t microseconds = std::chrono::duration_cast(end_time - start_time).count();
std::cout

Подробнее здесь: https://stackoverflow.com/questions/790 ... n-pingpong