Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License,

Transcription

1 Copyright 2010 tv Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.1 or any later version published by the Free Software Foundation; with no Invariant Sections, with no Front Cover Texts, and with no Back Cover. You can obtain a copy of the GNU General Public License : write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA USA 1

2 Programmation Système Sémaphores Win32 Sommaire API Win Rappels...3 Exclusion mutuelle...3 Mutex...3 Section Critique...3 Sémaphore...3 Mutex...4 Section Critique...7 Sémaphores

3 Programmation Système API Win32 API Win32 L'API Win32 de Micro$oft propose différents moyens pour coordonner l'exécution de plusieurs threads. Les fonctions décrites dans ce document fournissent un mécanisme utilisé pour que les threads synchronisent leur accès à des ressources. Les mécanismes fournis sont : les exclusions mutuelles les sections critiques les sémaphores Rappels Exclusion mutuelle Une ressource est en exclusion mutuelle si seul un processus peut utiliser la ressource à un instant donné. Mutex C'est un sémaphore binaire qui permet l'une exclusion mutuelle (mutex). Il est toujours initialisé avec la valeur 1. Section Critique C'est une partie de code telle que 2 processus ne peuvent s'y trouver au même instant. Sémaphore Un sémaphore permet de protéger une variable (ou un type de donnée abstrait) et constitue la méthode utilisée couramment pour restreindre l'accès à des ressources partagées dans un environnement de programmation concurrente. Le sémaphore a été inventé par Edsger Dijkstra. 3 Sémaphores Win32

4 tpsyswindows Semaphores correction.odt 19/01/2011 rev.59 Mutex Le mutex est de type HANDLE, comme tout objet ressource dans l'api Win32. Les fonctions utilisables sont : Création du mutex : CreateMutex() Opération V(), libération ou déverrouillage du mutex : ReleaseMutex() Opération P(), prise ou verrouillage du mutex : WaitForSingleOb ject() Processus créateur (mutex1.c) : ce processus crée le mutex et l'utilise #include <windows.h> #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <time.h> void P(HANDLE hmutex) WaitForSingleObject(hMutex, INFINITE); void V(HANDLE hmutex) ReleaseMutex(hMutex); void travail(int i) int simulationtravail = (int)((double)rand() * (i+100) / (RAND_MAX+1.0)); printf("la tache%d travaille pendant %.2f s...\n", i, (float) (simulationtravail/1000.0)); Sleep(simulationTravail); printf("la tache%d a fini son travail...\n", i); 4

5 Programmation Système Mutex int main(void) HANDLE hmutex; srand(time(null)); //pour la simulation hmutex = CreateMutex( NULL, // descripteur de sécurité par défaut FALSE, // mutex not owned TEXT("NameOfMutexObject")); // nom de l'objet if (hmutex == NULL) printf( "CreateMutex failed (%d).\n", GetLastError()); ExitProcess(1); P(hMutex); printf("le processus1 débloque le processus2...\n"); travail(1); printf("attente pour bloquer l'autre processus Appuyez sur une touche pour débloquer le processus 2\n"); getchar(); V(hMutex); CloseHandle(hMutex); printf("fin...\n"); return 0; Processus utilisateur (mutex2.c) : ce processus ouvre le mutex et l'utilise #include <windows.h> #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <time.h> void P(HANDLE hmutex) WaitForSingleObject(hMutex, INFINITE); void V(HANDLE hmutex) ReleaseMutex(hMutex); 5 Sémaphores Win32

6 tpsyswindows Semaphores correction.odt 19/01/2011 rev.59 void travail(int i) int simulationtravail = (int)((double)rand() * (i+1000) / (RAND_MAX+1.0)); printf("la tache%d travaille pendant %.2f s...\n", i, (float) (simulationtravail/1000.0)); Sleep(simulationTravail); printf("la tache%d a fini son travail...\n", i); int main(void) HANDLE hmutex; srand(time(null)); //pour la simulation hmutex = OpenMutex( MUTEX_ALL_ACCESS, // Accès complet FALSE, // handle not inheritable TEXT("NameOfMutexObject")); // nom de l'objet if (hmutex == NULL) printf( "CreateMutex failed (%d).\n", GetLastError() ); ExitProcess(1); printf("le processus2 attend le processus1...\n"); P(hMutex); travail(2); V(hMutex); CloseHandle(hMutex); printf("fin...\n"); return 0; 6

