Processus - Polytechnique Montréal

Transcription

Processus
•
Qu’est ce qu’un processus ?
•
États d’un processus
•
Hiérarchie des processus
•
Gestion des processus sous UNIX/LINUX
–
–
–
–
–
•
Création de processus
Remplacement d’espace d’adressage
Attente de la fin d’un processus fils
Terminaison de processus
Partage de fichiers entre processus
Gestion des processus sous Windows
– Création de processus
– Attente de la fin d’un processus fils
– Terminaison de processus
Systèmes d’exploitation
Génie Informatique
École Polytechnique de Montréal
Chapitre 2. 1
Qu’est ce qu’un processus ?
•
Le concept processus est le plus important dans un système d’exploitation (SE). Tout le
logiciel d’un ordinateur est organisé en un certain nombre de processus (processus
système, processus utilisateur).
Hypothèse : Nous supposons, dans ce qui suit, que chaque
processus a un seul flot d’exécution (un seul thread). Le cas de
plusieurs flots d’exécution sera traité lors de la séance suivante.
•
Un processus est un programme en cours d’exécution. Il est caractérisé par :
–
–
–
–
–
–
–
–
Un numéro d’identification unique (PID);
Un espace d’adressage (code, données, piles d’exécution);
Un état principal (prêt, en cours d’exécution (élu), bloqué, …);
Les valeurs des registres lors de la dernière suspension (CO, PSW, Sommet de Pile…);
Une priorité;
Les ressources allouées (fichiers ouverts, mémoires, périphériques …);
Les signaux à capturer, à masquer, à ignorer, en attente ainsi que les actions associées;
Autres informations indiquant, notamment, son processus père, ses processus fils, son groupe,
ses variables d’environnement, les statistiques et les limites d’utilisation des ressources….
•
Le système d’exploitation maintient dans une table appelée «table des processus» les
informations sur tous les processus créés (une entrée par processus : Bloc de Contrôle de
Processus PCB).
•
Cette table permet au SE de localiser et gérer tous les processus.
Génie Informatique
Chapitre 2. 2
1
Qu’est ce qu’un processus ? (2)
Table des processus
PCB =
informations concernant l’état, la
mémoire et les ressources du
processus
Génie Informatique
Chapitre 2. 3
Table des processus
•
Dans la plupart des systèmes d’exploitation, le PCB est composé de deux
zones :
– La première contient les informations critiques dont le système a
toujours besoin (jamais swappée);
– La deuxième contient les informations utilisées uniquement lorsque le
processus est à l’état élu.
Génie Informatique
Chapitre 2. 4
2
Exemple d’utilisation de la table des processus :
Changement de contexte
Programme A
Mode utilisateur
Mode kernel
Programme B
Mode utilisateur
exécution
Sauvegarder état dans PCB A
interruption
Charger état de PCB B
exécution
Sauvegarder état en PCB B
interruption
Charger état de PCB A
exécution
Génie Informatique
Chapitre 2. 5
États d’un processus
Expiration
Attente d’admission
File des prêts
Fin d’exécution
Process eur
Processeur
File des bloqués
Fin
Terminaison
Mise en attente d’1 evt
Attente d’événement
Nouveau
Exécution
Suspension
par le SE
Élection
par le SE
Admission
Arrivée de l’evt
Génie Informatique
Chapitre 2. 6
3
États d’un processus (2)
Cas d’Unix
fork
Création
Préemption
Retour
à usager
Exécution
Mode
user
Mémoire
insuffisante
Mémoire
suffisante
suspension
Retour
Interruption ou
Appel système
Hors mémoire
Élection
Exécution
Mode
noyau
Prêt en
mémoire
Prêt hors
mémoire
En mémoire
Mise en attente
d’un evt
Arrivée de l’evt
Arrivée de l’evt
terminaison
Zombie
attente
en mémoire
Hors mémoire
Génie Informatique
Attente
hors
mémoire
Chapitre 2. 7
États d’un processus (3)
Cas de Windows XP
Génie Informatique
Chapitre 2. 8
4
Hiérarchie des processus
•
Le système d’exploitation fournit un ensemble d’appels système qui permettent la
création, la destruction, la communication et la synchronisation des processus.
•
Les processus sont créés et détruits dynamiquement.
•
Un processus peut créer un ou plusieurs processus qui, à leur tour, peuvent en créer
d’autres.
•
Dans certains systèmes (MS-DOS), lorsqu’un processus crée un processus, l’exécution
du processus créateur est suspendue jusqu’à la terminaison du processus créé
(exécution séquentielle).
•
Dans Windows, les processus créateurs et créés s’exécutent en concurrence et sont de
même niveau (exécution asynchrone mais pas de relation hiérarchique explicite gérée
par le SE).
Génie Informatique
Chapitre 2. 9
Hiérarchie des processus (2)
Cas d’UNIX
•
Le programme amorce charge une partie du système d’exploitation à partir du disque
(disquette ou CD) pour lui donner le contrôle. Cette partie détermine les caractéristiques
du matériel, effectue un certain nombre d’initialisations et crée le processus 0.
•
Le processus 0 réalise d’autres initialisations (ex. le système de fichier) puis crée deux
processus : init de PID 1 et démon des pages de PID 2.
•
Ensuite, d’autres processus sont crées à partir du processus init.
•
Dans le cas de linux, on a, parmi d’autres, les processus kswapd, xfs et khubd.
Génie Informatique
Chapitre 2. 10
5
Hiérarchie des processus (3)
Cas de Windows XP
•
Chaque processus pointe vers le processus parent (processus créateur).
•
Si le parent se termine, il n’y a pas d’actualisation de cette information.
•
Il se peut donc qu’un processus pointe vers un parent inexistant. Cela ne cause
aucun problème puisque rien ne dépend de cette information de parenté.
•
Windows ne gère de lien qu’avec l’ID du processus parent, pas avec le parent du
parent, etc.
Génie Informatique
Chapitre 2. 11
Processus d’UNIX
•
Chaque processus a un numéro d’identification unique (PID). L’appel system getpid() permet
de récupérer le PID du processus : int getpid();
•
Chaque processus a un père, à l’exception du premier processus créé (structure
arborescente). S’il perd son père (se termine), il est tout de suite adopté par le processus init
de PID 1. L’appel système getppid() permet de récupérer le PID de son processus père.
•
Un processus père s’exécute en concurrence avec ses fils (exécution asynchrone).
•
Un processus fils peut partager certaines ressources (mémoire, fichiers) avec son processus
père ou avoir ses propres ressources. Le processus père peut contrôler l’usage des
ressources partagées.
•
Le processus père peut avoir une certaine autorité sur ses processus fils. Il peut les
suspendre, les détruire (appel système kill), attendre leur terminaison (appel système wait)
mais ne peut pas les renier.
•
La création de processus est réalisée par duplication de l’espace d’adressage et de certaines
tables du processus créateur (l’appel système fork). La duplication facilite la création et le
partage de ressources. Le fils hérite des résultats déjà calculés par le père.
•
Un processus peut remplacer son code exécutable par un autre (appel système exec).
Génie Informatique
Chapitre 2. 12
6
Processus d’UNIX (2) :
Processus shell (très simplifié)
Génie Informatique
Chapitre 2. 13
Cas d’UNIX : Lancement de la commande ls à partir du shell
Génie Informatique
Chapitre 2. 14
7
Création de processus (appel système fork)
•
La création de processus sous UNIX est réalisée au moyen de l’appel système : fork();
•
L’appel système fork :
– associe un numéro d’identification (le PID du processus);
– ajoute puis initialise une entrée dans la table des processus (PCB). Certaines
entités comme les descripteurs de fichiers ouverts, le répertoire de travail courant,
la valeur d’umask, les limites des ressources sont copiées du processus parent;
– duplique l’espace d’adressage du processus effectuant l’appel à fork
(pile+données);
– duplique la table des descripteurs….
•
La valeur de retour est :
– 0 pour le processus créé (fils).
– le PID du processus fils pour le processus créateur (père).
– négative si la création de processus a échoué (manque d’espace mémoire ou le
nombre maximal de créations autorisées est atteint).
•
Au retour de la fonction fork, l’exécution des processus père et fils se poursuit, en
temps partagé, à partir de l’instruction qui suit fork.
•
Le père et le fils ont chacun leur propre image mémoire mais ils partagent certaines
ressources telles que les fichiers ouverts par le père avant le fork.
Génie Informatique
Chapitre 2. 15
Création de processus
(appel système fork)
Après le fork,
• le père et le fils vont
poursuivre leurs exécutions
à partir de l’instruction qui
suit l’appel au fork mais
chacun a sa propre zone de
données.
(12339)
• le père récupèrera dans sa
variable p, le PID du fils
créé;
• le fils récupérera dans sa
variable p la valeur 0.
(12339)
(12340)
Génie Informatique
Chapitre 2. 16
8
Processus d’UNIX (6)
Création de processus : Exemple 1
// programme tfork.c : appel système fork()
#include <sys/types.h>
// pour le type pid_t
#include <unistd.h>
// pour fork
#include <stdio.h>
// pour perror, printf
int a=20;
int main ( )
{
pid_t x ;
// création d’un fils
switch (x = fork())
{
case –1 : /* le fork a échoué */
perror("le fork a échoué !") ;
break ;
case 0 : /* seul le processus fils exécute ce « case »*/
printf("ici processus fils, le PID %d.\n ", getpid()) ;
a+=10; break ;
default : /* seul le processus père exécute cette instruction*/
printf(" ici processus père, le PID %d. \n", getpid()) ;
a+=100;
}
// les deux processus exécutent ce qui suit
printf("Fin du Process %d. avec a = %d\n", getpid(),a ) ;
return 0 ;
}
Génie Informatique
Chapitre 2. 17
Création de processus : Exemple 1 (exécution)
jupiter% gcc -o tfork tfork.c
jupiter% tfork
ici processus père, le PID 12339.
ici processus fils, le PID 12340.
Fin du Process 12340 avec a = 30.
jupiter% tfork
ici processus père, le PID 15301.
ici processus fils, le PID 15302.
jupiter%
a du fils
a du père
a du père
a du fils
Génie Informatique
Chapitre 2. 18
9
// programme Arborescence.c : appel système fork()
#include <sys/types.h> // pour le type pid_t
#include <unistd.h>
// pour fork
#include <stdio.h>
// pour printf
int main ( )
{
pid_t p;
int i, n=5 ;
for (i=1; i<n; i++)
{
p = fork();
if (p > 0 )
break ;
printf(" Processus %d de père %d. \n", getpid(), getppid()) ;
}
sleep(1); // dormir pendant 1 seconde
return 0 ;
}
Génie Informatique
shell
(exécution)
Processus
23706
i=1
fork()
sleep(1)
Processus
23707
printf(..)
i=2
fork()
sleep(1)
Processus
23708
printf(..)
i=3
fork()
sleep(1)
jupiter% gcc -o Arborescence Arborescence.c
jupiter% Arborescence
Processus 23707 de pere 23706
Chapitre 2. 19
Processus
23709
printf(..)
i=4
fork()
Processus
23710
sleep(1)
Génie Informatique
printf(..)
i=5
sleep(1)
Chapitre 2. 20
10
Création de processus : Exemple 2 sans l’instruction sleep
shell
Processus
23706
Processus
23707
i=1
fork()
terminaison
printf(..)
i=2
fork()
terminaison
Les fils qui deviennent
orphelins sont adoptés
par le processus init
de PID 1
jupiter% gcc -o Arborescence Arborescence.c
jupiter% Arborescence
jupiter% Processus 23707 de pere 1
.
Processus
23708
printf(..)
i=3
fork()
Processus
23709
terminaison
printf(..)
i=4
fork()
terminaison
Processus
23710
printf(..)
i=5
Génie Informatique
Chapitre 2. 21
Remplacement d’espace d’adressage
Appel système exec
•
Le système UNIX offre une famille d’appels système exec qui permettent à un
processus de remplacer son code exécutable par un autre spécifié par path ou
file.
int execl(const char *path, const char *argv, …….);
int execlp(const char *file, const char *argv, …….);
int execv(const char *path, char *const argv[]);
int execvp(const char *file, char *const argv[]);
•
Ces appels permettent d’exécuter de nouveaux programmes.
•
Le processus conserve, notamment, son PID, l’espace mémoire alloué, sa table
de descripteurs de fichiers et ses liens parentaux (processus fils et père).
•
En cas de succès de l’appel système exec, l’exécution de l’ancien code est
abandonnée au profit du nouveau.
•
En cas d’échec, le processus poursuit l’exécution de son code à partir de
l’instruction qui suit l’appel (il n’y a pas eu de remplacement de code).
Génie Informatique
Chapitre 2. 22
11
Remplacement d’espace d’adressage (2)
Appel système exec : Exemple 3
// programme test_exec.c
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
int main ()
{ char* arg[] = {“/bin/ps”, “f”, NULL};
printf(“Bonjour…..\n”);
execvp(“/bin/ps”, arg);
printf(“Echec de execvp\n”);
printf("Erreur %s\n",strerror(errno));
return 0;
}
Génie Informatique
Chapitre 2. 23
Attente de la fin d’un processus fils : appel système wait
•
Les appels système wait(…) et waitpid(…) permettent à un processus père d’attendre
ou de vérifier la terminaison d’un de ses fils :
– int wait (int * status);
– int waitpid( int pid, int * status, int options);
•
wait et waitpid retournent :
– le PID du fils qui vient de se terminer,
– -1 en cas d’erreur (le processus n’a pas de fils).
– des informations concernant la terminaison du fils, dans le paramètre status.
Ces informations peuvent être récupérées au moyen de macros telles que :
• WIFEXITED(status) : fin normale avec exit
• WIFSIGNALED(status) : tué par un signal
• WIFSTOPPED(status) : stopé temporairement
• WEXITSTATUS(status) : valeur de retour du processus fils ( exit(valeur))
•
wait(status) et waitpid(-1,status,0) bloquent le processus appelant jusqu’à ce que l’un
quelconque des fils du processus se termine.
•
waitpid(pid, status,0) avec pid>0, bloque le processus appelant jusqu’à ce que son
fils pid se termine.
•
waitpid(pid, status, WNOHANG) vérifie seulement la terminaison, retourne 0 en cas
de non terminaison (pas d’attente).
Génie Informatique
Chapitre 2. 24
12
Attente de la fin d’un processus fils : exemple 4
// programme parent.c
#include <unistd.h>
// pour fork et execl
#include <sys/wait.h> // pour wait
#include <stdio.h>
//pour printf
#define NULL 0
int main ()
{ int p, child, status;
p=fork() ;
if ( p ==- 1) return – 1 ;
if( p>0) // ce que fera le père
{
printf (" ici père[%d], mon fils[ %d] \n", getpid(), p);
if ((child=wait(&status))>0)
printf(" ici père[%d], Fin du fils[%d]\n",getpid(),child);
printf(" Le père[%d] se termine \n", getpid());
}
else // ce que le fils fera
{ if ((status=execl("/home/user/a.out", "a.out", NULL))==-1)
printf("le programme n'
existe pas : %d\n",status);
else
printf("cette instruction n’est jamais exécutée\n");
}
return 0;
}
Génie Informatique
// programme fils.c
#include <stdio.h>
#include <unistd.h>
int main ( )
{
printf(" ici programme fils [%d]\n",
getpid());
return 0;
}
Le père attend
la fin du fils
Le fils change de
code exécutable
jupiter% gcc fils.c
jupiter% gcc -o parent parent.c
jupiter% parent
ici père[10524], mon fils[10525]
ici programme fils [10525]
ici père[10524] Fin du fils[10525]
Le père[10524] se termine
jupiter%
Chapitre 2. 25
Attente de la fin d’un processus fils : exemple 5
// programme test de execvp : texecvp.c
#include <unistd.h>
#include <stdio.h>
#include <sys/wait.h>
int main (int argc , char * argv[])
{
if ( fork() == 0) // il s'
agit du fils
{ // exécute un autre programme
execvp( argv[1], &argv[1]) ;
fprintf(stderr, "on ne peut exécuter %s\n ", argv[1]);
}
else if( wait(NULL)>0 )
printf(" Le père détecte la fin du fils\n");
return 0 ;
}
Génie Informatique
jupiter% gcc –-o texecvp texecvp.c
jupiter% texecvp date
mercredi, 6 septembre 2000,
16:12:49 EDT
Le père détecte la fin du fils
jupiter% texecvp ugg+kjù
on ne peut exécuter ugg+kjù
jupiter% gcc -o fils fils.c
jupiter% fils
jupiter% texecvp fils
Chapitre 2. 26
13
•
Un processus se termine par une demande d’arrêt volontaire (appel système exit) ou
par un arrêt forcé provoqué par un autre processus (appel système kill) ou une erreur.
void exit(int vstatus);
•
Lorsqu’un processus fils se termine :
– son état de terminaison est enregistré dans son PCB,
– la plupart des autres ressources allouées au processus sont libérées.
– le processus passe à l’état zombie (<defunct>).
•
Son PCB et son PID sont conservés jusqu’à ce que son processus père ait
récupéré cet état de terminaison.
•
Les appels système wait(status) et waitpid.(pid, status, option) permettent au processus
père de récupérer, dans le paramètre status, cet état de terminaison.
•
Que se passe-t-il si le père meurt avant de récupérer ces informations?
•
Si un processus est tué par un signal kill, ce signal est aussi envoyé à tous ses
processus fils.
Génie Informatique
Chapitre 2. 27
fork
Création
Préemption
Retour
à usager
Exécution
Mode
user
Mémoire
insuffisante
Mémoire
suffisante
suspension
Retour
Interruption ou
Appel système
Hors mémoire
Élection
Exécution
Mode
noyau
Prêt en
mémoire
Prêt hors
mémoire
En mémoire
Mise en attente
d’un evt
Arrivée de l’evt
Arrivée de l’evtl
terminaison
Zombie
Détruit
attente
en mémoire
père exécute wait
Génie Informatique
Hors mémoire
Attente
hors
mémoire
Chapitre 2. 28
14
Terminaison de processus : exemple 6
// programme deuxfils.c
#include <stdio.h>
#include <unistd.h>
void fils(int i) ;
int main()
{
int status;
if(fork()) // création du premier fils
{
if ( fork()==0) // création du second fils
fils(2) ;
}
else fils(1) ;
if (wait(&status)>0) printf("fin du fils%d\n", status>>8) ;
if (wait(&status)>0) printf("fin du fils%d\n", status>>8) ;
return 0 ;
}
void fils(int i)
{ sleep(2) ;
exit(i) ;
}
jupiter% gcc -o deuxfils deuxfils.c
jupiter% deuxfils
fin du fils1
fin du fils2
jupiter% deuxfils
fin du fils2
fin du fils1
Génie Informatique
Chapitre 2. 29
Terminaison de processus : exemple 7
// programme exec_wait.c
#include <unistd.h>
Après le fork, le père remplace son
#include <stdio.h>
espace d’adressage par celui du
programme attendre_fils.c
int main ( )
{ pid_t p = fork();
if( p != 0)
{
execlp(“./attendre_fils”, “./attendre_fils”, NULL);
printf( “execlp a échoué\n”);
exit(-1);
}
else
{
sleep(5);
printf(“Je suis le fils \n”);
exit(0);
}
}
Génie Informatique
Les liens père /fils
sont maintenus
// programme attendre_fils.c
#include <unistd.h>
#include <stdio.h>
int main ( )
{ printf( “J’attends le fils…\n”);
wait(NULL);
printf(“Le fils a terminé \n”);
exit(0);
}
Chapitre 2. 30
15
Partage de fichiers entre processus père et fils
•
Le fork duplique la table des descripteurs de fichiers du processus
père.
Génie Informatique
Chapitre 2. 31
Exercice
Déterminez ce qui sera affiché à l'
exécution de ce programme :
// chaine_fork_wait.c
int main(void)
{
int i, n=5;
pid_t fils_pid;
for (i=1; i<n; i++)
{
fils_pid = fork();
if (fils_pid > 0)
{
wait(NULL);
break;
}
}
printf("Processus %d avec pere %d\n",getpid(), getppid());
}
Génie Informatique
Chapitre 2. 32
16
Processus Windows XP
•
Windows offre un certain nombre de fonctions pour permettre au programmeur et au
système d’exploitation de manipuler les processus.
•
Un processus Windows se compose des éléments suivants:
– Un identificateur unique appelé ID processus.
– Un espace d’adressage virtuel privé qui est un ensemble d’adresses mémoires
virtuelles utilisables par le processus.
– Un programme exécutable qui définit le code et les données initiaux et qui est
mappé dans l’espace d’adressage virtuel du processus.
– Une liste de handles (gestionnaires) ouverts qui pointent vers diverses ressources
systèmes telles que les sémaphores, les ports de communication, les fichiers ….,
qui sont accessibles à tous les threads du processus.
– Un contexte de sécurité appelé jeton d’accès qui identifie l’utilisateur, les groupes
de sécurité et les privilèges associés au processus.
– Au moins un thread d’exécution.
•
Les processus, threads, fichiers, sémaphores,… sont considérés comme des objets. À
chaque objet est associé un ou plusieurs handles
Génie Informatique
Chapitre 2. 33
Processus Windows XP (2)
•
Deux structures sont associés à chaque processus :
– typedef struct _PROCESS_INFORMATION { // pi
HANDLE hProcess, hThread;
DWORD dwProcessId, dwThreadId;
} PROCESS_INFORMATION;
– typedef struct _STARTUPINFO {
DWORD cb;
LPTSTR lpReserved, lpDesktop, lpTitle;
DWORD dwX, dwY;
DWORD dwXSize, dwYSize;
DWORD dwXCountChars, dwYCountChars;
DWORD dwFillAttribute;
DWORD dwFlags;
WORD wShowWindow;
WORD cbReserved2;
LPBYTE lpReserved2;
HANDLE hStdInput, hStdOutput, hStdError;
} STARTUPINFO, *LPSTARTUPINFO;
Génie Informatique
Chapitre 2. 34
17
Processus Windows XP (3)
Création d’un processus
•
Il y a une création d’un processus Windows lorsqu’une application appelle une
fonction de création de processus comme
–
–
–
–
•
CreateProcess,
CreateProcessAsUser,
CreateProcessWithTokenW ou
CreateProcessWithLogonW.
BOOL CreateProcess(
LPCTSTR lpApplicationName, // pointer to name of executable module
LPTSTR lpCommandLine, // pointer to command line string
LPSECURITY_ATTRIBUTES lpProcessAttributes, // process security attributes
LPSECURITY_ATTRIBUTES lpThreadAttributes, // thread security attributes BOOL
bInheritHandles, // handle inheritance flag
DWORD dwCreationFlags, // creation flags
LPVOID lpEnvironment, // pointer to new environment block
LPCTSTR lpCurrentDirectory, // pointer to current directory name LPSTARTUPINFO
lpStartupInfo, // pointer to STARTUPINFO LPPROCESS_INFORMATION
lpProcessInformation // pointer to PROCESS_INFORMATION );
Génie Informatique
Chapitre 2. 35
Processus Windows (4)
Création de processus sous Windows
#include <windows.h>
#include <stdio.h>
void ErrorExit (LPTSTR lpszMessage)
void ErrorExit (LPTSTR lpszMessage)
{
int main( )
fprintf(stderr, "%s\n", lpszMessage);
{
STARTUPINFO si;
ExitProcess(1);
PROCESS_INFORMATION pi;
ZeroMemory( &si, sizeof(si) );
} // fonction de gestion d’erreurs
ZeroMemory( &pi, sizeof(pi));
si.cb = sizeof(si);
// Start the child process.
if( !CreateProcess( “Fils.exe”, //name or path of executable
NULL,
// no command line.
NULL,
// Process handle not inheritable.
NULL,
// Thread handle not inheritable.
FALSE,
// Set handle inheritance to FALSE.
0,
// No creation flags.
NULL,
// Use parent's environment block.
NULL,
// Use parent's starting directory.
&si,
// Pointer to STARTUPINFO structure.
&pi )
// Pointer to PROCESS_INFORMATION structure.
)
{
ErrorExit( "CreateProcess failed." ); }
// Wait until child process exits.
WaitForSingleObject( pi.hProcess, INFINITE );
// Close process and thread handles.
CloseHandle( pi.hProcess );
CloseHandle( pi.hThread );
return 0;
} // Fichier Pere.cpp
void main ( )
{ printf("Child sleeps 5s \n");
sleep(5000);
printf("done \n");
}//fichier Fils.cpp
Génie Informatique
Chapitre 2. 36
18
#include <stdio.h>
void main( VOID )
{ STARTUPINFO si;
PROCESS_INFORMATION pi;
DWORD status ; // address to receive termination status
ZeroMemory( &si, sizeof(si) );
si.cb = sizeof(si);
ZeroMemory( &pi, sizeof(pi) );
if( !CreateProcess("child.exe",NULL,NULL,NULL,FALSE,0,NULL,NULL,&si,&pi))
{
printf( "CreateProcess failed (%d).\n", GetLastError() );
ExitProcess(1);
}
WaitForSingleObject( pi.hProcess, INFINITE );
if(GetExitCodeProcess( pi.hProcess, &status))
printf("I am the father. My child has terminated with (%d). \n", status);
else printf( "GetExitCodeProcess failed (%d).\n", GetLastError() );
CloseHandle( pi.hProcess );
CloseHandle( pi.hThread );
printf( “I am the father. Going to terminate.\n");
ExitProcess(0);
} // fichier Father.cpp
Génie Informatique
Chapitre 2. 37
#include <stdio.h>
#include <tchar.h>
void main()
{
printf("I am the child. My Pid and Tid: (%d, %d).\n",
GetCurrentProcessId(), GetCurrentThreadId());
printf( "I am the child. Going to sleep for 5 seconds. \n");
Sleep(5000);
ExitProcess(10);
// exit code for all threads
}// fichier child.cpp
I am the child. My Pid and Tid (1084, 1404).
I am the child. Going to sleep for 5 seconds.
I am the father. My child [1084:1404] has terminated with (10).
I am the father. Going to terminate.
Génie Informatique
Chapitre 2. 38
19

Processus - Polytechnique Montréal

Transcription

Documents pareils

TECHNICIEN(NE) EN GÉNIE CIVIL (Affectation temporaire

cours de français pour immigrants

Objectifs Régulation IUT Chimie S4

Gestion de processus - Université Grenoble Alpes

offre d`emploi - adjoint/e administratif

HERVÉ VINCENT D. 514.839.2159 Développement orienté

Exercices sur la communication locale sous Unix

ASSOCIÉ, ASSOCIÉE DE RECHERCHE

Syst`emes d`exploitation Programmation en C sous UNIX Les

CPST - ENS-Genie-elect-Oran