Origin 2000 Etude et optimisation des entrées/sorties parallèles S. Descamps, S. Nussbaum, O. Rochel S. Vialle Avec le support technique d A. Filbois CCH.

Présentation au sujet: "Origin 2000 Etude et optimisation des entrées/sorties parallèles S. Descamps, S. Nussbaum, O. Rochel S. Vialle Avec le support technique d A. Filbois CCH."— Transcription de la présentation:

1 Origin 2000 Etude et optimisation des entrées/sorties parallèles S. Descamps, S. Nussbaum, O. Rochel S. Vialle Avec le support technique d A. Filbois CCH

2 Etude et optimisation des entrées/sorties parallèles 1. Environnement de travail 2. Description de l étude réalisée 3. Mode Direct 4. Mode Indirect 5. Problèmes rencontrés 6. Conclusion

3 1. Environnement de travail b 1.1 L Origin2000 b 1.2 La baie disque ConstitutionConstitution PartitionsPartitions StrippingStripping Piège de partitionnementPiège de partitionnement b 1.3 Modes d utilisation de l Origin2000 b 1.4 Ressources humaines de l étude

4 1.1 LOrigin2000 b Origine 2000 de Silicon Graphics (SGI) : DSM (Distributed Shared Memory) : CCNUMADSM (Distributed Shared Memory) : CCNUMA b Présentation en quelques chiffres : 64 processeurs R10000 à 195 Mhz64 processeurs R10000 à 195 Mhz 24 Go de RAM, 256 Mo de cache24 Go de RAM, 256 Mo de cache Baie disque de 1 Teraoctet Fibre ChannelBaie disque de 1 Teraoctet Fibre Channel

5 1.1 L Origin2000 : Structure interne From SGI Documentation

6 1.1 L Origin2000 : Liaison vers la baie disque From SGI Documentation

7 1.2 La baie disque b 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 b 11 contrôleurs de disques (Fibre Channel) Bande passante de 80 Mo/s par contrôleurBande passante de 80 Mo/s par contrôleur

8 1.2 La baie disque : Les 110 disques

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

10

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

12 1.2 La baie disque : Les partitions b Exemple: 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 disques –partition 2: 8 disques –partition 3: 7 disques –on recommence 7,8,7,… b Maximum de contrôleurs par partitions

13 1.2 La baie disque : Les partitions

14

15

16 1.2 La baie disque : Le stripping b Stripping sur les partitions : Répartition de la partition sur tous ses disques et donc tous ses contrôleursRépartition de la partition sur tous ses disques et donc tous ses contrôleurs Données non successives sur un disqueDonnées non successives sur un disque Utilisation optimale du cache des disquesUtilisation optimale du cache des disques

17 1.2 La baie disque : Le stripping

18

19

20

21 1.2 La baie disque : Piège de partitionnement 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

22 1.2 La baie disque : Piège de partitionnement 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

23 1.3 Modes d utilisation b Modes d utilisation: Mode batchMode batch Mode interactif :Mode interactif : –mode multi-users –mode exclusif b 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

24 1.4 Ressources humaines de l étude b Projet d étude : 3 étudiants O. Rochel, S. Nussbaum, S. Descamps : 2 moisO. Rochel, S. Nussbaum, S. Descamps : 2 mois b Stages : 2 étudiants S. Nussbaum : 1 mois (Supélec)S. Nussbaum : 1 mois (Supélec) S. Descamps : 3 mois (CCH) S. Descamps : 3 mois (CCH) b 1 enseignant : S. Vialle b Support technique : A. Filbois

25 2.Description de l étude réalisée b 2.1 Objectifs b 2.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

26 2.1 Objectifs b Etudier les différents modes d écriture Séquentiel / ParallèleSéquentiel / Parallèle Direct / Indirect-synchroneDirect / Indirect-synchrone Indirect asynchrone (recouvrement)Indirect asynchrone (recouvrement) b Rechercher les meilleures Bw b Mettre les résultats sur le web => http://www.ese-metz.fr/~vialle/parallel/par-io/index.html

27 2.4 Méthodologie : Démarche de programmation b Threads / Processus b Fichiers de même taille b 1 fichier par processus b Ecriture d une zone mémoire allouée-fixée b Barrière de synchronisation avant et après b T w = max (T fin-write ) - min (T début-write )

28 2.4 Méthodologie : Méthodes de mesure b Mesure externe : timex Mesure interne : gettimeofday() b Problème d incertitude : Résolution : 1msRésolution : 1ms Variation constatée 500msVariation constatée 500ms

29 2.4 Méthodologie : Paramètres étudiés b 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 ( TP, P)Nombre de partitions utilisées : SP ( TP, P) b 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

