Origin 2000Origin 2000

Etude et optimisation des Etude et optimisation des entrées/sorties parallèlesentrées/sorties parallèles

S. Descamps, S. Nussbaum, O. RochelS. Descamps, S. Nussbaum, O. Rochel

S. VialleS. Vialle

Avec le support technique d ’A. FilboisAvec le support technique d ’A. Filbois

CCH

Etude et optimisation Etude et optimisation des entrées/sorties des entrées/sorties parallèlesparallèles

1. Environnement de travail1. Environnement de travail

2. Description de l ’étude réalisée2. Description de l ’étude réalisée

3. Mode Direct3. Mode Direct

4. Mode Indirect4. Mode Indirect

5. Problèmes rencontrés5. Problèmes rencontrés

6. Conclusion6. Conclusion

1. Environnement de 1. Environnement de travailtravail

1.1 L ’Origin20001.1 L ’Origin2000 1.2 La baie disque1.2 La baie disque

• ConstitutionConstitution• PartitionsPartitions• StrippingStripping• Piège de partitionnementPiège de partitionnement

1.3 Modes d ’utilisation de l ’Origin20001.3 Modes d ’utilisation de l ’Origin2000 1.4 Ressources humaines de l ’étude1.4 Ressources humaines de l ’étude

1.1 L ’Origin2000 :1.1 L ’Origin2000 : Structure interneStructure interne

From SGI Documentation

1.1 L ’Origin2000 :1.1 L ’Origin2000 : Liaison vers la Liaison vers la baie disquebaie disque

From SGI Documentation

1.2 La baie disque1.2 La baie disque

110 disques standards :110 disques standards :• 9.1 Go x 110 = 1 Tera9.1 Go x 110 = 1 Tera• Bande passante individuelle de 7 à 9 Mo/sBande passante individuelle de 7 à 9 Mo/s• Cache disque individuel de 1 MoCache disque individuel de 1 Mo

11 contrôleurs de disques (Fibre 11 contrôleurs de disques (Fibre Channel)Channel)• Bande passante de 80 Mo/s par contrôleur Bande passante de 80 Mo/s par contrôleur

1.2 La baie disque :1.2 La baie disque : Les 110 disquesLes 110 disques

1.2 La baie disque : 1.2 La baie disque : 10 disques par 10 disques par contrôleurcontrôleur

1.2 La baie disque : 1.2 La baie disque : 10 disques par 10 disques par contrôleurcontrôleur

1.2 La baie disque : 1.2 La baie disque : 11 11 contrôleurs au totalcontrôleurs au total

1.2 La baie disque : 1.2 La baie disque : Les partitions Les partitions

Exemple: si on crée 15 partitionsExemple: si on crée 15 partitions• 110/15 = 7+1/3110/15 = 7+1/3• On a donc la répartition:On a donc la répartition:

– partition 1: 7 disquespartition 1: 7 disques– partition 2: 8 disquespartition 2: 8 disques– partition 3: 7 disquespartition 3: 7 disques– on recommence 7,8,7,…on recommence 7,8,7,…

Maximum de contrôleurs par Maximum de contrôleurs par partitionspartitions

1.2 La baie disque : 1.2 La baie disque : Les partitions Les partitions

1.2 La baie disque : 1.2 La baie disque : Les partitions Les partitions

1.2 La baie disque : 1.2 La baie disque : Les partitions Les partitions

1.2 La baie disque : 1.2 La baie disque : Le Le strippingstripping

StrippingStripping  sur les partitions :  sur les partitions :• Répartition de la partition sur tous ses Répartition de la partition sur tous ses

disques et donc tous ses contrôleursdisques et donc tous ses contrôleurs• Données non successives sur un Données non successives sur un

disquedisque• Utilisation optimale du cache des Utilisation optimale du cache des

disquesdisques

1.2 La baie disque : 1.2 La baie disque : Le Le strippingstripping

1.2 La baie disque : 1.2 La baie disque : Le Le strippingstripping

1.2 La baie disque : 1.2 La baie disque : Le Le strippingstripping

1.2 La baie disque : 1.2 La baie disque : Le Le strippingstripping

1.2 La baie disque : 1.2 La baie disque : Piège de Piège de partitionnementpartitionnement

Création de 60 partitions

• Partitions mono-disque

• Accumulation de charge sur un seul contrôleur

