Discussion :

[khealou]

Salut tout le monde
je suis entrain d'écrire un programme multithread en C++ en utilisant la bibliothèque "pthread", mais quand j'arrive à l’exécuter sur Ubuntu (installé sur une machine virtuelle), les threads et la fonction principale semblent de s’exécuter l'un après l'autre et non pas en parallèle! pourtant je possède un processeur multicore
Mon code est trop long, donc je vais décrire mon problème avec ce simple code:

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
#include <iostream>
#include <pthread.h>
using namespace std;
 
void* myfunction(void* arg); //function that the thread will execute
 
int main()
{
	pthread_t thread;
	pthread_create(&thread, NULL, myfunction, NULL); //thread created
	for (int i=0; i<10; i++) //show "1" 10 times
		cout << "1";
	pthread_join(thread, NULL); //wait for the thread to finish executing
	return 0;
}
 
void* myfunction(void* arg)
{
	for (int j=0; j<10; j++) //show "2" 10 times
		cout << "2";
	return NULL;
}

Voila! quand j’exécute ce code sur mon OS hôte (Windows 7 | VC++2010) j'obtiens comme résultat "12212121211212112112121212...", ce qui est normalement un résultat logique d'une exécution en parallèle.
Le même code lorsque je l'exécute sur le OS invité (Ubuntu virtuelle | Code::Blocks) j'obtiens toujours "11111111111111111122222222222222222..." !!

Le thread crée et la fonction main() dans le code ci-dessus vont normalement exécuter en parallèle! mais ce n'est pas le cas puisque les 2 s'affichent après que l'affichage des 1 se termine, pourtant la machine virtuelle est configurée sur 4 cores mais il semble que le programme utilisent seulement un core, pas plus.

Je suis nouveau avec les threads et j'aime bien si quelqu'un peut m'aider à résoudre ce problème.
Merci d'avance

[Emmanuel Deloget]

Tu en demandes trop peu à ton thread, et du coup, tu ne vois pas réellement ce qui se passe. Si tu augmentes le nombre d'itérations, tu verras que le thread est bel et bien exécuté en parallèle.

Accessoirement, pour bien comprendre comment le multithread fonctionne, il faut comprendre comment l'OS fonctionne.

A chaque nouveau process créé (et sous linux, un thread est un process allégé - ou plutôt, c'est l'inverse : un process est un thread allourdi par la gestion de la MMU. Enfin bref, au niveau du scheduler, c'est la même chose : un objet kthread) l'OS alloue un temps pendant lequel ce process s'exécutera - le quantum de temps, qui est relativement court (on va faire simple, on va dire 10 ms ; c'est beaucoup plus court en fait). Au bout de ces 10 ms, le scheduler regarde si un autre process doit s'exécuter - s'il en trouve un, il va effectuer le changement de contexte (pile, registres, ...) et va jumper là ou l'exécution s'était arrêté avant, et ce nouveau process va s'exécuter pendant 10 ms à son tour. Je ne prends pas en compte ici la gestion de la priorité (plus elle est élevée, et plus le process/thread va prendre la main souvent), la gestion des opérations bloquantes, les appels système, la gestion des interruptions, etc. Il y a pas mal de choses qui peuvent avoir une influence sur la façon dont les thread/process vont s'enchaîner.

Du coup, ne crois pas que tu auras systématiquement 12121212... comme sortie ; tu auras 11111111...22222.... quelques fois ; ou 11122211122... etc. Quasiment toutes les sorties possibles sont envisageables, en fonction de la façon dont le kernel va scheduler les différents thread et process.