Déterminer l'heure utilisateur et système utilisée par un thread

Question

Nous avons un moteur de flux de travail basé sur qthreads où les threads de travail récupèrent des paquets d'entrée lorsqu'ils sont placés dans une file d'attente, puis placent leur sortie dans une autre file pour exécuter d'autres threads. étape suivante; et ainsi de suite jusqu'à ce que toute l'entrée ait été consommée et que toute la sortie ait été générée.

Généralement, plusieurs threads exécutent la même tâche et d'autres exécutent d'autres tâches en même temps. Nous voulons comparer les performances de ces tâches threadées afin de cibler les efforts d'optimisation.

Il est facile d'obtenir le temps réel (écoulé) qu'un thread donné, exécutant une tâche donnée, a pris. Nous examinons simplement la différence entre les valeurs de retour de la fonction POSIX times() au début et à la fin de la procédure run(). Cependant, je n'arrive pas à comprendre comment obtenir l'heure et l'utilisateur correspondant. Obtenir ceux-ci de la struct tms que vous passez à times() ne fonctionne pas, car cette structure donne le temps total de l'utilisateur et du système de tous les threads en cours d'exécution lorsque le thread en question est actif.

Answer 1

En supposant que c'est sous Linux que diriez-vous de getrusage() avec RUSAGE_THREAD? Solaris propose également RUSAGE_LWP qui est similaire et je suppose qu'il y a probablement des équivalents pour d'autres systèmes semblables à POSIX.

exemple brut:

#define _GNU_SOURCE 
#include <sys/time.h> 
#include <sys/resource.h> 
#include <stdio.h> 
#include <pthread.h> 
#include <assert.h> 
#include <unistd.h> 

struct tinfo { 
    pthread_t thread;  
    int id; 
    struct rusage start; 
    struct rusage end; 
}; 

static void * 
thread_start(void *arg) 
{ 
    struct tinfo *inf = arg; 
    getrusage(RUSAGE_THREAD, &inf->start); 
    if (inf->id) { 
    sleep(10); 
    } 
    else { 
    const time_t start = time(NULL); 
    while (time(NULL) - start < 10); // Waste CPU time! 
    } 
    getrusage(RUSAGE_THREAD, &inf->end); 
    return 0; 
} 

int main() { 
    static const int nrthr = 2; 
    struct tinfo status[nrthr]; 
    for (int i = 0; i < nrthr; ++i) { 
    status[i].id = i; 
    const int s = pthread_create(&status[i].thread, 
              NULL, &thread_start, 
              &status[i]); 
    assert(!s); 
    } 

    for (int i = 0; i < nrthr; ++i) { 
    const int s = pthread_join(status[i].thread, NULL); 
    assert(!s); 
    // Sub-second timing is available too 
    printf("Thread %d done: %ld (s) user, %ld (s) system\n", status[i].id, 
       status[i].end.ru_utime.tv_sec - status[i].start.ru_utime.tv_sec, 
       status[i].end.ru_stime.tv_sec - status[i].start.ru_stime.tv_sec); 
    } 
} 

Je pense que quelque chose est possible sur Windows similaire en utilisant GetProcessTimes()