Discussion :

[Tinkh]

Bonjour à tous,

Après quelques recherches infructueuses sur le net, me voilà pour une petite question sur les thread en C. J'ai créé un petit programme de simulation qui lance deux threads (j'utilise pthread) qui communiquent entre eux. J'ai besoin d'une com inter thread que je gère avec des pthread_cond_wait et pthread_cond_signal ... Bref tout ceci tourne bien.
Seulement le soft que je simule a besoin de s'exécuter en un certain temps et j'aimerai donc savoir s'il est possible de mettre en début d'une fonction un timer qui va me comptabiliser UNIQUEMENT le temps d'exécution de ma fonction sur mon thread, et non le temps global d'un simple timer. Ou une méthode qui me récupère le 'temps thread' au lieu de l'heure du PC.
En espérant ne pas avoir été trop brouillon dans mon explication, je vous remercie par avance.

[Vincent Rogier]

un simple clock() peut faire l'affaire...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
#include "stdio.h"
#include "time.h"
 
/*..*/
 
my_thread_func()
{
    clock_t t = clock();
    /*..*/
    t = ((clock() - t) * CLOCKS_PER_SEC) * 1000;
    printf("Elapsed time : %d milliseconds\n", t);
}

[Tinkh]

Si je cale ma fonction entre deux clock, j'aurais le temps d'exécution globale du processeur, donc la somme du temps qu'il a potentiellement passé sur l'autre thread. C'est justement là où ça me pose problème.

L'idée est que la communication qui se fait entre les threads doit être fait dans un certain temps et que ce temps est dépassé quand je veux le calculer (en utilisant un gethrtime() par exemple).

Autre précision, je suis sous Solaris OS.

[Invité]

Bonjour,

Le programme prstat fournit ce niveau d'information avec l'option "-L".
En regardant son source pour open solaris, ça pourra peut-être aider:
http://richlowe.net/webrevs/il_713/u.../prstat.c.html

Bon courage.

[Tinkh]

Effectivement cela permet d'avoir des stats mais j'aurais besoin de ces calculs en temps réel et non à la fin de l'exécution.
Je pense que je suis pas très clair dans ce que je dis, voici un peu plus de détail :
Je récupère le code embarqué dans un appareil et je dois l'exécuter sur ma machine pour des besoins de simulation. Cela tourne sur deux processeurs sur l'appareil réel mais c'est simuler sur deux threads qui communiquent entre eux afin de s'échanger certaines variables. J'ai donc une séquence de Read et Write qui se fait chaque cycle du programme et que j'ai réussi à ordonner comme sur l'appareil réel avec la lib pthread. A ce niveau là, tout tourne bien.

Le souci que j'ai, c'est que chaque read est sensé se faire en un certain temps (200µs). Je récupère donc le temps au début du read puis à la fin. Seulement entre temps, le processeur n'a pas que dérouler mon read mais a pu donné la main à l'autre thread et le temps d'exécution que je récupère est variable (ça va de 30µs à 250µs ...). Ce que je suppose, c'est que les temps d'exécution élevé correspondent aux moments où le processeur a passé la main.
Je cherche donc une solution lme permettant de calculer le temps d'exécution uniquement de mon thread, ou un moyen de bloquer le processeur sur mon thread.

PS : A noter que je ne suis pas du tout expert du sujet donc il se peut que je passe à côté de certaines évidences ou qu'il y ait des coquilles dans mon raisonnement.

[Invité]

Effectivement cela permet d'avoir des stats mais j'aurais besoin de ces calculs en temps réel et non à la fin de l'exécution.

prstat donne justement des informations en temps réel sur les processus et leurs threads en cours d'exécution.

[Tinkh]

Tout d'abord, merci de ta réponse mais je crois que je ne suis pas très doué pour expliquer mon problème. En effet, prstat reste du consultatif (ou je suis passé à côté de quelque chose) et je ne pourrais pas rentrer les résultats à l'intèrieur de mon programme. Il me faut récupérer ces temps d'exécution, et pas seulement les consulter.
Autre précision :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
void ReadWithWait_##Type (_C_ReadWithWait_##Type *C){ \
    _int Length_ = 0; \
    SYSTEM_TIME_TYPE entry; \
    SYSTEM_TIME_TYPE curr; \
    RETURN_CODE_TYPE retCode; \
    Dur waitDur = 0; \
 \
    GET_TIME(&entry, &retCode); \
    C->_O0_Validity_ = INVALID; \
\
    if (C->_M_init == true) \
    { \
        CREATE_SAMPLING_PORT(...)\
        (C->_O1_Message_) = *(C->_I3_InitMessage_); \
        C->_PrevMsg = *(C->_I3_InitMessage_); \
        C->_M_init = false; \
    } \
    while((waitDur <= (C->_I2_TimeOut_)) && ((C->_O0_Validity_) == INVALID)) \
    { \
        READ_SAMPLING_MESSAGE( ... ); \
        GET_TIME(&curr, &retCode); \
        waitDur = (Dur)(curr - entry); \
    } \
    if (waitDur > (C->_I2_TimeOut_)) \
    { \
        (C->_O0_Validity_) = INVALID; \
        (C->_O2_ReturnCode_)= (ReturnCode)TIMED_OUT; \
	printf("TIME OUT 2 : %d > %d\n",waitDur,(C->_I2_TimeOut_));\
    } \
    (...)
    C->_PrevMsg = (C->_O1_Message_); \
}

J'ai quelques peu caché du code peu important pour le problème en question. Les fonctions Create et Read mettent à jour bien évidement le paramètre de validité. Ma fonction GET_TIME est celle qui, pour l'instant, utilise getthrtime() et je voudrais changer ce système par quelque chose qui me récupère le temps d'exécution du thread qui à lancer la macro.
Je suis entrazin de regarder si la fonction clock_gettime peut être utilisé sur mon Solaris OS avec le paramètre CLOCK_THREAD_CPUTIME_ID mais jen doute un peu, je reste donc en rade ...

[souviron34]

euh...

Il suffit d'avoir une variable globale et de faire des clocks dans les 2 threads..

Et de faire la différence...



Ou alors j'ai rien compris...