Exécution concurrente

Bonjour,

Je débute avec la programmation concurrente et la bibliothèque pthread. Je programme en C sous Linux Ubuntu 6.06 (GCC version 4.0.3, kernel 2.6.15 sur un pentium IV 3.2 GHz monoprocesseur). Pour commencer avec cette bibliothèque, j'ai testé un bout de code trouvé sur le site web de Emmanuel Delahaye http://emmanuel-delahaye.developpez.com/pthreads.htm :

Code:

---

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 33 34 35 36 37 38 39 40 41 42 43 44

#include <stdio.h> #include <pthread.h>   static void * task_a(void *p_data) { int i;   for (i=0; i<10; i++){ printf("Hello world from A (%d)\n", i); } (void) p_data; return NULL; }   static void * task_b(void *p_data) { int i;   for (i=0; i<10; i++){ printf("Hello world from B (%d)\n", i); } (void) p_data; return NULL; }   int main(void) { pthread_t ta; pthread_t tb;   puts("Main init");   pthread_create(&ta, NULL, task_a, NULL); pthread_create(&tb, NULL, task_b, NULL);   #if 1 pthread_join(ta, NULL); pthread_join(tb, NULL); #endif   puts("Main end");   return 0; }

---

L'idée est ici simplement d'exécuter les tâches main(), task_a() et task_b() de manière concurrente et d'observer ce qui se passe. Voici le résultat que j'obtient:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

Main init Hello world from A (0) Hello world from A (1) Hello world from A (2) Hello world from A (3) Hello world from A (4) Hello world from A (5) Hello world from A (6) Hello world from A (7) Hello world from A (8) Hello world from A (9) Hello world from B (0) Hello world from B (1) Hello world from B (2) Hello world from B (3) Hello world from B (4) Hello world from B (5) Hello world from B (6) Hello world from B (7) Hello world from B (8) Hello world from B (9) Main end

---

Quelles que soit le nombre de répétitions de la boucle exécutée par les fonctions task_a() et task_b() (c'est à dire i=10, 100, 1000), j'obtient une exécution séquentielle des tâches. Avez-vous une idée de la raison pour laquelle je n'obtient pas une exécution concurrente des tâches dans l'exemple ci-dessus?

Meilleures salutations et merci d'avance pour votre aide

Thierry

cela depend de ton ordonnanceur ...
essaye avec un kernel preemptif :)

Citation:

---

Envoyé par emdel

[1] En fait, la concurrence est une notion relative. Sur un système mono-processeur, l'exécution des tâches se fait selon des critères de temps (time slicing) ou de suspensions.

---

Le problème est résolu!

Le code ci-dessous me montre que le passage d'une tâche à l'autre s'effectue, mais beaucoup plus lentement que je l'avais imaginé.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

#include <pthread.h> #include <stdio.h>     void * print_xs (void *unused) { while (1) fputc ('x', stderr); (void) unused; return NULL; }     int main (void) { pthread_t thread_id;   pthread_create (&thread_id, NULL, &print_xs, NULL);   while (1) fputc ('o', stderr); return 0; }

---

Mon kernel n'est-il pas preemptif par défaut? J'ai l'impression que l'ordonnanceur effectue la commutation entre les tâche, mais à un rythme assez lent (toutes les 5-10s), ce qui a pour conséquence de masquer l'exécution concurrente de mon premier exemple.

Y a-t'il un moyen de règler la durée moyenne d'un time slice? Qu'entends-tu par kernel preemptif? Un kernel temps-reel à la Ingo Molnar?

Salutations

Thierry

Salut,

Ton code ne laisse aucune chance au kernel d'executer une autre thread lorsque l'une des deux est en cours d'execution.
Ajoute un sleep () de quelques micro secondes à la fin de tes boucles et le comportement de ton soft chagera. Idem dans ton deuxième programme, ajoute un sleep dans tes while(1).

Merci beaucoup,

C'était donc juste que mon deuxième thread n'avait pas le temps de s'exécuter avec que le 1er ait terminé. J'ai ralenti l'exécution de mes boucles à l'aide de la fonction sleep() et le comportement attendu est observé. Merci pour votre aide.

Thierry

En effet, c'est une des bases de la prog multi-thread. Lorsque des thread bouclent indéfiniement, il faut toujours laisser à la machine la possibilité d'exécuter les autres threads/programmes en cours. Pour ce faire il faut à un moment ou un autre ne rien faire (avec sleep). En java, il y a "yield" qui est un pseudo sleep (dors si tu n'as rien d'autre à faire), mais je ne sais pas si il y a un equivalent en C.