c – 代码运行速度比2个线程慢1倍

所以我编写了一些代码来试验线程并进行一些测试.

代码应创建一些数字,然后找到这些数字的平均值.

我认为到目前为止,向您展示我的内容会更容易.我期待两个线程的代码运行速度大约是其两倍.用秒表测量它我觉得它运行速度慢了6倍！编辑：现在使用计算机和clock()函数来告诉时间.

void findmean(std::vector<double>*,std::size_t,double*);


int main(int argn,char** argv)
{

    // Program entry point
    std::cout << "Generating data..." << std::endl;

    // Create a vector containing many variables
    std::vector<double> data;
    for(uint32_t i = 1; i <= 1024 * 1024 * 128; i ++) data.push_back(i);

    // Calculate mean using 1 core
    double mean = 0;
    std::cout << "Calculating mean,1 Thread..." << std::endl;
    findmean(&data,data.size(),&mean);
    mean /= (double)data.size();

    // Print result
    std::cout << "  Mean=" << mean << std::endl;

    // Repeat,using two threads
    std::vector<std::thread> thread;
    std::vector<double> result;
    result.push_back(0.0);
    result.push_back(0.0);
    std::cout << "Calculating mean,2 Threads..." << std::endl;

    // Run threads
    uint32_t halfsize = data.size() / 2;
    uint32_t A = 0;
    uint32_t B,C,D;
    // Split the data into two blocks
    if(data.size() % 2 == 0)
    {
        B = C = D = halfsize;
    }
    else if(data.size() % 2 == 1)
    {
        B = C = halfsize;
        D = hsz + 1;
    }

    // Run with two threads
    thread.push_back(std::thread(findmean,&data,A,B,&(result[0])));
    thread.push_back(std::thread(findmean,D,&(result[1])));

    // Join threads
    thread[0].join();
    thread[1].join();

    // Calculate result
    mean = result[0] + result[1];
    mean /= (double)data.size();

    // Print result
    std::cout << "  Mean=" << mean << std::endl;

    // Return
    return EXIT_SUCCESS;
}


void findmean(std::vector<double>* datavec,std::size_t start,std::size_t length,double* result)
{
    for(uint32_t i = 0; i < length; i ++) {
        *result += (*datavec).at(start + i);
    }
}

我认为这段代码并不完美,如果你能提出改进方法,那么我也会感激不尽.

注册变量：

有几个人建议为函数’findmean’创建一个局部变量.这就是我所做的：

void findmean(std::vector<double>* datavec,double* result)
{
register double holding = *result;
for(uint32_t i = 0; i < length; i ++) {
    holding += (*datavec).at(start + i);
}
*result = holding;
}

我现在可以报告：代码运行的执行时间与单个线程几乎相同.这是6倍的大改进,但肯定必须有一种方法使它几乎快两倍？

注册变量和O2优化：

我已将优化设置为’O2′ – 我将创建一个包含结果的表.

结果到目前为止：

原始代码没有优化或寄存器变量：
1个线程：4.98秒,2个线程：29.59秒

添加了寄存器变量的代码：
1个线程：4.76秒,2个线程：4.76秒

使用reg变量和-O2优化：
1线程：0.43秒,2线程：0.6秒2线程现在更慢？

根据Dameon的建议,这是在两个结果变量之间放置一大块内存：
1个线程：0.42秒,2个线程：0.64秒

TAS建议使用迭代器来访问向量的内容：
1个线程：0.38秒,2个线程：0.56秒

与Core i7 920(单通道内存4GB)相同：
1个线程：0.31秒,2个线程：0.56秒

与Core i7 920(双通道内存2x2GB)相同：
1个线程：0.31秒,2个线程：0.35秒