Discussion :

[mosflex]

Bonjour voici mon code qui utilise un sémaphore :

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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
int main (int argc, char * argv[])
{	int sem,e,j,k,f;
		//semaphore
		sem=ouvrirsem(123);
		initsem(sem,1);
 
	if (fork()==0)
	{	
		e=0;
 
			while(e<5000){
			k=0;
			//section critique
				down(sem);
				printf("1");
				fflush( stdout );
				while(k<200000)
				k++;
 
				printf("1");
				fflush( stdout );
				up(sem);
			//section non critique
				e++;
			}
 
 
 
 
		printf("Le fils a terminé \n");
		exit(0); 
	}
		j=0;
		while(j<5000){
		k=0;
		//section critique
			down(sem);
			printf("2");
			fflush( stdout );
			while(k<200000)
			k++;
			printf("2");
			fflush( stdout );
			up(sem);
		//section non critique
			j++;
		}
 
	printf("Le père a terminé \n");
	wait(0);
	supsem(sem);
	exit(0); 
}

Dans ce code j'écris 2 process qui utilise une section critique. Le fils affiche '1' après y être entré et '1' avant d'en sortir même chose pour le père mais celui ci affiche '2'. Dans ma section critique j'effectue des opérations qui peuvent être remplacé par un sleep(). Lorsque jeffectue ce code j'ai un résulat de ce type :

Code :

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

112211112222222222111111112211221122...

mais si je modifie mon while(k<200000) par while(k<200000000) mon résultat est de type:

Code :

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

11221122112211221122112211221122112211..

Donc chacun son tour. Est ce que c'est dû a la durée de mes opérations que l’ordonnanceur décide de ne plus donner la main a un process qui s'est appropriés trop de temps le processeur ? où y'a t'il autre chose ?

Merci

[emardjean]

Pour répondre à ta question, il manque à mon avis beaucoup de chose...
D'abord, il y a une Grosses différences entre un while et un sleep.
--> le sleep arrête ton processus. (Il n'est plus actif)
--> le while, le processus tourne en permanence sur lui même( il reste actif)

Deuxièmement. Le type du système d'exploitation.
-> En temps réel, le processus prend la main jusqu'a la fin de traitement (sauf si tu remplaces tes while par un sleep)
--> Dans ton cas, tu sembles être en mode Round Robin.( Temps partage). Dans ce cas, ton microprocesseur partage le temps microprocesseur entre tes threads.

Troisièmement:
--> Si tu as un microprocesseur multicœur, l'OS peut repartir la charge de tes threads sur des coeurs différents, donc tes processus tourneront en même temps.

Quatrièmement:
--> Cas de plusieurs microprocesseurs monocœur, j'ai aucune idée de ce que cela peut donner..
Bon courage

[Neckara]

Ton ordinateur a de 1 à X processeurs.

Chaque processus actif va demander l'accès à un processeur et l'ordonnanceur va attribuer à chacun un "temps de passage", s'il n'a pas fini ce qu'il avait à faire, il devra à nouveau attendre son tour.

Donc chacun de tes threads vont attendre d'avoir accès à l'un des X processeurs.
Or, sur un ordinateur, il n'y a pas que tes processus, il y a beaucoup de processus en tâche de fond qui vont prendre un processeurs.

Donc au final, même avec X coeur, tu peux de retrouver avec un seul processus qui utilise un processeur pendant que tes autres processus attendent l'accès au processeur.