Question

我是一个有线程的初学者，我有2个浮点数组（每个1024个元素），一个用于实部，另一个用于虚部，我必须进行一些计算。

所以我想通过使用4个线程来提高代码的性能，并且我将我的数组分成4个子部分，每个子部分大小为256个元素。因此每个线程都在处理数组的每个子部分的一部分，例如：

线程编号：

处理元素索引0到索引64
处理元素索引256以索引319
处理元素索引512以索引575
处理元素索引768到索引831

线程Nr 2 ：

处理元素索引64到索引127
处理元素索引320以索引383
处理元素索引576到索引639
处理元素索引832到索引895

线程Nr 3 ：

处理元素索引128到索引191
处理元素索引384以索引447
处理元素索引640到索引703
处理元素索引896到索引959

线程Nr 4 ：

处理元素索引192到索引255
处理元素索引448到索引511
处理元素索引704到索引767
将元素索引960工作到索引1023

试一试，我写了这段代码：

#define SHIFT_FACTOR 8
#define SIMD_SIZE    256
struct thread_data
{
    unsigned            start;
    unsigned            stop;
    unsigned            Twids_idx;
    float*              re_in;
    float*              im_in;
    float*              re_out;
    float*              im_out;
};

struct          thread_data     thread_data_array[4];
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

void *thread_routine(void *thread_info)
{
    int n;
    unsigned t_start, t_stop, tw_offset;
    unsigned ind1, ind2, ind3;
    float *Re_in, *Im_in;
    float *Re_out, *Im_out;
    struct thread_data *mydata;

    mydata = (struct thread_data*) thread_info;
    t_start = mydata->start;
    t_stop = mydata->stop;
    Re_in = mydata->re_in;
    Im_in = mydata->im_in;
    Re_out = mydata->re_out;
    Im_out = mydata->im_out;

    for (n = t_start; n < t_stop; n += SHIFT_FACTOR)
    {
        pthread_mutex_lock(&mutex);
        ind1 = 256 + n;
        ind2 = 512 + n;
        ind3 = 768 + n;

        __LOAD_PS__((RE_vec_a, &Re_in[n]), SIMD_SIZE);
        __LOAD_PS__((RE_vec_b, &Re_in[ind2]), SIMD_SIZE);
        __LOAD_PS__((RE_vec_c, &Re_in[ind1]), SIMD_SIZE);
        __LOAD_PS__((RE_vec_d, &Re_in[ind3]), SIMD_SIZE);

        __LOAD_PS__((IM_vec_a, &Im_in[n]), SIMD_SIZE);
        __LOAD_PS__((IM_vec_b, &Im_in[ind2]), SIMD_SIZE);
        __LOAD_PS__((IM_vec_c, &Im_in[ind1]), SIMD_SIZE);
        __LOAD_PS__((IM_vec_d, &Im_in[ind3]), SIMD_SIZE);
        pthread_mutex_unlock(&mutex);

        pthread_mutex_lock(&mutex);
        __STORE_PS__((&Re_out[n], RE_vec_a), SIMD_SIZE);
        __STORE_PS__((&Re_out[ind1], RE_vec_c), SIMD_SIZE);
        __STORE_PS__((&Re_out[ind2], RE_vec_b), SIMD_SIZE);
        __STORE_PS__((&Re_out[ind3], RE_vec_d), SIMD_SIZE);

        __STORE_PS__((&Im_out[n], IM_vec_a), SIMD_SIZE);
        __STORE_PS__((&Im_out[ind1], IM_vec_c), SIMD_SIZE);
        __STORE_PS__((&Im_out[ind2], IM_vec_b), SIMD_SIZE);
        __STORE_PS__((&Im_out[ind3], IM_vec_d), SIMD_SIZE);
        pthread_mutex_unlock(&mutex);
    }
    pthread_exit(NULL);
}

void foo(float* data1, float* data2, float* result1, float* result2)
{
    unsigned         t, i = 0, tw = 0;
    pthread_t        threads[4];

    for (t = 0; t < 256; t += 64)
    {
        thread_data_array[i].start = t;
        thread_data_array[i].stop = t + QUARTER;
        thread_data_array[i].re_in = data1;
        thread_data_array[i].im_in = data2;
        thread_data_array[i].re_out = result1;
        thread_data_array[i].im_out = result2;
        pthread_create(&threads[i], NULL, thread_routine, (void *)&thread_data_array[i]);
        i++;
    }
    for (i = 0; i < 4; i++)
        pthread_join(threads[i], NULL);
}

正如您所看到的，我只使用包含Intel内在函数的一些宏__LOAD_PS__() __STORE_PS__()在相同位置加载和存储元素。

我试图检查执行的正确性，结果是10次尝试：7给出了正确的结果和3个部分错误的结果。

有人可以解释一下背后的原因是什么？

线程执行不稳定

0 个答案: