Chapter 2 Processus et threads 2 1 Processus

Chapter 2 Processus et threads 2. 1 Processus 2. 2 Threads 2. 3 Communication interprocessus 2. 4 Problèmes classiques de communication 2. 5 Ordonancement 1

Processus Le concept • Multiprogrammation de quatre programmes • Conceptuellement: 4 processus séquentiels indépendants • À chaque instant, un seul processus est actif 2

Création de processus Événements causant la création d’un processus 1. Initialisation du système 2. Exécution d’un appel système demandé par un processus 3. Un usager demande de créer un processus 4. Initiation d’une tâche sur un système de traitement par lots. 3

Création de processus sur Windows (1) BOOL WINAPI Create. Process( LPCTSTR lp. Application. Name, LPTSTR lp. Command. Line, LPSECURITY_ATTRIBUTES lp. Process. Attributes, LPSECURITY_ATTRIBUTES lp. Thread. Attributes, BOOL b. Inherit. Handles, DWORD dw. Creation. Flags, LPVOID lp. Environment, LPCTSTR lp. Current. Directory, LPSTARTUPINFO lp. Startup. Info, LPPROCESS_INFORMATION lp. Process. Information ); 4

Création de processus sur Windows(2) typedef struct _PROCESS_INFORMATION { HANDLE h. Process; HANDLE h. Thread; DWORD dw. Process. Id; DWORD dw. Thread. Id; } *LPPROCESS_INFORMATION; 5

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

Création de processus sur UNIX (2) Qu'est-ce que envp? // Commande shell: env int main(int argc, char* argv[], char* envp[]) { for (int i=0; envp[i]!=0; i++) printf("%sn", envp[i]); } 7

Valeur de retour #include <sys/types. h> #include <sys/wait. h> pid_t wait(int *status) pid_t waitpid( pid_t pid, int *status, int options); 8

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

Hiérarchie de processus • Le parent crée un processus enfant, l’enfant peut créer ses propres processus. • Unix: Forme une hiérarchie – "process group" • Windows: le concept de hiérarchie n’existe pas – Tous les processus sont égaux 10

L’état d’un processus (1) • États possibles – – en cours d’exécution bloqué prêt etc. • Transitions entre les états 11

L’état d’un processus(2) • Conceptuellement, l’ordonnanceur est au niveau le plus bas du SE – Prend en charge les interruptions et l’ordonnancement • Les autres processus séquentiels sont au dessus 12

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

Exemple: Free BSD struct proc { LIST_ENTRY(proc) p_list; /* substructures: */ struct pcred *p_cred; struct filedesc *p_fd; struct pstats *p_stats; /* List of all processes. */ /* Process owner's identity. */ /* Ptr to open files structure. */ /* Accounting/statistics (PROC ONLY). */ struct procsig *p_procsig; int p_flag; char p_stat; pid_t p_pid; /* P_* flags. */ /* S* process status. */ /* Process identifier. */ struct proc *p_pptr; LIST_ENTRY(proc) p_sibling; LIST_HEAD(, proc) p_children; /* Pointer to parent process. */ /* List of sibling processes. */ /* Pointer to list of children. */ struct callout_handle p_ithandle; /* * Callout handle for scheduling * p_realtimer. */ … 14

… struct vmspace *p_vmspace; … /* Address space. */ /* scheduling */ u_int p_estcpu; int p_cpticks; fixpt_t p_pctcpu; void *p_wchan; const char *p_wmesg; u_int p_swtime; u_int p_slptime; /* Time averaged value of p_cpticks. */ /* Ticks of cpu time. */ /* %cpu for this process during p_swtime */ /* Sleep address. */ /* Reason for sleep. */ /* Time swapped in or out. */ /* Time since last blocked. */ struct itimerval p_realtimer; u_int 64_t p_runtime; u_int 64_t p_uu; u_int 64_t p_su; u_int 64_t p_iu; u_int 64_t p_uticks; u_int 64_t p_sticks; u_int 64_t p_iticks; /* Alarm timer. */ /* Real time in microsec. */ /* Previous user time in microsec. */ /* Previous system time in microsec. */ /* Previous interrupt time in usec. */ /* Statclock hits in user mode. */ /* Statclock hits in system mode. */ /* Statclock hits processing intr. */ int p_traceflag; struct vnode *p_tracep; /* Kernel trace points. */ /* Trace to vnode. */ sigset_t p_siglist; /* Signals arrived but not delivered. */ u_char p_oncpu; u_char p_lastcpu; char p_rqindex; /* Which cpu we are on */ /* Last cpu we were on */ /* Run queue index */ 15

… sigset_t p_sigmask; stack_t p_sigstk; /* Current signal mask. */ /* sp & on stack state variable */ u_char p_priority; /* Process priority. */ u_char p_usrpri; /* User-priority based on p_cpu and p_nice. */ char p_nice; /* Process "nice" value. */ char p_comm[MAXCOMLEN+1]; struct pgrp *p_pgrp; /* Pointer to process group. */ struct mdproc p_md; /* Any machine-dependent fields. */ u_short p_xstat; u_short p_acflag; struct rusage *p_ru; /* Exit status for wait; also stop signal. */ /* Accounting flags. */ /* Exit information. */ int p_nthreads; void *p_aioinfo; int p_wakeup; struct proc *p_peers; struct proc *p_leader; struct pasleep p_asleep; void *p_emuldata; /* number of threads (only in leader) */ /* ASYNC I/O info */ /* thread id */ /* Used by asleep()/await(). */ /* process-specific emulator state data */ }; 16