7 Programmation Système Mutex Ce qui donne l'exécution suivante : Section Critique L'objet section critique fournit une synchronisation similaire au mutex sauf que ces objets doivent être utilisées par les threads d'un même processus. Ce mécanisme est plus performant que les mutex et il est plus simple à utiliser. Remarques : Si vous ne rendez pas la main à la fin de la section critique, cela bloquera le système. De même, il faut que les sections critiques soient les plus courtes possibles. Le processus est responsable de l'allocation de la mémoire utilisée par la section critique. Typiquement, il suffit de déclarer une variable de type CRITICAL_SECTION, de l'initialiser grâce à la fonction InitializeCriticalSection() ou InitializeCriticalSectionAndSpinCount(). 7 Sémaphores Win32

8 tpsyswindows Semaphores correction.odt 19/01/2011 rev.59 Les fonctions utilisables sont : Le thread utilise la fonction EnterCriticalSection() ou TryEnterCriticalSection() avant d'entrer dans la section critique. Le thread utilise la fonction LeaveCriticalSection() pour rendre le processeur à la fin de la section critique. Chaque thread du processus peut utiliser la fonction DeleteCriticalSection() pour libérer les ressources système qui ont été allouées quand la section critique a été initialisé. Après son appel, aucune fonction de synchronisation ne peut plus être appelée. Exemple avec 2 threads : critical_section.c #include <windows.h> #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <time.h> CRITICAL_SECTION cs; // shared structure void travail(int i) int simulationtravail = (int)((double)rand() * (i+1000) / (RAND_MAX+1.0)); printf("la tache%d travaille pendant %.2f s...\n", i, (float) (simulationtravail/1000.0)); Sleep(simulationTravail); printf("la tache%d a fini son travail...\n", i); DWORD WINAPI ThreadProc1(LPVOID lpparam) int n; int *pdata; pdata = (int*)lpparam; n = *pdata; EnterCriticalSection(&cs); printf("la tache%d est entrée dans une section critique...\n", n); travail(n); printf("la tache%d va sortir d'une section critique...\n", n); LeaveCriticalSection(&cs); return 0; 8

9 Programmation Système Section Critique DWORD WINAPI ThreadProc2(LPVOID lpparam) int n; int *pdata; pdata = (int*)lpparam; n = *pdata; EnterCriticalSection(&cs); printf("la tache%d est entrée dans une section critique...\n", n); travail(n); printf("la tache%d va sortir d'une section critique...\n", n); LeaveCriticalSection(&cs); return 0; int main(void) DWORD dwthreadid1, dwthreadid2; HANDLE hthread1, hthread2; int n1 = 1, n2 = 2; InitializeCriticalSection(&cs); srand(time(null)); //pour la simulation // Création du thread (autre que le primaire) hthread1 = CreateThread(NULL, // default security attributes 0, // use default stack size ThreadProc1, // thread function &n1, // argument to thread function 0, // use default creation flags &dwthreadid1); // returns the thread identifier if (hthread1 == NULL) printf( "CreateThread failed (%d).\n", GetLastError()); ExitProcess(1); 9 Sémaphores Win32

10 tpsyswindows Semaphores correction.odt 19/01/2011 rev.59 // Création du thread (autre que le primaire) hthread2 = CreateThread(NULL, // default security attributes 0, // use default stack size ThreadProc2, // thread function &n2, // argument to thread function 0, // use default creation flags &dwthreadid2); // returns the thread identifier if (hthread2 == NULL) printf( "CreateThread failed (%d).\n", GetLastError()); ExitProcess(1); // Attente fin des threads WaitForSingleObject(hThread1, INFINITE); WaitForSingleObject(hThread2, INFINITE); CloseHandle(hThread1); CloseHandle(hThread2); DeleteCriticalSection(&cs); printf("fin...\n"); return 0; Ce qui donne l'exécution suivante : 10

11 Programmation Système Sémaphores Sémaphores Sous Windows, un sémaphore est un compteur qui peut prendre des valeurs entre 0 et une valeur maximale définie lors de la création du sémaphore. Le sémaphore est de type HANDLE. Les fonctions utilisables sont : La fonction CreateSemaphore() crée l'objet sémaphore. HANDLE CreateSemaphore( LPSECURITY_ATTRIBUTES lpsemaphoreattributes, // pointer to security attributes LONG linitialcount, // initial count LONG lmaximumcount, // maximum count LPCTSTR lpname // pointer to semaphore object name ); La fonction Op ensemaphore() ouvre un objet sémaphore déjà créé par un autre thread ou processus. Opération V() : la fonction ReleaseSemaphore() libère un jeton. Opération P() : la fonction WaitForSingleOb ject () permet de prendre un sémaphore. Exemple 1 x Producteur et 1 x Consommateur : producteur1.c #include <windows.h> #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <time.h> /* taille de la file */ #define L 5 /* la file */ int f[l]; int in = 0, out = 0; /* Les semaphores */ HANDLE nbrequetes; // init 0 HANDLE nbcasesvides; // init L 11 Sémaphores Win32

