Question

我根据黎曼总和的想法编写了一个程序来找出积分值。它使用了几个线程，但与我后面写的顺序程序相比，它的性能（算法）是次要的。算法方面，除了线程之外，它们是相同的，所以问题是它的错误是什么？我假设pthread_join不是这种情况，因为如果一个线程比另一个线程更早完成，那个加入等待，它将来会简单地跳过它。那是对的吗？ free调用可能是错误的，并且在创建线程时没有错误检查，我意识到它，我在测试各种东西的过程中删除了它。对不起英语不好，提前谢谢。

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <sys/types.h>
#include <time.h>


int counter = 0;
float sum = 0;
pthread_mutex_t mutx;

float function_res(float);


struct range {
    float left_border;
    int steps;
    float step_range;
};

void *calcRespectiveRange(void *ranges) {
    struct range *rangs = ranges;
    float left_border = rangs->left_border;
    int steps = rangs->steps;
    float step_range = rangs->step_range;
    free(rangs);
    //printf("left: %f steps: %d step range: %f\n", left_border, steps, step_range);
    int i;
    float temp_sum = 0;
    for(i = 0; i < steps; i++) {
        temp_sum += step_range * function_res(left_border);
        left_border += step_range;
    }
    sum += temp_sum;
    pthread_exit(NULL);
}


int main() {
    clock_t begin, end;

    if(pthread_mutex_init(&mutx, NULL) != 0) {
        printf("mutex error\n");
    }
    printf("enter range, amount of steps and threads: \n");
    float left_border, right_border;

    int steps_count;
    int threads_amnt;
    scanf("%f %f %d %d", &left_border, &right_border, &steps_count, &threads_amnt);
    float step_range = (right_border - left_border) / steps_count;
    int i;
    pthread_t tid[threads_amnt];
    float chunk = (right_border - left_border) / threads_amnt;
    int steps_per_thread = steps_count / threads_amnt;
    begin = clock();
    for(i = 0; i < threads_amnt; i++) {
        struct range *ranges;
        ranges = malloc(sizeof(ranges));
        ranges->left_border = i * chunk + left_border;
        ranges->steps = steps_per_thread;
        ranges->step_range = step_range;
        pthread_create(&tid[i], NULL, calcRespectiveRange, (void*) ranges);
    }
    for(i = 0; i < threads_amnt; i++) {
        pthread_join(tid[i], NULL);
    }
    end = clock();
    pthread_mutex_destroy(&mutx);
    printf("\n%f\n", sum);

    double time_spent = (double) (end - begin) / CLOCKS_PER_SEC;
    printf("Time spent: %lf\n", time_spent);
    return(0);
}

float function_res(float lb) {
    return(lb * lb + 4 * lb + 3);
}

编辑：简而言之 - 是否可以改进以减少执行时间（例如，使用互斥锁）？

Answer 1

只要您有多个可用的硬件线程，执行时间就会缩短。

问题在于您如何衡量时间：clock会返回程序使用的处理器时间。这意味着，它总结了所有线程所花费的时间。如果你的程序使用2个线程，并且它的线性执行时间是1秒，那意味着每个线程使用1秒的CPU时间，clock将返回相当于2秒的时间。

要获取实际使用的时间（在Linux上），请使用gettimeofday。我通过添加

来修改您的代码

#include <sys/time.h>

并捕获循环前的开始时间：

struct timeval tv_start;
gettimeofday( &tv_start, NULL );

之后：

struct timeval tv_end;
gettimeofday( &tv_end, NULL );

并计算以秒为单位的差异：

printf("CPU Time:    %lf\nTime passed: %lf\n",
    time_spent,
    ((tv_end.tv_sec * 1000*1000.0 + tv_end.tv_usec) -
    (tv_start.tv_sec * 1000*1000.0 + tv_start.tv_usec)) / 1000/1000
);

（我还修复了来自malloc(sizeof(ranges))的malloc，它将指针的大小（32/64位CPU为4或8个字节）分配给malloc(sizeof(struct range))（12个字节）。 / em>的

使用输入参数0 1000000000 1000000000 1运行时，即1个线程中的10亿次迭代，我机器上的输出是：

CPU Time: 4.352000 Time passed: 4.400006

当使用0 1000000000 1000000000 2运行时，即10亿次迭代分布在2个线程上（每次5亿次迭代），输出为：

CPU Time: 4.976000 Time passed: 2.500003

为了完整起见，我使用输入0 1000000000 1000000000 4测试了它：

CPU Time: 8.236000 Time passed: 2.180114

它快一点，但不是两个线程的两倍，并且它使用了两倍的CPU时间。这是因为我的CPU是Core i3，一个具有超线程的双核，它们不是真正的硬件线程。

C线程程序

1 个答案: