Processus et threads

Rappels sur les systèmes d’exploitation Agit comme interface (Machine virtuelle) Gère les ressources Gestion des processus et des threads Gestion de la mémoire Gestion des fichiers Gestion des E/S

Les processus Un processus est une structure de donnée représentant un programme en cours d'exécution. Un processus contient toute l'information qu'il est nécessaire de conserver pour poursuivre l'exécution d'un programme interrompu. En particulier, chaque processus possède: Un espace d'adressage (programme, données, pile) Des registres (incluant PC, SP, PSW) D'autres informations (fichiers ouverts, priorité, etc.)

Table des processus La table des processus est un tableau de structures contenant une entrée pour chaque processus actifs dans le système. Périodiquement, le système d'exploitation décide d'interrompre un processus pour en exécuter un autre. Il doit alors: suspendre l'exécution d'un processus A sauver l'information de A dans la table des processus choisir un nouveau processus B recupérer l'information de B démarrer l'exécution de B

Implémentation des processus Différent champs d’une entrée de la table des processus

Les threads (1) Chaque processus possède un ou plusieurs threads (fils d’exécution) Deux threads d’un même processus partagent un même espace d’adressage mais des piles et des compteurs ordinaux distincts. Quelque fois appelés processus légers Utile même lorsqu’il n’y a qu’un seul processeur Dans le contexte d’appels systèmes bloquants

Les threads (2) Items partagés par tous les threads d’un processus Items à chaque thread

Ordonnanceur Partie du SE qui détermine si un processus doit poursuivre son exécution ou être temporairement arrêté pour être remplacé par un autre Doit choisir le prochain processus à être exécuté Priorités

Les priorités sous Windows 32 niveaux de priorité

Les priorités sur Solaris

Création de processus sur UNIX // Crée une copie exacte du processus appelant pid_t fork(void) // Remplace l’image du processus appelant int execv( const char *fichier, char * const argv [] );

Valeur de retour #include <sys/types.h> #include <sys/wait.h> Attendre qu’un enfant quelconque termine pid_t wait(int *status) Attendre qu’un enfant donné termine pid_t waitpid( pid_t pid, int *status, int options);

Création de processus sur Windows (1) BOOL WINAPI CreateProcess( LPCTSTR lpApplicationName, LPTSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes, LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCTSTR lpCurrentDirectory, LPSTARTUPINFO lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation );

Création de processus sur Windows(2) typedef struct _PROCESS_INFORMATION { HANDLE hProcess; HANDLE hThread; DWORD dwProcessId; DWORD dwThreadId; } *LPPROCESS_INFORMATION;

Fin d’exécution d’un processus Conditions de fin d’exécution: Sortie normale (volontaire) Sortie avec erreur (volontaire) Erreur fatale (involontaire) Tué par un autre processus (involontaire)

L’état d’un processus États possibles Transitions entre les états en cours d’exécution bloqué prêt etc. Transitions entre les états

L’état d’un processus Wikipedia

Les threads (1) (a) Trois processus possédant un seul thread. (b) Un processus possédant trois threads.

Les threads (2) Items partagés par tous les threads d’un processus Items à chaque thread

Chaque thread possède sa propre pile. Les threads (3) Chaque thread possède sa propre pile.

Utilisation des threads (1) Un logiciel de traitement de texte avec trois threads

Les threads POSIX #include <pthread.h> int pthread_create( pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void*), void *restrict arg); void pthread_exit(void *value_ptr); int pthread_join(pthread_t thread, void **value_ptr);

Les threads POSIX Certaines implémentations possèdent l’instruction: void pthread_yield(void); ou void sched_yield(void); Sur Solaris et Linux on compile avec l'option: -lpthread

Les threads sur Windows HANDLE WINAPI CreateThread( __in_opt LPSECURITY_ATTRIBUTES lpThreadAttributes, __in SIZE_T dwStackSize, __in LPTHREAD_START_ROUTINE lpStartAddress, __in_opt LPVOID lpParameter, __in DWORD dwCreationFlags, __out_opt LPDWORD lpThreadId ); VOID WINAPI ExitThread( __in DWORD dwExitCode);

Les threads sur Windows DWORD WINAPI WaitForSingleObject( __in HANDLE hHandle, __in DWORD dwMilliseconds ); DWORD WINAPI WaitForMultipleObjects( __in DWORD nCount, __in const HANDLE *lpHandles, __in BOOL bWaitAll,

Communication interprocessus Trois points importants: Comment partager les ressources? Concurrence pour l'utilisation des ressources Synchronisation

Conditions de concurrence Deux processus veulent accéder à la mémoire partagée en même temps. Par exemple: Les processus A et B veulent utiliser la file d’impression. A voit que la prochaine case disponible est 7 puis est remplacé par B B voit que la prochaine case disponible est 7, y place le nom de son fichier, puis est remplacé par A A place le nom de son fichier dans une case qu’il croit libre écrasant le nom donné par B

Sections Critiques (1) L’exclusion mutuelle est une méthode qui permet de s’assurer que si un processus utilise une variable ou un fichier partagé, les autres processus seront exclus de la même activité. Une section critique (ou région critique) est la partie du programme à partir de laquelle on accède à la mémoire partagée.

Sections Critiques (2) Quatre conditions pour obtenir l'exclusion mutuelle: Un seul processus à la fois dans la section critique Aucune supposition sur le nombre et la vitesse des CPUs Aucun processus hors de la section critique ne peut bloquer un autre processus. Aucun processus ne doit attendre indéfiniment pour entrer en section critique.

Exclusion mutuelle à l'aide des sections critiques.

Solutions à l’exclusion mutuelle Variable de verrou Un processus peut entrer seulement si VERROU=0 Il met alors VERROU=1 pour empêcher les autres processus d’entrer Cette solution ne fonctionne pas sans aide matérielle

L'instruction TSL (Test and Set Lock) TSL R, LOCK est une opération atomique équivalente à: R=LOCK LOCK=1 enter_region: TSL REGISTER,LOCK | copie lock dans le registre et le définit à 1 CMP REGISTER,#0 | lock était-il à 0 ? JNE enter_region | s'il n’était pas à 0, boucle RET | retourne à l’appelant ; entre en section critique leave_region: MOVE LOCK,#0 | stocke un 0 dans lock RET | retourne à l’appelant

L'instruction XCHG (Intel x86) XCHG R, LOCK échange le contenu de R et LOCK Cette instruction peut facilement remplacer TSL enter_region: MOVE REGISTER, #1 | Mettre 1 dans REGISTER XCHG REGISTER,LOCK | Échanger REGISTER et LOCK CMP REGISTER,#0 | lock était-il à 0 ? JNE enter_region | s'il n’était pas à 0, boucle RET | retourne à l’appelant ; entre en section critique leave_region: MOVE LOCK,#0 | stocke un 0 dans lock RET | retourne à l’appelant

Opérations Sleep et Wakeup (1) Alternative aux solutions par attente active vues jusqu’à présent. Ex. Problème du producteur-consommateur #define N 100 /* nombre de connecteurs dans le tampon */ int count = 0;  /* nombre d’éléments dans le tampon */ void producteur(void) { int item; while (TRUE) { item = produire_item( );  /* génère l’élément suivant */ if (count == N) sleep( );  /* si le tampon est plein, entre en sommeil */ ajouter_item(item);  /* place l’élément dans le tampon */ count = count + 1;  /* incrémente le décompte des éléments dans le tampon */ if (count == 1) wakeup(consommateur);  /* le tampon était vide ? */ }

Opérations Sleep et Wakeup (2) void consommateur(void) { int item; while (TRUE) { if (count == 0) sleep( );  /* si le tampon est vide, entre en sommeil */ item = enlever_item( );  /* prélève un élément dans le tampon */ count = count - 1;  /* décrémente le décompte des éléments dans le tampon */ if (count == N - 1) wakeup(producteur);  /* le tampon était plein ? */ utiliser_item(item);  /* utilise l’élément */ } Que se passe-t-il si le producteur fait un wakeup entre le moment ou le consommateur constate que le tampon est vide et celui où il appelle sleep?

Les sémaphores: opérations Up et Down (1) Solution de Dijkstra au problème des wakeup perdus. Un sémaphore est une variable partagée entre plusieurs processus et munie de deux nouvelles instruction atomiques: Down(S): if (S==0) sleep S=S-1 Up(S): S=S+1 if (S==1) wakeup() // si des processus sont endormis sur le // sémaphore S alors l’un d’eux sera réveillé

Les sémaphores Résolution au problème du producteur-consommateur. On utilise trois sémaphores: #define N 100 /* nombre d’emplacements dans le tampon */ typedef int semaphore;  /* les sémaphores sont un type de variable int spécial */ semaphore mutex = 1;  /* contrôle l’accès à la section critique */ semaphore empty = N;  /* compte les emplacements vides dans le tampon */ semaphore full = 0;  /* compte les emplacements pleins */ void producer(void){ int item; while (TRUE) { item = produce_item( ); /* génère quelque chose à placer dans le tampon */ down(&empty);  /* décrémente le décompte des emplacements vides */ down(&mutex);  /* entre en section critique */ insert_item(item);  /* place un nouvel élément dans le tampon */ up(&mutex);  /* quitte la section critique */ up(&full);  /* incrémente le décompte des emplacements pleins */ }

Les sémaphores void consumer(void){ int item; while (TRUE) { down(&full);  /* décrémente le décompte des emplacements pleins */ down(&mutex);  /* entre en section critique */ item = remove_item();  /* prélève un élément dans le tampon */ up(&mutex);  /* quitte la section critique */ up(&empty);  /* incrémente le décompte des emplacements vides */ consume_item(item);  /* fait quelque chose avec l’élément */ }

Sémaphores sur Windows HANDLE WINAPI CreateSemaphore( LPSECURITY_ATTRIBUTES lpsa, LONG lInitialCount, // Nombre de ressources initialement disponibles LONG lMaximumCount, // Nombre maximale de ressources LPCTSTR lpName ); DWORD WINAPI WaitForSingleObject( HANDLE hSemaphore, DWORD dwMilliSeconds // Peut être INFINITE BOOL WINAPI ReleaseSemaphore( LONG lReleaseCount, // Nombre de ressources à remettre LPLONG lpPreviousCount // Reçoit le nombre de ressource actuelle);

Sémaphores sur Solaris #include <semaphore.h> sem_t *sem_open( char* nom, // Le premier caractère du nom doit être '/' int oflag // O_CREAT ou O_CREAT | O_EXCL int mode // bits de permission int valeur // valeur initiale ); int sem_wait(sem_t *psem) int sem_post(sem_t *psem) int sem_init( // sémaphore sans nom sem_t * psem, int pshare, // Si non nul, peut être partagé avec d'autres processus int valeur // NULL = Attributs par défaut );

Sémaphores sur Solaris #include <semaphore.h> main() { sem_t my_semaphore; int rc; rc = sem_init(&my_semaphore, 0, 10); … }

Les mutex Les mutex sont des sémaphore qui ne peuvent prendre que la valeur 0 ou 1. Ils servent à réaliser l’exclusion mutuel.

Mutex sur Solaris #include <pthread.h> pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; int pthread_ mutex_lock(pthread_mutex_t* pm); int pthread_mutex_unlock(pthread_mutex_t* pm); int pthread_mutex_init( // mutex dynamique pthread_mutex_t * pm, const pthread_mutexattr_t *mattr // NULL = Attributs par défaut );

Mutex sur Windows HANDLE WINAPI CreateMutex ( LPSECURITY_ATTRIBUTES lpma, // Pour nos applications ce paramètre // peut être mis à NULL BOOL bInitialOwner, // True pour créer et posséder le mutex LPTSTR lpName // Nom pour partager le mutex avec d'autres processus // ( Peut être NULL) ); DWORD WINAPI WaitForSingleObject( HANDLE hMutext, DWORD dwMilliSeconds // Peut être INFINITE BOOL WINAPI ReleaseMutex( HANDLE hMutex );

Critical Section sur Windows void WINAPI InitializeCriticalSection( LPCRITICAL_SECTION lpCriticalSection ); void WINAPI EnterCriticalSection( BOOL WINAPI InitializeCriticalSectionAndSpinCount( LPCRITICAL_SECTION lpCriticalSection, DWORD dwSpinCount void WINAPI LeaveCriticalSection(

Critical Section sur Windows // Variable globale CRITICAL_SECTION CriticalSection; DWORD WINAPI ThreadProc( LPVOID lpParameter ){ ... EnterCriticalSection(&CriticalSection); ... // Accès à la ressource partagée. LeaveCriticalSection(&CriticalSection); } void main(){ InitializeCriticalSection(&CriticalSection) ... // Création des threads DeleteCriticalSection(&CriticalSection)

Les barrières Utilisation des barrières Les processus s'approchent de la barrière Tous les processus sauf un sont bloqués Le dernier processus arrive, libérant les autres

Les barrières sur Solaris int pthread_barrier_init(pthread_barrier_t * barrier, const pthread_barrierattr_t * attr, unsigned count); int pthread_barrier_wait(pthread_barrier_t *barrier); int pthread_barrier_destroy(pthread_barrier_t *barrier);

Les barrières sur Windows BOOL WINAPI InitializeSynchronizationBarrier( _Out_ LPSYNCHRONIZATION_BARRIER lpBarrier, _In_ LONG lTotalThreads, _In_ LONG lSpinCount ); BOOL WINAPI EnterSynchronizationBarrier( _Inout_ LPSYNCHRONIZATION_BARRIER lpBarrier, _In_ DWORD dwFlags BOOL WINAPI DeleteSynchronizationBarrier( _Inout_ LPSYNCHRONIZATION_BARRIER lpBarrier

Variables conditionelles Permet à un thread de se bloquer non pas à l’entrée d’une région critique mais en fonction d’une certaine condition définie par la valeur d’une variable. Ex. Plusieurs threads se partage une variable P qu’ils incrémentent à tour de rôle. Un des threads veut se bloquer tant que P n’aura pas pas atteint une certaine valeur.

Variables conditionelles sur Windows VOID WINAPI InitializeConditionVariable PCONDITION_VARIABLE cond ); BOOL WINAPI SleepConditionVariableCS( // De façon atomique, bloque et PCONDITION_VARIABLE cond, // relâche la section critique PCRITICAL_SECTION pcs, DWORD millisecond VOID WINAPI WakeConditionVariable( // Débloque un thread bloqué PCONDITION_VARIABLE cond // sur la variable de condition VOID WINAPI WakeAllConditionVariable( // Débloque tous les threads bloqués PCONDITION_VARIABLE cond // sur la variable de condition

Variables conditionelles sur Solaris pthread-cond_t cond = PTHREAD_COND_INITIALIZER; int pthread_cond_wait( pthread_cond_t *cond, pthread_mutex_t *mutex ); int pthread-cond_signal(pthread_cond_t *cond); int pthread_cond_broadcast(pthread_cond_t *cond); int pthread_cond_init( pthread_cond_t *cond, const pthread_condattr_t *attr );