1 / 32

Processus et threads

Processus et threads. 2.1 Processus 2.2 Threads 2.3 Communication interprocessus 2.4 Problèmes classiques de communication 2.5 Ordonancement. Chapter 2. Processus Le concept. Multiprogrammation de quatre programmes Conceptuellement: 4 processus séquentiels indépendants

orli
Download Presentation

Processus et threads

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

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

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

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

  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. Création de processus sur Windows(2) typedef struct _PROCESS_INFORMATION {HANDLE hProcess;HANDLE hThread;DWORD dwProcessId;DWORD dwThreadId; } *LPPROCESS_INFORMATION;

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

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

  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. L’état d’un processus (1) • États possibles • en cours d’exécution • bloqué • prêt • etc. • Transitions entre les états

  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. Implémentation des processus (1) Différent champs d’une entrée de la table des processus

  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. … 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. … 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. Implémentation des processus(2) Idée général du traitement d’une interruption par le SE: • 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

  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. Les threads (2) • Items partagés par tous les threads d’un processus • Items à chaque thread

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

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

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

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

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

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

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

  30. Solaris 2.5 (1995)

  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. Du code monothread au code multithread Conflits pour l'utilisation des variables globales

More Related