Implémentation des processus(2) Idée général du traitement d’une interruption par le SE: 1. 2. 3. 4. 5. 6. 7. 8. Le matériel empile les registres sur la pile courante Le matériel charge un nouveau PC à partir du vecteur d'interuption Une procédure en assembleur sauve les registres dans la table La procédure en assembleur définie une pile temporaire La procédure d'interruption en C s'exécute L'ordonnanceur décide du prochain processus La procédure C retourne au code assembleur La procédure en assembleur démarre le nouveau processus 17

Les threads (1) (a) Trois processus possédant un seul thread. (b) Un processus possédant trois threads. (c) Appels systèmes bloquant 18

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

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

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

Utilisation des threads(2) Un serveur web multithread 22

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); 23

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

Les threads sur Windows HANDLE WINAPI Create. Thread( __in_opt LPSECURITY_ATTRIBUTES lp. Thread. Attributes, __in SIZE_T dw. Stack. Size, __in LPTHREAD_START_ROUTINE lp. Start. Address, __in_opt LPVOID lp. Parameter, __in DWORD dw. Creation. Flags, __out_opt LPDWORD lp. Thread. Id ); VOID WINAPI Exit. Thread( __in DWORD dw. Exit. Code); 25

Les threads sur Windows DWORD WINAPI Wait. For. Single. Object( __in HANDLE h. Handle, __in DWORD dw. Milliseconds ); DWORD WINAPI Wait. For. Multiple. Objects( __in DWORD n. Count, __in const HANDLE *lp. Handles, __in BOOL b. Wait. All, __in DWORD dw. Milliseconds ); 26

Implémentation des threads dans l'espace usager Système d'exécution: logiciel procurant des services à un programme • Gestion de la mémoire • Débogueur • Threads usagers • Bibliothèques partagées • Etc. • Rapidité: Pas de passage en mode noyau • Contrôle: Ordonnancement adapté • Problème: Appels systèmes bloquant, fautes de page, etc. 27

Implémentation des threads dans le noyau Lorsqu'un thread est bloqué, les autres threads demeurent actifs. 28

Implémentation hybride Multiplexage des threads usagers dans les threads noyaux. 29

Solaris 2. 5 (1995) 30

Activations de l'ordonanceur • But – Imiter la fonctionnalité des threads noyau – avec les avantages des threads utilisateur • Le noyau assigne des processeurs virtuels au processus – laisse le système d'exécution du processus allouer les threads au processeurs – Le noyau comunique avec le système d'exécution (upcall) lequel détermine quel thread doit recevoir le message (ex. les ASLWP sur Solaris 2. 6 – 1997). • Problème: – upcall en contradiction avec la structure des systèmes en couches. 31

Du code monothread au code multithread Conflits pour l'utilisation des variables globales 32