-3

我需要测量进入和结束代码互斥锁的时间，所以我写了这个： 

#include<stdio.h>
#include<string.h>
#include<pthread.h>
#include<stdlib.h>
#include<unistd.h>
#include<time.h>

pthread_t tid[4];
int counter;
pthread_mutex_t lock;

void* doSomeThing(void *arg)
{
    pthread_mutex_lock(&lock);

    time_t stime=time(NULL);

    unsigned long i = 0;
    counter += 1;
    printf("\n Job %d started\n", counter);

    for(i=0; i<(0xFFFF);i++){
//      printf("%d", i); //this is just wait
    }
    printf("\n Job %d finished\n", counter);

    time_t etime=time(NULL);
    printf("time : %ld\n", difftime(etime, stime));
    pthread_mutex_unlock(&lock);
    return NULL;
}

int main(void)
{
    int i = 0;
    int err;

    if (pthread_mutex_init(&lock, NULL) != 0)
    {
        printf("\n mutex init failed\n");
        return 1;
    }

    while(i < 4)
    {
        err = pthread_create(&(tid[i]), NULL, &doSomeThing, NULL);
        if (err != 0)
            printf("\ncan't create thread :[%s]", strerror(err));
        i++;
    }

    pthread_join(tid[0], NULL);
    pthread_join(tid[1], NULL);
    pthread_join(tid[2], NULL);
    pthread_join(tid[3], NULL);
    pthread_mutex_destroy(&lock);

    return 0;
}

但我得到的时间是0

4

2 回答 2

2

有不同的计时方式 - “墙上时间”，“CPU时间”是其中的两种。有不同的库可以帮助您执行计时任务。这里有几个：

对于 CPU TIME（如果您在多个 CPU 上有多个线程，这将“比挂钟快”）：

#include <time.h>
clock_t startTime, stopTime;
double msecElapsed;
startTime = clock();
// thing that needs timing
stopTime = clock();
msecElapsed = (stopTime - startTime) * 1000.0 / CLOCKS_PER_SEC;

请注意，这可能能够以微秒精度进行计时 - 取决于编译器和平台。

对于 ELAPSED（挂钟）时间：

#include <sys/timeb.h>

struct timeb start, stop;
ftime(&start);
// thing that needs timing
ftime(&stop);
msecElapsed = timeDifference(&start, &stop);

您还需要此功能：

double timeDifference(struct timeb *start, struct timeb *stop) {
  return stop->time - start->time + 0.001 * (stim->millitm - start->millitm);
}

如果您使用 OMP 来促进并行处理，它有一个方便的功能

#include <omp.h>
double startTime, stopTime;
startTime = omp_get_wtime();
// do things
stopTime = omp_get_wtime();

这通常会达到微秒精度（即使您没有使用任何其他 OMP 函数）。

最后 - 您可能想查看这个较早问题的答案和这个问题的答案以获取更多信息/建议。

于 2013-08-29T17:00:49.413 回答
1

您可能会得到零，因为执行所需的时间太小，因此时间戳的分辨率不够精细，正如@Floris 所建议的那样。

该time()函数实际上返回自 1970 年 1 月 1 日以来的秒数，而不是毫秒。在快速谷歌之后，似乎解决方案可能在 clock() 函数中，它提供了毫秒级别的时间（未经测试）：

#include <time.h>

int main()
{
    clock_t start, end;

    start = clock();
    // do stuff
    end = clock();

    std::cout << "Process took " << (1000 * double(end - start) / CLOCKS_PER_SEC) << "milliseconds." << '\n';
}
于 2013-08-29T15:54:52.190 回答