processus et threads

1

Processus et threads

Chapter 2

2.1 Processus2.2 Threads2.3 Communication interprocessus2.4 Problèmes classiques de communication2.5 Ordonancement

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

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

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:

1. Sortie normale (volontaire)

2. Sortie avec erreur (volontaire)

3. Erreur fatale (involontaire)

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

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

• 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

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