1 Processus et threads Chapter 2 2.1 Processus 2.2 Threads 2.3 Communication interprocessus 2.4 Problèmes classiques de communication 2.5 Ordonancement.

Présentation au sujet: "1 Processus et threads Chapter 2 2.1 Processus 2.2 Threads 2.3 Communication interprocessus 2.4 Problèmes classiques de communication 2.5 Ordonancement."— Transcription de la présentation:

1 1 Processus et threads Chapter 2 2.1 Processus 2.2 Threads 2.3 Communication interprocessus 2.4 Problèmes classiques de communication 2.5 Ordonancement

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

3 3 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.

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

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

6 6 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[] );

7 7 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("%s\n", envp[i]); }

8 8 Valeur de retour #include pid_t wait(int *status) pid_t waitpid( pid_t pid, int *status, int options);

9 9 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)

10 10 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

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

12 12 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

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

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

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

16 16 … sigset_t p_sigmask; /* Current signal mask. */ stack_t p_sigstk; /* 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; /* Exit status for wait; also stop signal. */ u_short p_acflag; /* Accounting flags. */ struct rusage *p_ru; /* Exit information. */ int p_nthreads; /* number of threads (only in leader) */ void *p_aioinfo; /* ASYNC I/O info */ int p_wakeup; /* thread id */ struct proc *p_peers; struct proc *p_leader; struct pasleep p_asleep; /* Used by asleep()/await(). */ void *p_emuldata; /* process-specific emulator state data */ };

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

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

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

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

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

22 22 Utilisation des threads(2) Un serveur web multithread

23 23 Les threads POSIX #include 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);

24 24 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

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

26 26 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, __in DWORD dwMilliseconds );

27 27 Implémentation des threads dans l'espace usager Rapidité: Pas de passage en mode noyau Contrôle: Ordonnancement adapté Problème: Appels systèmes bloquant, fautes de page, etc. 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.

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

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

30 30 Solaris 2.5 (1995)

31 31 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.

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

33 33 Solutions? 1.Interdire les variables globales 2.Les threads peuvent avoir leurs propres variables globales 1.Passées en paramètres 2.Fonctions spéciales de la bibliothèque: create_global(“VARG”) set_global(“VARG”, &var) var = read_global(“VARG”)