30 2.4 Méthodologie : Méthode de travail b D abord pour dégrossir : Utilisation de batch avec enregistrement brut puis extraction des résultatsUtilisation de batch avec enregistrement brut puis extraction des résultats Fichier de Log pour vérification en cas d irrégularitéFichier de Log pour vérification en cas d irrégularité b Puis pour finaliser : Étude au cas par casÉtude au cas par cas Courbes spécifiquesCourbes spécifiques

31 3. Le mode Direct 3.1 Description 3.2 Les Résultats 3.3 Bilan

32 3.1 Description b A la charge de l utilisateur b Toujours synchrone b Tenir compte des caractéristiques du DMA Structure imposée aux données :Structure imposée aux données : –Taille minimale : 16 Ko –Taille maximale = Taille de page : 16 Mo –Taille totale = K x Taille minimale –Alignement : 32 Ko Une granularité de 16 Mo est l optimum Une granularité de 16 Mo est l optimum

33 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)…//error datasize=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 = 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);

34 3.1 Description : Procédure à suivre b Procédure à suivre: Pré requis : arborescence montée en xfsPré requis : arborescence montée en xfs Open : préciser O_DIRECTOpen : préciser O_DIRECT Statvfs : pour vérifier le pré requisStatvfs : pour vérifier le pré requis Fcntl : pour les caractéristiques du DMAFcntl : pour les caractéristiques du DMA Formatage de la mémoireFormatage de la mémoire Write : Souvent une boucle à cause du DMAWrite : Souvent une boucle à cause du DMA CloseClose

35 3.1 Description : Surcoût de code # include #include #include #include #include #include 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 = 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 #include 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; }

36 3.2 Les résultats b Combien de partitions utiliser ? b Combien de disques utiliser ? b Combien de processus utiliser ? b Erreurs de mesure et correction b Bilan des I/O directes

37 3.2 Les résultats : Combien de partitions utiliser? Etude de : Bw(P,SP) avec TP = 16 P, Bw(SP) croissante => Utiliser le maximum de partitions disponibles : SP = TP

38 3.2 Les résultats : Combien de disques 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

39 3.2 Les résultats : Combien de disques utiliser? Etude généralisée : Bw(NbDisk,TP) Indépendant de TP => Peu de gaspillage => Bonne parallélisation => Utiliser le maximum de disques

40 3.2 Les résultats : Combien de processus 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

41 3.2 Les résultats : Combien de processus 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

42 3.2 Les résultats : Recherche du K optimum Etude de : Bw(TP,K=P/TP) Bw opt (TP,K) Bw opt Zone optimale : 8 Popt = K x Tp 16 => Quelque soit le partitionnement, on peut exploiter la baie disque à l optimum

43 3.2 Les résultats : Erreur des mesures externes b Q moyen (<6GB) : Bw (P 32) décroit Q grand (>6GB) : Bw (P 32) constante b Hypothèse : erreur de mesure Initialisation des processusInitialisation des processus Quelques autres instructions (allocation,...)Quelques autres instructions (allocation,...) => Mesure interne

44 3.2 Les résultats : Mesures internes b P 50 : pas de perte de bande passante b P > 50 : décroissance rencontrée b Modification de la règle précédente : 8 P opt 50

45 3.3 Bilan des I/O directes Pour l administrateur b Pour l administrateur : Donner un accès à toutes les partitions pour tousDonner un accès à toutes les partitions pour tous Créer plus d une partition (résultats moins bon pour 1 partition unique)Créer plus d une partition (résultats moins bon pour 1 partition unique)

46 3.3 Bilan des I/O directes Pour l utilisateur b Règle 1 : SP = TP 2SP = TP 2 b Règle 2 : P = K x TPP = K x TP b Règle 3 : 8 P 508 P 50 => Bande passante de l ordre de 700MB/s

47 4. Le mode Indirect 4.1 Description et différences 4.2 Mode Indirect Synchrone 4.3 Mode Indirect Asynchrone

48 4.1 Description et différences Comparaison au mode Direct b Gestion de l écriture par le système : Plus simplePlus simple Plus sûrPlus sûr b Aucune contrainte sur les données b 2 modes proposés: Le mode Indirect SynchroneLe mode Indirect Synchrone Le mode Indirect AsynchroneLe mode Indirect Asynchrone

49 4.1 Description et différence : Synchrone ou asynchrone b 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é b Mode Indirect Asynchrone: Rend la main bien plus viteRend la main bien plus vite Gestion entière par le système de l écriture qui peut être différéeGestion entière par le système de l écriture qui 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

