1 processus (= n threads) 2 threads. Commun Code Données Fichiers. Indépendant. Indépendant Registres. Pile

Dimension: px

Commencer à balayer dès la page:

Download "1 processus (= n threads) 2 threads. Commun Code Données Fichiers. Indépendant. Indépendant Registres. Pile"

Basile St-Germain
il y a 6 ans
Total affichages :

1 POSIX Différences entre processus et threads Tous deux permettent d effectuer des taches en parallèles, cependant il existe de nombreuses différences entre les deux. On peut le remarquer ne serait-ce qu en comparant le temps d exécution pris lors de la création de 5000 threads et celui pris pour 5000 processus. pierre@pierre-ubuntu32:~/documents/posix/td4$ multiple_fork.exe 5000 Time taken for creating 5000 processus (nanoseconds): Time taken for creating 5000 processus (milliseconds): 218 pierre@pierre-ubuntu32:~/documents/posix/td4$ multiple_threads.exe 5000 Time taken for creating 5000 threads (nanoseconds): Time taken for creating 5000 threads (milliseconds): 35 Cette importante différence de temps vient des éléments créés lors de l instanciation d un thread ou d un processus. En effet lorsqu on crée un nouveau processus le code, les données, les fichiers, les registre et la pile de ce nouveau processus (fils) sont alors dissociés de son créateur (père). Le nouveau processus commence «sa vie» à l endroit où il a été créé. Un thread lui partage le code, les données et les fichiers avec son créateur mais «possède» ses propres registres et sa propre pile d exécution. Un thread a «un travail» à effectuer on lui indique la fonction qu il devra exécuter à sa création. 1 processus (= n threads) 2 threads Commun Code Données Fichiers Indépendant Indépendant Registres Pile Registres Pile Processus Utilisation En C, sous linux, on se sert de la fonction «fork» pour créer un nouveau processus. Comme expliqué, le fils va alors être créé au moment de l appel de cette fonction et exécuter le code suivant comme le père. La fonction fork retourne un entier, si ce dernier est égale à 0 alors c est qu on se trouve dans le fils. Il possible (et recommandé) d attendre que tous les fils du processus père soient terminés avant que celui-ci soit terminé à l aide de la fonction «wait».

2 Exemple utilisé pour réaliser les métriques précédentes : #include <stdlib.h> #include <unistd.h> #include <sys/wait.h> #include "timer.h" #define NPROCESS 100 void wait_processus(int); // Définition du prototype de fonction pour l'utiliser long create_processus(int n) { struct timespec vartime = timer_start(); /* Démarrage de la mesure temporelle */ /* Création de n processus s'exécutant en parallèle */ for (int i = 0; i < n; ++i) { switch () { case -1: /* Erreur à l'appel de fork */ perror("fork"); abort(); case 0: /* Processus fils de numéro i */ ; /* Ne pas oublier pour ne pas forker indéfiniment */ default: /* Suite du processus père : On reboucle pour créer les fils suivants */ break; /* On mesure le temps écoulé pour la création des n processus */ long time = timer_end(vartime); /* On attend la fin des processus créés pour éviter un impact sur les prochaines mesures */ wait_processus(n); return time; /* Retourne le temps écoulé pour réaliser la création des n processus */ void wait_processus(int n) { /* Le père attend la fin de tous ses fils */ for (int i = 0; i < n; ++i) wait(null); int main(int argc, char *argv[]) { int n = NPROCESS; for (int i = 1; i < argc; i++) if (argv[i][0]!= '-') n = atoi(argv[i]); long time_processus = create_processus(n); printf("time taken for creating %d processus (nanoseconds): %ld\n", n, time_processus); printf("time taken for creating %d processus (milliseconds): %ld\n", n, time_processus / NANO_TO_MILLI); fflush(stdout); /* On flushe la sortie standard */ ; /* Fin du père */