=> Bw observées de plus de 10 fois inférieures à l ’ordinaire

1.2 La baie disque : 1.2 La baie disque : Piège de Piège de partitionnementpartitionnement

Création de 61 partitions•

•Répartition des partitions mono-disque équilibrée

=> les résultats restent bons dans cette configuration

=> à une partition près on peut avoir de bons ou de très mauvais résultats

1.3 Modes d ’utilisation1.3 Modes d ’utilisation

Modes d ’utilisation:Modes d ’utilisation:• Mode batchMode batch• Mode interactif :Mode interactif :

– mode multi-usersmode multi-users– mode exclusif mode exclusif

Pour la baie disque:Pour la baie disque:• Accès limité à notre groupeAccès limité à notre groupe• Test en interactif exclusif et multi-usersTest en interactif exclusif et multi-users

2.Description de l ’étude 2.Description de l ’étude réaliséeréalisée

2.1 Objectifs2.1 Objectifs 2.2 Méthodologie2.2 Méthodologie

• Démarche de programmationDémarche de programmation• Méthode de mesureMéthode de mesure• Paramètres étudiésParamètres étudiés• Méthode de travailMéthode de travail

2.1 Objectifs 2.1 Objectifs

Etudier les différents modes Etudier les différents modes d ’écritured ’écriture• Séquentiel / ParallèleSéquentiel / Parallèle• Direct / Indirect-synchroneDirect / Indirect-synchrone• Indirect asynchrone (recouvrement)Indirect asynchrone (recouvrement)

Rechercher les meilleures BwRechercher les meilleures Bw Mettre les résultats sur le web Mettre les résultats sur le web

=> http://www.ese-metz.fr/~vialle/parallel/par-io/index.html=> http://www.ese-metz.fr/~vialle/parallel/par-io/index.html

2.4 Méthodologie :2.4 Méthodologie : Démarche de Démarche de programmationprogrammation

Threads / Threads / ProcessusProcessus Fichiers de même tailleFichiers de même taille 1 fichier par processus1 fichier par processus

Ecriture d ’une zone mémoire allouée-fixée Ecriture d ’une zone mémoire allouée-fixée Barrière de synchronisation avant et aprèsBarrière de synchronisation avant et après

TTww = max (T = max (Tfin-writefin-write) - min (T) - min (Tdébut-writedébut-write))

2.4 Méthodologie :2.4 Méthodologie : Méthodes de mesureMéthodes de mesure

Mesure externe : timexMesure externe : timex

Mesure interne : gettimeofday()Mesure interne : gettimeofday()

Problème d ’incertitude :Problème d ’incertitude :• Résolution : 1msRésolution : 1ms• Variation constatée Variation constatée 500ms 500ms

2.4 Méthodologie : 2.4 Méthodologie : Paramètres étudiésParamètres étudiés

4 paramètres explicites :4 paramètres explicites :• Nombre de partitions présentes : TPNombre de partitions présentes : TP• Taille des données à écrire : QTaille des données à écrire : Q

• Nombre de processus utilisés : PNombre de processus utilisés : P• Nombre de partitions utilisées : SP (Nombre de partitions utilisées : SP (TP, TP, P)P)

2 paramètres implicites :2 paramètres implicites :• Nombre de disques par partition = 110 / TPNombre de disques par partition = 110 / TP• Nombre de disques utilisés = 110 / TP * SPNombre de disques utilisés = 110 / TP * SP

3. Le mode Direct3. Le mode Direct

3.1 Description 3.1 Description

3.2 Les Résultats3.2 Les Résultats

3.3 Bilan3.3 Bilan

3.1 Description3.1 Description

A la charge de l ’utilisateurA la charge de l ’utilisateur Toujours synchroneToujours synchrone Tenir compte des caractéristiques du DMATenir compte des caractéristiques du DMA

• Structure imposée aux données :Structure imposée aux données :– Taille minimale : 16 KoTaille minimale : 16 Ko– Taille maximale = Taille de page : 16 MoTaille maximale = Taille de page : 16 Mo– Taille totale = K Taille totale = K xx Taille minimale Taille minimale– Alignement : 32 KoAlignement : 32 Ko

• Une granularité de 16 Mo est l ’optimumUne granularité de 16 Mo est l ’optimum

file = open("nom_fichier.ext", O_RDWR|O_TRUNC|O_CREAT|O_SYNC|O_DIRECT);if (file < 0) … //error

