c - Pthreads 在循环完成之前返回，工作似乎在后台继续

Question

我编写了一个简单的基准测试来测试和测量处理器和 OpenCL 设备的单精度融合乘加性能。

我最近使用 Pthread 添加了 SMP 支持。 CPU 端很简单，它会为输入生成几个随机矩阵，以确保工作不会被编译器优化掉。

函数 cpu_result_matrix() 创建线程，并阻塞直到每个线程使用 pthread_join() 返回。正是这个定时功能决定了设备的性能。

static float *cpu_result_matrix(struct bench_buf *in)
{
        const unsigned tc = nthreads();
        struct cpu_res_arg targ[tc];

        float *res = aligned_alloc(16, BUFFER_SIZE * sizeof(float));

        for (unsigned i = 0; i < tc; i++) {
                targ[i].tid = i;
                targ[i].tc = tc;
                targ[i].in = in;
                targ[i].ret = res;
        }

        pthread_t cpu_res_t[tc];

        for (unsigned i = 0; i < tc; i++)
                pthread_create(&cpu_res_t[i], NULL,
                               cpu_result_matrix_mt, (void *)&targ[i]);

        for (unsigned i = 0; i < tc; i++)
                pthread_join(cpu_res_t[i], NULL);

        return res;
}

实际内核在cpu_result_matrix_mt():

static void *cpu_result_matrix_mt(void *v_arg)
{
        struct cpu_res_arg *arg = (struct cpu_res_arg *)v_arg;

        const unsigned buff_size = BUFFER_SIZE;
        const unsigned work_size = buff_size / arg->tc;
        const unsigned work_start = arg->tid * work_size;
        const unsigned work_end = work_start + work_size;

        const unsigned round_cnt = ROUNDS_PER_ITERATION;

        float lres;

        for (unsigned i = work_start; i < work_end; i++) {

                lres = 0;
                float a = arg->in->a[i], b = arg->in->b[i], c = arg->in->c[i];

                for (unsigned j = 0; j < round_cnt; j++) {
                        lres += a * ((b * c) + b);
                        lres += b * ((c * a) + c);
                        lres += c * ((a * b) + a);
                }

                arg->ret[i] = lres;
        }

        return NULL;
}

我注意到报告的内核花费的时间大致相同，无论我展开了多少内部循环。

为了进行调查，我通过手动展开内部循环使内核变得更大，直到我可以轻松测量程序运行的墙时间。

在这个过程中，我观察到(看起来)线程在内核完成它实际应该做的工作之前返回，这导致 pthread_join() 停止阻塞主线程，并且执行时间看起来很长低于实际情况。我不明白这是怎么可能的，或者程序如何在这些条件下继续运行并输出正确的结果。

Htop 显示线程仍然非常活跃并且正在工作。我查看了pthread_join()的返回值，每次运行成功。我很好奇，在内核的末尾，在 return 语句之前放了一个 print 语句，果然，每个线程都打印出它比它应该完成的要早得多。

我在运行程序时观察 ps，它显示一个线程，接着是三个线程，另外五个线程，然后下降到四个线程。

我很困惑，我以前从未见过这样的线程。

我修改后的测试分支的完整源代码在这里:https://github.com/jakogut/clperf/tree/test

Answer 1

In the process, I observed that (it appears) the threads are returning before the kernel does the work it actually should do, which causes pthread_join() to stop blocking the main thread, and the execution time to appear to be much lower than it really is.

我不确定您是如何确定这一点的。但是查看带有 -Ofast 的程序集表明

res[i] += a * ((b * c) + b);
res[i] += b * ((c * a) + c);
res[i] += c * ((a * b) + a);

在内循环之前计算。内循环是有效的

float t = a * ((b * c) + b) + b * ((c * a) + c) + c * ((a * b) + a);
float sum = 0;
for (unsigned j = 0; j < ROUNDS_PER_ITERATION; j++) {
    sum += t;     
}
res[i] = sum;

如果在你的时间你期望你的内部循环做 sum += a * ((b * c) + b) + b * ((c * a) + c) + c * (( a * b) + a) 每次迭代，而实际上它只执行 sum += t 那么您的时间估计将比您观察到的大得多。