50 4.2 Mode Indirect Synchrone b Procédure à suivre b Granularité et DMA b Combien de partitions utiliser? b Influence de la taille des données b Combien de processus utiliser? b Bilan

51 4.2 Mode Indirect Synchrone : Procédure à suivre b Procédure d I/O habituelle : open (…)open (…) write (…)write (…) close (…)close (…) => Simple et connu

52 4.2 Mode Indirect Synchrone : Granularité et DMA Etude de : Bw(Q 1-write ) Indirect : DMA masqué Asymptote au delà de 16MB => Q 1-write 16MB

53 4.2 Mode Indirect Synchrone : Combien de partitions utiliser? Etude de : Bw(P,SP) avec TP=8 Idem mode direct : Bw(SP) croît SP opt = TP => Utiliser le maximum de partitions disponibles : SP = TP

54 4.2 Mode Indirect Synchrone : Combien de partitions 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

55 4.2 Mode Indirect Synchrone : Influence de la taille des données Etude de : Bw(Q) Bw(Q>1.6GB) constante => Bw indépendant de Q

56 4.2 Mode Indirect Synchrone : Combien de processus utiliser? Etude de : Bw(P=K.TP,SP=TP) I/O équilibrées Utilisation de tous les disques Identification de deux zones de performances

57 4.2 Mode Indirect Synchrone : Combien de processus utiliser? Zone 1 : TP 16 Asymptote pour : P 16 350 MB/s Zone 2 : TP > 16 P opt = 1 x TP 550 MB/s

58 4.2 Mode Indirect Synchrone : Bilan b Plus facile d utilisation que le mode Direct b Plus lent que le mode Direct b Règle 1 : SP opt = TPSP opt = TP b Règle 2 (Influence du DMA) : Q 1-write > 16MBQ 1-write > 16MB b Règle 3 : TP>16 : prendre P = 1 x TP 550 MB/sTP>16 : prendre P = 1 x TP 550 MB/s b Règle 4 : TP<16 : prendre P = K x TP 350 MB/sTP<16 : prendre P = K x TP 350 MB/s

59 4.3 Mode Indirect Asynchrone b Même vitesse d écriture que le mode Indirect Synchrone b 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) b Pas d expérimentations dans cette étude : Pas d étude d applications complètesPas d étude d applications complètes

60 5. Les problèmes rencontrés 5.1 Rapide historique 5.2 Travail à distance 5.3 Le Bogue FF15149 de SGI

61 5.1 Rapide historique b Prise en main en Indirect (mai 99) ->erreur sur l utilisation des partitions->erreur sur l utilisation des partitions b Passage au mode Direct (juillet 99) Meilleur prise en main et automatisationMeilleur prise en main et automatisation -> plantages inexpliqués-> plantages inexpliqués b Retour au mode Indirect (fin juillet 99) Détection des erreurs commises en maiDétection des erreurs commises en mai -> plantages inexpliqués-> plantages inexpliqués

62 5.1 Rapide historique b Passage à 1 seul stagiaire (Fin Juillet 99) b Exploitation des résultats, hypothèses (Août 99) b Nouveau programme de test b Changement du système sur l Origin2000 : IRIX 6.5.5f : le 09/09/99IRIX 6.5.5f : le 09/09/99 b Nouveaux tests spécifiques (Sept 99) disparition des plantagesdisparition des plantages

63 5.2 Travail à distance b Une période avec quelquun sur place : Plus facile en cas de saturation du réseauPlus facile en cas de saturation du réseau Contact avec Alain Filbois facilitéContact avec Alain Filbois facilité b Période seul : Vacance d Alain Filbois : arrêt de l Origin2000Vacance d Alain Filbois : arrêt de l Origin2000 Difficulté due au réseauDifficulté due au réseau Travail avec Alain Filbois par mail efficace tout de mêmeTravail avec Alain Filbois par mail efficace tout de même

64 5.3 Le Bogue FF15149 de SGI b Manifestation: Arrêt du déroulement du programmeArrêt du déroulement du programme Processus bloqués, kill -9 sans effetProcessus bloqués, kill -9 sans effet La baie disque est bloquéeLa baie disque est bloquée Reboot obligatoireReboot obligatoire Les autres processus peuvent continuer à fonctionner tout de mêmeLes autres processus peuvent continuer à fonctionner tout de même b Disparu depuis le changement de système mais pas d explication de la part de SGImais pas d explication de la part de SGI

65 6. Conclusion Notre étude b 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 b Règles de config. optimale différentes b Règles d utilisation optimale différentes

66 6. Conclusion Related works b Beaucoup d études vers 1995 b Peu d études de performances b 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 b Mailing list : parallel-io@dartmouth.edu