12 tpsyswindows Semaphores correction.odt 19/01/2011 rev.59 void P(HANDLE s) WaitForSingleObject(s, INFINITE); void V(HANDLE s) ReleaseSemaphore(s, 1, NULL); int construirerequete(int n) int simulationtravail = (int)((double)rand() * (n+1000) / (RAND_MAX+1.0)); int requete = 1 + (int)((double)rand() * (n+100) / (RAND_MAX+1.0)); //printf("la tache%d construit une requete en %.3f s...\n", n, (float)(simulationtravail/1000.0)); Sleep(simulationTravail); return requete; void deposerrequete(int n, int requete) printf("la tache%d producteur depose la requete %d dans la file a la position %d...\n", n, requete, in); f[in] = requete; in = (in + 1) % L; int retirerrequete(int n) int requete; printf("la tache%d consommateur retire une requete de la file a la position %d...\n", n, out); requete = f[out]; f[out] = 0; /* élement vide */ out = (out + 1) % L; return requete; void traiterrequete(int n, int requete) int simulationtravail = (int)((double)rand() * (n+1000) / (RAND_MAX+1.0)); //printf("la tache%d traite la requete en %.2f s...\n", n, (float) (simulationtravail/1000.0)); Sleep(simulationTravail*2); // on retarde un peu le consommateur! requete = 0; // inutilement inutile! 12

13 Programmation Système Sémaphores DWORD WINAPI producteur(lpvoid nt) int n = *(int *)nt; // numéro de tache int requete; int i; // on produit pendant un certain temps... for(i=0;i<(l*3);i++) requete = construirerequete(n); //printf("la tache%d producteur attend une place libre...\n", n); P(nbCasesVides); deposerrequete(n, requete); V(nbRequetes); //printf("la tache%d producteur signale qu'une requete est disponible dans la file...\n", n); return 0; DWORD WINAPI consommateur(lpvoid nt) int n = *(int *)nt; // numéro de tache int requete; int i; //on consomme pendant un certain temps... for(i=0;i<(l*2);i++) //printf("la tache%d consommateur attend une requete disponible dans la file...\n", n); P(nbRequetes); requete = retirerrequete(n); V(nbCasesVides); printf("la tache%d consommateur va traiter la requete %d et libere la position...\n", n, requete); traiterrequete(n, requete); return 0; 13 Sémaphores Win32

14 tpsyswindows Semaphores correction.odt 19/01/2011 rev.59 int main(void) /* les threads */ DWORD dwthreadid1, dwthreadid2; HANDLE hthread1, hthread2; int t1 = 1, t2 = 2; // numéros des taches /* init des semaphores */ nbrequetes= CreateSemaphore(NULL, 0, L, (LPCTSTR )"SemaphoreNbRequetes"); nbcasesvides = CreateSemaphore(NULL, L, L, (LPCTSTR )"SemaphoreNbCasesVides"); // si dans un autre processus alors ouverture d'un sémaphore déjà créé //nbrequetes= OpenSemaphore(SEMAPHORE_ALL_ACCESS, FALSE, (LPCTSTR )"SemaphoreNbRequetes"); //nbcasesvides = OpenSemaphore(SEMAPHORE_ALL_ACCESS, FALSE, (LPCTSTR )"SemaphoreNbCasesVides"); srand(time(null)); //pour la simulation /* demarre les threads */ hthread1 = CreateThread(NULL, // default security attributes 0, // use default stack size consommateur, // thread function &t1, // argument to thread function 0, // use default creation flags &dwthreadid1); // returns the thread identifier hthread2 = CreateThread(NULL, // default security attributes 0, // use default stack size producteur, // thread function &t2, // argument to thread function 0, // use default creation flags &dwthreadid2); // returns the thread identifier /* attends la fin des threads */ WaitForSingleObject(hThread1, INFINITE); WaitForSingleObject(hThread2, INFINITE); CloseHandle(hThread1); CloseHandle(hThread2); CloseHandle(nbRequetes); CloseHandle(nbCasesVides); printf("fin...\n"); return 0; 14

15 Programmation Système Sémaphores Ce qui donne l'exécution suivante : 15 Sémaphores Win32