if (statvfs("name_of_file.ext", &fsdesc))… //error if (strcmp(fsdesc.f_basetype,"xfs")) … //error if (fcntl(file, F_DIOINFO, dioI) != 0)… //errordatasize=10*1024*1024*1024; if (datasize%dioI.d_miniosz!=0) datasize+=dioI.d_miniosz-datasize%dioI.d_miniosz;

data=(double*)memalign(dioI.d_mem,dioI.d_maxiosz); if (mpin(data,dioinfo.d_maxiosz)==-1) … //error

while (dataondisk < datasize) { if (datasize-dataondisk >= dioI.d_maxiosz) {

datawewant=dioI.d_maxiosz; dataW=write(file,data,datawewant); } else {

datawewant=datasize-dataondisk; dataW=write(file,data,datawewant); }

if (datawrite!=datawewant) … // error dataondisk+=datawrite; }

close(file);

3.1 Description :3.1 Description : Surcoût de codeSurcoût de code

• #include <stdio.h> #include <stdlib.h> #include <fcntl.h> #include <unistd.h> #include <sys/types.h> #include <sys/statvfs.h>

• int example (void) { /* We need several variables as following. */ int file; /* The file descriptor */ double *data; /* The data to write. */ size_t datasize; /* The size of the data to be written */ size_t dataondisk; /* The size of the data already on the disk bay */ size_t datawrite; /* The size of the last writting (see below)*/ size_t datawewant; /* The size of the data we wanted to write (see below) */ /* To get the information about the DMA. composed of 3 variables: */ /* d_miniosz: the smallest size accepted by the DMA for one write. The size must be a multiple. */ /* d_maxiosz: the biggest size accepted by the DMA on one write. */ /* d_mem: the memory must be aligned on it */ struct dioattr dioinfo; struct statvfs fsdesc; /* To get the information about the filesystem. */

• /* We are trying to get the file descriptor, first with an open which will eliminate a lot of possible errors. We */ /* chose to create a new file, in direct mode (of course here) and in synchronous mode, even if O_DIRECT */ /* always occurs in synchronous mode we prefered precising it again. */ if (file=open("nom_fichier.ext", O_RDWR | O_TRUNC | O_CREAT | O_SYNC | O_DIRECT)<0) { perror("Open error: "); /* if there is an error, stop the open */ return -1; } /* Now we will get the informations about the file (which is created now) to check whether or not it is an xfs */ /* filesystem. The open could already check it when O_DIRECT is specified, but double check is better. */ if (statvfs("name_of_file.ext", &fsdesc)) { perror("Information about filesystem of the file can't be accessed: "); return -1; } /* Now we test whether or not it is a xfs file system (at last). */ if (strcmp(fsdesc.f_basetype,"xfs")) { perror("That's not xfs!"); return -1; } /* Here we can assume that we have a nice file descriptor. We chose to force the good rights for our file, but it */ /* would not be needed. */ fchmod(file,644);

• /* Now we will get the information about the DMA, to know how to allocate the memory. */ if (fcntl(file, F_DIOINFO, dioinfo) != 0) /* we ask for the information about the DMA */ { perror ("Internal fail of fcntl + F_DIOINFO."); /* if we can't get them, then error */ }

• /* We will now try to write 10GB of data. In a real situation, you will maybe have to write specific data, but here*/ /* we will write always the same bloc up to 10GB */ datasize=10*1024*1024*1024; /* 10GB */ /* We will have to change the datasize so that it will be a multiple of dioinfo.d_miniosz. This is the first */ /* condition on the data. */ if (datasize%dioinfo.d_miniosz!=0) /* Is it a multiple ?*/ datasize+=dioinfo.d_miniosz - datasize%dioinfo.d_miniosz; /* now it is a multiple, a bit longer */ /* We will use dioinfo.d_mem to know how to aligne the data, and allocate the memory. We will allocate only */ /* "dioinfo.d_maxiosz" because we have no real data to write, but in your case you should allocate datasize in */ /* your case. */ /*Remark: the system assume that dioinfo.d_maxiosz IS a multiple of dioinfo.d_miniosz, so that no need to */ /* check one more */ data=(double*)memalign(dioinfo.d_mem,dioinfo.d_maxiosz); /* We pin the memory so that it won't be moved because of reschedulding. It is not necessary but it increase */ /* a bit more the bandwidth. Once again, we only pin "dioinfo.d-maxiosz because that is what we allocate, you */ /* will need to pin datasize in your case */ if (mpin(data,dioinfo.d_maxiosz)==-1) /* Hope there is no error?*/ { perror("Mpin error:"); return -1; /* we want to pin so we exit, but you needn't to if you needn't mpin. */ }

• /* Now will begin the write. We need a loop because we can write only "small" blocs of "dioinfo.d_maxiosz" at */ /* a time. we use several test to be sure there are no errors. */ while (dataondisk<datasize) /* We stop when all the data are written. */ { /* If we can still write a whole DMA page we will, else we will heve to write less. */ /* Each time we use several variables: */ /* datawrite: "write" return the data size it really writed, to check later. */ /* datawewant: it is the data size we want to write on this write, to check with datawrite later */ if (datasize-dataondisk >= dio.d_maxiosz) datawrite=write(file,data,datawewant=dioinfo.d_maxiosz); else /* we will complete the data on the disk bay to have the right size */ datawrite=write(file,data,datawewant=datasize-dataondisk); /* Now we test if we really writed what we wanted to. */ if (datawrite!=datawewant) { perror("Write error!"); return -1; } /* Finally all was correct, so we notice the write */ dataondisk+=datawrite; } close(file) /* Do not forget... */ free(data); return 0; }

#include <stdio.h> #include <stdlib.h>

int example (void) { /* We need some variables as following. */ int file; /* The file descriptor */ double *data; /* The data to write. */ size_t datasize /* The size of the data to be written */

/* We are trying to get the file descriptor, first with an open which will eliminate a lot of possible */ /* errors. We chose to create a new file, in indirect mode (of course here) and in synchronous */ /* mode. Asynchronous mode is also possible. */ if (file=open("nom_fichier.ext", O_RDWR | O_TRUNC | O_CREAT | O_SYNC )<0) { perror("Open error: "); /* if there is an error, stop the open */ return -1; } /* Here we can assume that we have a nice file descriptor. We chose to force the good rights for */ /* our file, but it would not be needed. */ fchmod(file,644);

datasize=10*1024*1024*1024; /* We will write 10GB */ data=(double*)malloc(datasize); /* We allocate 10 GB */ /* Now a normal write, so easy. */ if (write(file,data,datasize)!=datasize) /* We check if we really write the good size of data */ { perror("Write error!"); return -1; } close(file); /* Never forget... */ return 0; }

3.2 Les résultats3.2 Les résultats

Combien de partitions utiliser ?Combien de partitions utiliser ? Combien de disques utiliser ?Combien de disques utiliser ? Combien de processus utiliser ?Combien de processus utiliser ? Erreurs de mesure et correctionErreurs de mesure et correction Bilan des I/O directesBilan des I/O directes

3.2 Les résultats : 3.2 Les résultats : Combien de partitions Combien de partitions utiliser?utiliser?

Etude de : Bw(P,SP) avec TP = 16

• P, Bw(SP) croissante

=> Utiliser le maximum de partitions disponibles :

SP = TP

3.2 Les résultats : 3.2 Les résultats : Combien de disques Combien de disques utiliser?utiliser?

Etude de : Bw(NbDisk) avec TP = 16

• Pente : 7 MB/s/disk

•Bw un disque 7MB/s

=> Bonne parallélisation

=> Utiliser le maximum de disques

3.2 Les résultats : 3.2 Les résultats : Combien de disques Combien de disques utiliser?utiliser?

Etude généralisée :

Bw(NbDisk,TP)

• Indépendant de TP

=> Peu de gaspillage

=> Bonne parallélisation

=> Utiliser le maximum de disques

3.2 Les résultats : 3.2 Les résultats : Combien de processus Combien de processus utiliser?utiliser?

Etude de : Bw(P) avec SP=TP (optimum)

• Meilleure Bw : P = K x TP

• Chaque processus écrit Q/P

=> Equilibrer la charge et l ’attaque des partitions

3.2 Les résultats : 3.2 Les résultats : Combien de processus Combien de processus utiliser?utiliser?

Etude de : Bw(P=K.TP,TP)

•Zone optimale :

8 Popt = K x Tp 16

=> Quelque soit le partitionnement, on peut exploiter la baie disque à l ’optimum en ajustant P

3.2 Les résultats : 3.2 Les résultats : Erreur des mesures Erreur des mesures externesexternes

Q moyen (<6GB) : Bw (P Q moyen (<6GB) : Bw (P 32) décroit 32) décroit

Q grand (>6GB) : Bw (P Q grand (>6GB) : Bw (P 32) constante 32) constante Hypothèse : erreur de mesure Hypothèse : erreur de mesure

• Initialisation des processusInitialisation des processus• Quelques autres instructions (allocation, ...)Quelques autres instructions (allocation, ...)

=> Mesure interne=> Mesure interne

3.2 Les résultats : 3.2 Les résultats : Mesures internesMesures internes

P P 50 : pas de perte de bande 50 : pas de perte de bande passantepassante

P > 50 : décroissance rencontréeP > 50 : décroissance rencontrée

Modification de la règle précédente Modification de la règle précédente ::

8 8 P Poptopt 50 50

3.3 Bilan des I/O directes3.3 Bilan des I/O directes Pour Pour l ’administrateurl ’administrateur

Pour l ’administrateur :Pour l ’administrateur :• Donner un accès à toutes les Donner un accès à toutes les

partitions pour touspartitions pour tous• Créer plus d ’une partition (résultats Créer plus d ’une partition (résultats

moins bon pour 1 partition unique)moins bon pour 1 partition unique)

3.3 Bilan des I/O directes3.3 Bilan des I/O directes Pour l ’utilisateurPour l ’utilisateur

Règle 1 :Règle 1 :• SP = TP SP = TP 2 2

Règle 2 :Règle 2 :• P = K P = K xx TP TP

Règle 3 :Règle 3 :• 8 8 P P 50 50

=> Bande passante de l ’ordre de => Bande passante de l ’ordre de 700MB/s700MB/s

4. Le mode Indirect4. Le mode Indirect

4.1 Description et différences4.1 Description et différences

4.2 Mode Indirect Synchrone4.2 Mode Indirect Synchrone

4.3 Mode Indirect Asynchrone4.3 Mode Indirect Asynchrone

4.1 Description et 4.1 Description et différencesdifférences Comparaison au Comparaison au mode Direct mode Direct

Gestion de l ’écriture par le Gestion de l ’écriture par le système :système :• Plus simplePlus simple• Plus sûrPlus sûr

Aucune contrainte sur les donnéesAucune contrainte sur les données 2 modes proposés:2 modes proposés:

• Le mode Indirect SynchroneLe mode Indirect Synchrone• Le mode Indirect AsynchroneLe mode Indirect Asynchrone

4.1 Description et 4.1 Description et différence :différence : Synchrone ou Synchrone ou asynchroneasynchrone

Mode Indirect Synchrone:Mode Indirect Synchrone:• Attente que l ’écriture soit effectuéeAttente que l ’écriture soit effectuée• Plus long mais mieux sécuriséPlus long mais mieux sécurisé

Mode Indirect Asynchrone:Mode Indirect Asynchrone:• Rend la main bien plus viteRend la main bien plus vite• Gestion entière par le système de l ’écriture Gestion entière par le système de l ’écriture

qui peut être différéequi peut être différée• Problème : maintenir l ’intégrité des donnéesProblème : maintenir l ’intégrité des données• Problème : moins sûr si reboot de la machineProblème : moins sûr si reboot de la machine

4.2 Mode Indirect 4.2 Mode Indirect SynchroneSynchrone

Procédure à suivreProcédure à suivre Granularité et DMAGranularité et DMA Combien de partitions utiliser?Combien de partitions utiliser? Influence de la taille des donnéesInfluence de la taille des données Combien de processus utiliser?Combien de processus utiliser? BilanBilan

4.2 Mode Indirect 4.2 Mode Indirect Synchrone :Synchrone : Procédure à suivreProcédure à suivre

Procédure d ’I/O habituelle :Procédure d ’I/O habituelle :• open (…)open (…)• write (…)write (…)• close (…)close (…)

=> Simple et connu=> Simple et connu

4.2 Mode Indirect 4.2 Mode Indirect Synchrone : Synchrone : Granularité et DMAGranularité et DMA

Etude de : Bw(Q1-write)

• Indirect : DMA masqué

•Asymptote au delà de 16MB

=> Q1-write 16MB

4.2 Mode Indirect 4.2 Mode Indirect Synchrone : Synchrone : Combien de partitions Combien de partitions utiliser?utiliser?

Etude de : Bw(P,SP) avec TP=8

• Idem mode direct :

• Bw(SP) croît

• SPopt = TP

=> Utiliser le maximum de partitions disponibles :

SP = TP

4.2 Mode Indirect 4.2 Mode Indirect Synchrone : Synchrone : Combien de partitions Combien de partitions créer ?créer ?

Etude de : Bw(TP)

1 TP 55 :

• Pas de gros pièges

• Bw(TP) croît

• 55 TP :

•Pièges nombreux

•Bw(TP) décroît

=> Créer de 45 à 55 partitions

4.2 Mode Indirect 4.2 Mode Indirect Synchrone : Synchrone : Influence de la taille des Influence de la taille des donnéesdonnées

Etude de : Bw(Q)

• Bw(Q>1.6GB) constante

=> Bw indépendant de Q

4.2 Mode Indirect 4.2 Mode Indirect Synchrone : Synchrone : Combien de processus Combien de processus utiliser?utiliser?

Etude de :

Bw(P=K.TP,SP=TP)

• I/O équilibrées

• Utilisation de tous les disques

• Identification de deux zones de performances

4.2 Mode Indirect 4.2 Mode Indirect Synchrone : Synchrone : Combien de processus Combien de processus utiliser?utiliser?

Zone 1 : TP 16

• Asymptote pour : P 16

• 350 MB/s

Zone 2 : TP > 16

• Popt = 1 x TP

• 550 MB/s

4.2 Mode Indirect 4.2 Mode Indirect Synchrone : Synchrone : Bilan Bilan

Plus facile d ’utilisation que le mode DirectPlus facile d ’utilisation que le mode Direct Plus lent que le mode DirectPlus lent que le mode Direct Règle 1 :Règle 1 :

• SPSPoptopt = TP = TP Règle 2 (Influence du DMA) :Règle 2 (Influence du DMA) :

• QQ1-write1-write > 16MB > 16MB Règle 3 :Règle 3 :

• TP>16 : prendre P = 1 TP>16 : prendre P = 1 xx TP TP 550 MB/s 550 MB/s Règle 4 :Règle 4 :

• TP<16 : prendre P = K TP<16 : prendre P = K xx TP TP 350 MB/s 350 MB/s

4.3 Mode Indirect 4.3 Mode Indirect AsynchroneAsynchrone

Même vitesse d ’écriture que le mode Même vitesse d ’écriture que le mode Indirect SynchroneIndirect Synchrone

Permet le recouvrement I/O-calcul :Permet le recouvrement I/O-calcul :• Gain de temps possibleGain de temps possible• Gain dépendant du programmeGain dépendant du programme• Étude spécifique (voir Bibliographie)Étude spécifique (voir Bibliographie)

Pas d ’expérimentations dans cette étude Pas d ’expérimentations dans cette étude ::• Pas d ’étude d ’applications complètesPas d ’étude d ’applications complètes

5. Les problèmes 5. Les problèmes rencontrésrencontrés

5.1 Rapide historique5.1 Rapide historique

5.2 Travail à distance5.2 Travail à distance

5.3 Le Bogue FF15149 de SGI5.3 Le Bogue FF15149 de SGI

6. Conclusion6. Conclusion Notre étude Notre étude

3 modes d ’écriture :3 modes d ’écriture :• Direct : plus rapide, moins facileDirect : plus rapide, moins facile• Indirect Synchrone : plus facile, moins rapideIndirect Synchrone : plus facile, moins rapide• Indirect Asynchrone : pour le recouvrementIndirect Asynchrone : pour le recouvrement

Règles de config. optimale différentesRègles de config. optimale différentes Règles d ’utilisation optimale différentes Règles d ’utilisation optimale différentes

6. Conclusion6. Conclusion Related worksRelated works

Beaucoup d ’études vers 1995Beaucoup d ’études vers 1995 Peu d ’études de performancesPeu d ’études de performances Plusieurs tendances :Plusieurs tendances :

• Simulation et traçage d ’un systèmeSimulation et traçage d ’un système• Recouvrement E/S - calculsRecouvrement E/S - calculs• Comparaison entre technologiesComparaison entre technologies

Mailing list : parallel-Mailing list : parallel-io@dartmouth.eduio@dartmouth.edu