Question

编辑：我已经弄明白了。第二种算法运行得非常有效，以至于即使用输入＆lt; 100,000

我试图测量我在函数中实现的某个算法执行的时间。我已经包含了<time.h>，并围绕time_t变量周围的函数。它适用于我的第一次实现，但不是我的第二次。

在使用之间，我是否需要关闭时钟流（无法想到更好的工作）？有点像你在Java程序中关闭Scanner流的方式。这是我的代码，以防我不能很好地解释它。

switch(choice) {
    case 1:
        printf("Beginning prefixAverages1\n");
        clock_t begin1 = clock();
        int *a1 = prefixAverages1(input);
        clock_t end1 = clock();
        double time_spent1 = (double)(end1 - begin1) * 1000.0 / CLOCKS_PER_SEC;
        free(a1);
        printf("Algorithm took %f milliseconds to execute \n", time_spent1);
        break;
    case 2:
        printf("Beginning prefixAverages2\n");
        clock_t begin2 = clock();
        int *a2 = prefixAverages2(input);
        clock_t end2 = clock();
        double time_spent2 = (double)(end2 - begin2) * 1000.0 / CLOCKS_PER_SEC;
        free(a2);
        printf("Algorithm took %f milliseconds to execute \n", time_spent2);
        break;
    default:
        printf("Invalid input!");
        break;
}

在第一种情况下正确显示时间，但在第二种情况下则没有。我尝试过做一些研究，但我无法找到适用于我情景的任何内容。

当运行案例1时，根据输入，我得到600-1000毫秒之间的运行时间（听起来是正确的）。当我运行案例2时，无论输入如何，我都会得到00.000

如果有帮助，以下是我的功能：

int* prefixAverages1(int input) {
    int x[input];
    int *a = malloc(input*sizeof(*a));
    srand(time(NULL));  

    for(int i = 0; i < input; i++) {
        int sum = 0;
        for(int j = 0; j < i; j++) {
            int r = rand() % 100;
            x[j] = r;
            sum = sum + x[j];
        }
        a[i] = sum / (i+1);
    }
    return a;
}

int* prefixAverages2(int input) {
    int sum = 0;
    int x[input];
    int *a = malloc(input*sizeof(*a));
    srand(time(NULL));  

    for(int i = 0; i < input; i++) {
        int r = rand() % 100;
        x[i] = r;
        sum = sum + x[i];
        a[i] = sum / (i+1);
    }
    return a;
}

Answer 1

虽然我不知道为什么第二个选项可能为0，但由于这两个函数具有相同的签名，因此可以使用函数指针消除冗余代码。

void do_benchmark( const char *name, int*(*functionPtr)(int), int input ) {
    printf("Beginning %s\n", name);
    clock_t begin = clock();
    int *ret = (*functionPtr)(input);
    clock_t end = clock();
    double time_spent = (double)(end - begin) * 1000.0 / CLOCKS_PER_SEC;
    free(ret);
    printf("Algorithm took %f milliseconds to execute \n", time_spent);
}

然后两个函数都使用相同的时序代码运行，消除了基准测试代码中的差异作为罪魁祸首。

switch(choice) {
    case 1:
        do_benchmark("prefixAverages1", &prefixAverages1, input);
        break;
    case 2:
        do_benchmark("prefixAverages2", &prefixAverages2, input);
        break;
    default:
        printf("Invalid input!");
        break;
}

请注意，clock可能会失败。

如果使用的处理器时间不可用或无法表示其值，则函数返回值（clock_t）（ - 1）。

您想要检查该失败。

if( begin == (clock_t)-1 ) {
    fprintf(stderr, "Begin time not available.\n");
}
else if( end == (clock_t)-1 ) {
    fprintf(stderr, "End time not available.\n");
}
else {
    double time_spent = (double)(end - begin) * 1000.0 / CLOCKS_PER_SEC;
    printf("Algorithm took %f milliseconds to execute \n", time_spent);
}

Answer 2

我更熟悉使用QueryPerformanceCounter在Windows上执行此操作，因此我可能会在这里做各种不好的事情，但是测量短循环的基本思路是：

int main()
{
  printf("Beginning prefixAverages2\n");
  timespec begin, end;
  clock_gettime(CLOCK_REALTIME, &begin);
  int *a1 = prefixAverages2(50000);
  clock_gettime(CLOCK_REALTIME, &end);
  double time_spent = (end.tv_nsec - begin.tv_nsec) / 1000;
  time_spent += (end.tv_sec - begin.tv_sec) *1000000;

  free(a1);
  printf ("Time spent %f microseconds", time_spent);
}

输出：

Beginning prefixAverages2
Time spent 427.000000 microseconds

PS - 事实证明clock()没有挂机时间：Calculate execution time when sleep() is used

测量时间执行功能

2 个答案: