Transcript Processus et threads
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 CreateProcess( LPCTSTR
lpApplicationName
, LPTSTR
lpCommandLine
, LPSECURITY_ATTRIBUTES
lpProcessAttributes
, LPSECURITY_ATTRIBUTES
lpThreadAttributes
, BOOL
bInheritHandles
, DWORD
dwCreationFlags
, LPVOID
lpEnvironment
, LPCTSTR
lpCurrentDirectory
, LPSTARTUPINFO
lpStartupInfo
, LPPROCESS_INFORMATION
lpProcessInformation
); 4
Création de processus sur Windows(2)
typedef struct _PROCESS_INFORMATION { HANDLE hProcess; HANDLE hThread; DWORD dwProcessId; DWORD dwThreadId; } *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("%s\n", envp[i]); } 7
Valeur de retour
#include
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; struct procsig *p_procsig; int p_flag; char p_stat; pid_t p_pid; struct proc *p_pptr; LIST_ENTRY(proc) p_sibling; LIST_HEAD(, proc) p_children; struct callout_handle p_ithandle; /* List of all processes. */ /* Process owner's identity. */ /* Ptr to open files structure. */ /* Accounting/statistics (PROC ONLY). */ /* P_* flags. */ /* S* process status. */ /* Process identifier. */ /* Pointer to parent process. */ /* List of sibling processes. */ /* Pointer to list of children. */ /* * 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_int64_t p_runtime; u_int64_t p_uu; u_int64_t p_su; u_int64_t p_iu; u_int64_t p_uticks; u_int64_t p_sticks; u_int64_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; u_char p_usrpri; /* Process priority. */ /* User-priority based on p_cpu and p_nice. */ char p_nice; /* Process "nice" value. */ char p_comm[MAXCOMLEN+1]; struct pgrp *p_pgrp; struct mdproc p_md; u_short p_xstat; u_short p_acflag; struct rusage *p_ru; /* Pointer to process group. */ /* Any machine-dependent fields. */ /* 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.
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 4.
5.
6.
7.
8.
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
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 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); 25
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 ); 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