3 Processus «zombie» Un processus est dit «zombie» lorsqu il se termine avant que le père atteigne l appel de la fonction «wait» : Cas standards wait() wait() Cas de processus zombie Processus «orphelin» Un processus est dit «orphelin» lorsque son père s est terminé avant lui (donc qu il n a pas fait appelle à la fonction «wait») : Durée où le processus est zombie Multiprocessing sous windows (Win32) Le principe de processus est sensiblement le même sous Windows, même si les librairies et la syntaxe change. Cependant il est important de prendre en compte que pour créer un processus en Win32 il nécessaire de disposer d un exécutable qui sera le point de départ de ce nouveau processus (différent de linux) : #include <windows.h> #include <tchar.h> #include <time.h> Durée où le processus est orphelin #define NPROCESS 100 long create_processus(int n, TCHAR *cmdline) { STARTUPINFO si; PROCESS_INFORMATION pi; time_t start, end; ZeroMemory(&si, sizeof(si)); si.cb = sizeof(si); ZeroMemory(&pi, sizeof(pi)); start = time(null); for (int i = 0; i < n;i++) { // Start the child process.

4 if (!CreateProcess(cmdLine, // No module name (use command line) // Command line // Process handle not inheritable // Thread handle not inheritable FALSE, // Set handle inheritance to FALSE 0, // No creation flags // Use parent's environment block // Use parent's starting directory &si, // Pointer to STARTUPINFO structure &pi) // Pointer to PROCESS_INFORMATION structure ) { printf("createprocess failed (%d).\n", GetLastError()); WaitForSingleObject(pi.hProcess, INFINITE); // Wait until child process exits. CloseHandle(pi.hProcess); // Close process handles. CloseHandle(pi.hThread); // Close thread handles. end = time(null); return difftime(end, start); int main(int argc, char *argv[]){ int n = NPROCESS; if (argc == 2) n = atoi(argv[1]); TCHAR* exe = _T("D:/Donnees/Informatique/Polytech/SI3S6/courses/Systeme_POSIX/TP4-5/Windows/SANS_IDE/emptyProcessus.exe"); long timetaken = create_processus(n, exe); printf("temps pour %d processus : %ld s\n", n, timetaken); Threads Que ce soit sous Linux ou Windows, les threads ont le même fonctionnement. Création du thread en lui attribuant une fonction à exécuter Attente de sa terminaison Fermeture du thread Linux #include <stdlib.h> #include <unistd.h> #include <pthread.h> #include <sys/syscall.h> #include <sys/types.h> void *threadexecutionfonction(void *arg){

5 int n = (int)arg; for(int i=0; i<20;i++){ sleep(n); printf("pid = %ld PTHREAD = %ld\n", (long)getpid(), pthread_self()); printf("linux Thread ID: %ld\n \n", syscall(sys_gettid)); pthread_exit(null); // Fermeture du thread int main(int argc, char *argv[]){ if(argc!=2) exit(1); int n1 = atoi(argv[1]); pthread_t thread1; if(pthread_create(&thread1, threadexecutionfonction, (void *)n1) == -1) { // Création du thread perror("pthread_create"); return EXIT_FAILURE; if (pthread_join(thread1, NULL)) { // Attente de la fin du thread perror("pthread_join"); return EXIT_FAILURE; return EXIT_SUCCESS; Win32 #include <Windows.h> #include <specstrings.h> DWORD WINAPI mythread(){ int a = 0; printf("thread id %d \n", GetCurrentThreadId()); int main() { HANDLE myhandle; DWORD mythreadid; for (int i = 0; i < 10; i++) { myhandle = CreateThread(0, 0, mythread, 0, 0, &mythreadid); // Création du thread printf("a: %d \n", mythread()); WaitForSingleObject(myhandle, INFINITE); // Attente de la fin du thread CloseHandle(myhandle); // Fermeture du thread

Documents pareils

Le prototype de la fonction main()

Le prototype de la fonction main() 1. Introduction...1 2. Paramètres et type de retour de la fonction main()...1 3. Exemple 1...2 4. La fonction exit() du C...2 5. Détecter le code de retour d un programme