Intelligence Artificielle Distribuée. Dossier technique. IAD TeamZ

Intelligence Artificielle Distribuée Dossier technique IAD TeamZ 29 mai 2004

Table des matières 1 Introduction 4 1.1 Historique d Othello........................ 4 1.2 Othello............................... 5 1.3 But du jeu.............................. 5 1.4 Support............................... 5 2 Algorithmique 6 2.1 Fonction d évaluation........................ 6 2.2 MinMax et Alpha Beta....................... 7 2.2.1 L algorithme MinMax................... 7 2.2.2 Alpha Beta ou MinMax amélioré............. 10 2.2.3 Codage de l othellier.................... 12 3 Algorithmique distribuée 12 3.0.4 le maître.......................... 13 3.0.5 l esclave.......................... 13 3.0.6 Amélioration........................ 14 4 LAM/MPI 14 4.1 Introduction à LAM/MPI...................... 14 4.2 Installation de LAM/MPI...................... 15 4.2.1 Avec les sources...................... 15 4.2.2 Sous Debian........................ 15 4.2.3 Parc Informatique EPITA.................. 15 4.3 Configuration............................ 16 4.3.1 problèmes communs.................... 16 4.3.2 problèmes liés au PIE.................... 16 5 IAD 17 5.1 compilation............................. 17 5.1.1 Paramètres......................... 17 5.1.2 environnement du PIE................... 17 5.1.3 le./configure........................ 17 5.2 Configuration............................ 18 5.2.1 Spécification automatique................. 18 5.2.2 Spécification avancee.................... 18 5.3 Exécution.............................. 18 5.3.1 LAM/MPI plusieurs esclaves sur une seule machine... 19 5.3.2 Autres modes........................ 19 2

6 Résultats 20 6.1 Résultats techniques......................... 20 6.2 XMPI................................ 24 7 Webographie 24 3

1 Introduction Le but de ce projet était de réaliser une version d othello avec une IA utilisant efficacement plusieurs ordinateurs. 1.1 Historique d Othello Le jeu d Othello 1 sous sa forme actuelle a été commercialisé pour la première fois au Japon en 1971. Toutefois, ce jeu est très proche d un jeu anglais vieux d une centaine d années, connu sous le nom de Reversi. Qui a inventé le Reversi alors? Il est difficile de répondre à cette question. Deux gentlemen anglais, Lewis Waterman et John W. Mollett, se disputent la paternité de ce jeu dans les années 1880 et se traitent mutuellement d escrocs. A la fin des années 1880, où le Reversi était extrêmement populaire en Angleterre, les deux protagonistes avaient publié des livrets de règles et soutenaient des fabricants rivaux. Le plus vieil article de presse sur le jeu connu à ce jour est paru dans "The Saturday Review" daté du 21 août 1886. Le jeu est peu diffusé jusqu à ce que l auteur de jeux Walter H. Peel écrive au printemps 1888 une série d articles publiés dans "The Queen", un magazine spécialisé dans "des sujets intéressant les dames". Plusieurs livrets sont alors publiés mais le jeu perd de sa popularité au début du siècle. On trouve tout au long du vingtième siècle des références au jeu de Reversi mais celui-ci reste très confidentiel malgré une diffusion en Europe Centrale et aux Etats-Unis. Othello a été inventé en 1971 au Japon par Goro Hasegawa. Son père, professeur de littérature anglaise, suggéra le nom Othello par analogie avec les rebondissements de la pièce de Shakespeare. Il y a seulement deux différences avec Reversi : une seule position de départ est autorisée, et on peut emprunter des pions à l adversaire s il est obligé de passer. Dès 1973, le jeu devient un succès commercial au Japon et le premier championnat national est organisé. En 1976 le jeu d Othello envahit les Etats-Unis et l Angleterre. Parallèlement àà ce succès, des fédérations nationales se créent ; le premier championnat du monde est ainsi organisé en 1977 sur une base annuelle. En 1980, pour la première fois, le titre n est pas remporté par un Japonais : le joueur américain Jonathan Cerf bat le champion asiatique Takuya Mimura en finale. Le jeu d Othello apparaît en France à la fin des années 70 tandis que le premier championnat de France est organisé en 1980. En 1983, la Fédération 1 Othello est une marque déposé, on préférera le terme "Reversi" 4

Française d Othello est créée et va monter en puissance grâce, notamment, au journal "Jeux & Stratégie" qui fait du jeu un de ses "Grands Classiques". En 1984, Paul Ralle, alors âgé de 16 ans, devient le premier Français (et le deuxième non- Japonais) à remporter le titre suprême. La seconde moitié des années 80 voit un développement lent mais constant de la pratique du jeu. Toujours parmi les meilleurs au niveau mondial, l équipe de France remporte en 1990 le titre par équipe (performance qu elle rééditera en 1994 et 1998), tandis que Marc Tastet devient en 1992 le deuxième champion du monde français. 1.2 Othello Othello est un jeu de stratégie à deux joueurs : Noir et Blanc. Il se joue sur un plateau unicolore de 64 cases, 8 sur 8, appelé othellier. Ces joueurs disposent de 64 pions bicolores, noirs d un côté et blancs de l autre. Par commodité, chaque joueur a devant lui 32 pions mais ils ne lui appartiennent pas et il doit en donner à son adversaire si celui-ci n en a plus. Un pion est noir si sa face noire est visible et blanc si sa face blanche est sur le dessus. Pour jouer, il faut poser un pion sur une case vide, de manière à encadrer une ou plusieurs rangées de pions adverses qui sont alors retournées et qui nous appartiennent. 1.3 But du jeu Avoir plus de pions de sa couleur que l adversaire à la fin de la partie. Celle-ci s achève lorsque aucun des deux joueurs ne peut plus jouer de coup légal. Cela intervient généralement lorsque les 64 cases sont occupées. 1.4 Support Le projet est sous licence GPL 2 et est hébergé sur GNA 3 ici 4. Il sera bientôt téléchargeable en tar.bz2 ici 5. En attendant un accès au CVS en anonyme est proposé : cvs -d:pserver:anonymous@cvs.gna.org:/cvs/iad co iad 2 http://www.gnu.org/copyleft/gpl.html 3 http://www.gna.org 4 https://gna.org/projects/iad 5 http://home.gna.org/iad/ 5

2 Algorithmique Nous avons implementé un minimax et un minimax_alpha_beta non-distribué de référence pour que chaque membre du groupe puisse comprendre l algorithme facilement. On peut jouer contre l ordinateur sans distribuer l algorithme (option -IA). 2.1 Fonction d évaluation Les algorithmes doivent être capables d évaluer une situation, c est a dire la valeur d un échiquier par rapport à un coup considéré. Ainsi à un echiquier dans une certaine configuration est associé une note pour un joueur consideré. Plus la note est grande plus le coup est pertinent et permettra de se diriger vers une victoire. C est la fonction d évaluation qui fournie cette note en évaluant une situation selon plusieurs critères : Les pions positionnés Il s agit des pions définitif groupés autour d un angle. Les pions C-X Les 3 pions autour d un angle sont les 3 pions C-X (les 2 du bord sont les pions C et celui en diagonale est le X) Les pions insérés Il s agit d un groupe de pions entièrement cernés par des pions adverses (cheval de troie) Les pions incrustés C est une invention maison : c est moins bien noté que les pions insérés : en fait les pions insérés sont tous incrustés Il s agit de pions complètement entourés, avec possibilité d avoir des voisins enemis. La mobilité Plus un coup laisse de possibilités a l adversaire, plus il aura statistiquement de chances de jouer un bon coup, il faut donc réduire ses possibilités avec la technique dite du bétonnage. Tous ces critères sont évalués par la suite pour donner une note au coup joué. pour un même critère, une note peut être positive ou négative selon la situation : un pion X est souvent malheureux mais dans certaines situations, cela peut-être très rentable. 6

L algorithme va chercher à trouver les coups maximisants sa note et minimisant la note du joueur adverses. Les valeurs d évaluation des différentes stratégies décrites ci-dessus ont été modifiées par bon sens et tâtonnement, et en jouant de nombreuses parties, soit contre un humain, soit contre le générateur aléatoire. 2.2 MinMax et Alpha Beta 2.2.1 L algorithme MinMax Son principal atout est de tester tous les coups possibles jusqu à une certaine profondeur, y compris donc les coups tels que les sacrifices, etc..., qui paraissent dans un premier temps mauvais. Son principal défaut est, à l inverse, d être très lent : le nombre de configurations à tester évolue exponentiellement en fonction de la profondeur de réflexion, et donc le temps de réflexion également. La stratégie minmax suppose tout d abord que chacun des joueurs joue son meilleur coup (par rapport aux valeurs calculées par l algorithme) à chaque fois ; ça paraît discutable, mais ça n a pas l air de marcher si mal que ça : si l adversaire ne joue pas son meilleur coup, alors par définition c est qu il arrivera à une position moins forte qu il n aurait pu (toujours par rapport aux valeurs calculées par l algorithme lui-même). On commence donc par développer l arbre des coups possibles jusqu à la profondeur maximale. Pour cela on regarde l échiquier et on calcule les positions jouables pour le joueur courant (l ordinateur). Pour ce début de partie : Si c est "à l algorithme" de jouer en premier il a quatre coups possibles : C3, D2, F4, E5. Supposons qu il joue C3, au coup suivant l adversaire à trois coups possibles C2, E2 et C4 : Ainsi de suite. On aura donc un "arbre" des coups possibles comme celui visible sur la figure 3 page 9. Après chaque coup, on obtient une position : après le coup C3, une position dans laquelle c est à l adversaire de "l algorithme" de jouer, après la suite C3 - C2, c est à nouveau à l algorithme de jouer, et ainsi de suite. Après chaque suite de trois coups, notamment (donc aux feuilles de l arbre), c est à l adversaire de l algorithme de jouer. La fonction coût devient alors primordiale : c est elle qui va decider de la meilleur branche, c est a dire celle menant à un score le plus élevé possible. 7

FIG. 1 Début de partie FIG. 2 Après un premier coup 8

FIG. 3 Arbre de l algorithme MinMax Cela est notamment necessaire du fait qu on ne peut pas calculer absolument tous les coups possibles mais qu on doivent se limiter à une certaine profondeur d arbre selon les ressources allouées (nombre de nodes,...). L algorithme MiniMax, dû à Von Neumann, est très simple : on visite l arbre de jeu pour faire remonter à la racine une valeur (appelée "valeur du jeu") qui est calculée récursivement. On peut aller à n importe quelle profondeur de réflexion, en gardant bien à l esprit cependant que ce n est pas très rapide (on regarde tout l arbre, dont la taille croit exponentiellement en fonction de la profondeur). Pour être sûr d aller jusqu a la fin de la partie il faut compter une profondeur au moins égale au nombre de case sur l échiquier (dans le cas fictif ou l on passerait tout le temps). Il faut également garder à l esprit que cette stratégie dépend énormément de la qualité de la fonction d évaluation (on peut par exemple lorsque l on detecte que l on va gagner la partie à coup sur dans une certaine branche lui donner plus de poid). Le pseudo code de l algorithme est le suivant : minimax(in game board, in int depth, in int max_depth, out score chosen_score, out score chosen_move) begin 9

if (depth = max_depth) then chosen_score = evaluation(board); else moves_list = generate_moves(board); if (moves_list = NULL) then chosen_score = evaluation(board); else for (i = 1 to moves_list.length) do best_score = infinity; new_board = board; apply_move(new_board, moves_list[i]); minimax(new_board, depth+1, max_depth, the_score, the_move); if (better(the_score, best_score)) then best_score = the_score; best_move = the_move; endif enddo chosen_score = best_score; chosen_move = best_move; endif endif end. 2.2.2 Alpha Beta ou MinMax amélioré On observe que l algorithme MINIMAX effectue l évaluation pour tous les noeuds de l arbre de jeu d un horizon donné. Mais il existe des situations dans lesquelles, pour déterminer la valeur MiniMax associée à la racine, il n est pas nécessaire de calculer les valeurs associées à tous les noeuds de l arbre. On peut remarquer une telle situation dans la figure suivante, où la racine a un fils avec la valeur maximale possible (+100), donc les valeurs des autres fils n importent pas : elles ne peuvent pas changer la valeur MiniMax : La valeur 100 du fils central permet d éviter d explorer les autres branches : elle ne pourront pas changer la valeur MiniMax L algorithme alpha-beta est une optimisation du MiniMax, qui "coupe" des sous-arbres dès que leur valeur devient inintéressante aux fins du calcul de la valeur MiniMax du jeu. Cette optimisation permet souvant de diviser par deux le temps de calcul, sur le jeu othello le gain est de 30%. De plus en pratique ce gain permet de doubler la profondeur de l arbre. 10

FIG. 4 Nécessité d utiliser alpha-beta Le nom de l algorithme vient du nom donné a des valeurs portées par les noeuds dans le cas où il est utilisé : 1. alpha d un noeud : est une approximation par le bas de la vraie valeur du noeud. Elle est égale à la valeur sur les feuilles, et est initialisée à inf ailleurs. Ensuite, sur les noeuds joueur elle est maintenue égale à la plus grande valeur obtenue sur les fils visités jusque là, et elle est égale à la valeur alpha de son prédécesseur sur les noeuds opposant. 2. beta d un noeud : c est une approximation par le haut de la vraie valeur du noeud. Elle est égale à la valeur sur les feuilles, et est initialisée à +inf ailleurs. Ensuite, sur les noeuds opposant elle est maintenue égale à la plus petite valeur obtenue sur les fils visités jusque là, et elle est égale à la valeur beta de son prédécesseur sur les noeuds joueur. Le pseudo code de l algorithme est le suivant : minimax (in game board, in int depth, in int max_depth, in boolean alpha_beta, in score black_best, in score white_best, out score chosen_score, out score chosen_move) begin : 11

end. : minimax(new_board, depth+1, max_depth, alpha_beta, black_best, white_best, the_score, the_move); if (alpha_beta) then if (to_move(black) and (the_score > black_best)) if (the_score > white_best) break; /* alpha_beta cutoff */ else black_best = the_score; endif endif if (to_move(white) and (the_score < white_best)) if (the_score < white_best) break; /* alpha_beta cutoff */ else white_best = the_score; endif endif endif : : 2.2.3 Codage de l othellier L othellier est de taille variable, le choix intervenant à la compilation. Ceci permet de tester plus facilement l algorithme et nécessite plus de puissance de calcul. 3 Algorithmique distribuée Il y a principalement deux manière de distribuer minmax : 1. Méthode du split : le maitre execute le corps de l algorithme et chaque exclave ne fait qu évaluer des positions avec la fonction coût 6. 6 cf Principle Variation Splitting (Marsland, Olafsson, and Schaeffer, 1986) 12

2. Méthode du depth : le maître évalue le premier niveau et répartit sur les esclaves les calculs à faire. Chaque esclaves s occupant lui même des sous niveaux de l algorithme (chaque esclave execute MinMax mais en commençant à une profondeur différente). Ces deux méthodes ont leurs points faibles et leurs avantages : Pour la méthode du split : + Tous les esclaves travaillent en permanence + Si un esclave meurt on peut facilement redistribuer - Beaucoup de transfert réseau Pour la méthode du depth : + Peu de transfert réseau + Fiabilité : à chaque coup on envoi uniquement aux esclaves "vivants" - Si un esclave meurt on devra peut être refaire beaucoup de calcul en fonction de son niveau. - Certains esclaves peuvent ne pas travailler pour certains coups. Nous avons choisis la deuxième méthode. Notre minimax est distribué de la sorte : 3.0.4 le maître Calcul de la liste des coups possibles Traitement des cas triviaux (un ou zero coups possibles) Creation des jobs 7 par le dispatcher Envoi des jobs aux processus esclaves Recuperation des meilleurs coups et comparaison Renvoi du meilleur coup Pour jouer en distribuant l algorithme il faut utiliser l option NETWORK. 3.0.5 l esclave Réception d une situation à tester Algorithme alpha beta dessus Renvoi au maître du meilleur coup trouvé et de sont coût 7 Un job un est un noeud de l arbre à évaluer 13

3.0.6 Amélioration En faisant cela on se rend vite compte que au dela de 6 esclaves (le nombre moyen de coup jouables) beaucoups ne servent que très peu ou pas du tout. Par exemple si au premier coup on a 5 possibilités et 20 esclaves le maitre n enverra des jobs que à 5 esclaves. La solution est d envoyer en même temps que les situation une liste d esclaves utilisable pour chaque exclaves. Par exemple dans le cas précédents si les esclaves sont numérotés de 1 à 20 on aura : esclave 1 : évalue cout de position 1 avec les esclaves 6,7,8 esclave 2 : évalue cout de position 2 avec les esclaves 9,10,11 esclave 3 : évalue cout de position 3 avec les esclaves 12,13,14 esclave 4 : évalue cout de position 4 avec les esclaves 15,16,17 esclave 5 : évalue cout de position 5 avec les esclaves 18,19,20 4 LAM/MPI 4.1 Introduction à LAM/MPI LAM/MPI est une bibliothèque de calcul parallèlle. MPI signifie Message Passing Interface et est un standard qui nous permet d écrire des applications distribuées portables. Il en existe plusieurs implémentations. Nous avons choisi LAM, qui est disponible sur toutes les distributions dignes de ce nom, et pour laquelle nous disposions d une documentation de qualité. LAM/MPI 8 est un environnement de programmation MPI développé par Ohio Supercomputer Center 9. Il permet à la fois le débuggage des applications MPI grace à des démons (comme PVM) et l éxécution performante des codes en courtcircuitant ces démons lorsque l application est testée. 8 http://www.mpi.nd.edu/lam/ 9 http://www.osc.edu/ 14

4.2 Installation de LAM/MPI 4.2.1 Avec les sources Les sources de la version utilisée sont disponibles depuis l url suivante : http://www.lam-mpi.org/ Une fois les sources récupérée on compile les binaires :./configure --prefix=~/lam/ --without-romio make make install 4.2.2 Sous Debian Pour compiler IAD, vous aurez besoin du paquet lam4-dev. Le problème est que ce paquet contient la version 7 de LAM, non compatible avec les versions inferieures (ou du moins posant suffisamment de problèmes de deploiment). Ceci venant de format de message incompatibles et d une liaison avec une version précise lors de la compilation. Pour eviter les problèmes d execution en cas de communication avec les machines du PIE, mieux vaut compiler LAM a partir des sources 10 afin d uniformiser les versions utilisées. Pour les autres distributions. Attention aux problèmes des versions. Utilisez bien la 6.5.9 et pas les 7.*.*. 4.2.3 Parc Informatique EPITA Choix de la version de LAM : Nous n avons pas pu compiler les dernières versions de LAM sur le PIE, et nous sommes donc rabattus sur des versions anterieures : la 6.5.9. Ceci ne devrait pas être pénalisant étant donné l usage que l on compte en faire. Une version compilée se trouve ici : " cessie_g/www/lam_install.tar.bz2". ou http://www/epita.fr/~cessie_g/lam_install.tar.bz2 Lieu de l installation : Il faut que les binaires soient accessibles à toutes les machines participant a la distribution. Il faut donc installer les binaires sur votre compte ou sur le sgoinfre en cas de problème de quotas. 10 cf section 4.2.1 15

4.3 Configuration 4.3.1 problèmes communs Clefs ssh : Lorsque vous lancez lamboot, il ne doit y avoir aucune sortie standard, c est à dire que aucune confirmation ou action ne doit être nécessaire. Ainsi vos clefs ssh ne doivent pas vous demander de mot de passe. deux solutions, soit vous creez vos clefs sans passphrase (non securisé), soit vous utilisez ssh-agent comme suit : eval ssh-agent -s ssh-add qui lorsque la passphrase sera demandé la renverra automatiquement. 4.3.2 problèmes liés au PIE environnement avoir un.mytcshrc comme celui qui suit (remplacer bien sur cessie_g par votre login ;), ne rien laisser d autre et la dernière ligne est indispensable!) : setenv PATH /u/a2/cessie\_g/lam/bin:/u/a2/cessie\_g/iad/bin\${path} setenv LAMHOME /u/a2/cessie\_g/lam/ setenv LAMRSH "ssh -x" alias. echo Je ne buggerais plus N.B : même si vous utilisez zsh, bash ou autre d habitude cela concerne toujours le.mytcshrc qui est utilisé par lamboot pour les vm. En effet lors du lancement des machines virtuelles sur les différents noeuds du réseau le shell par défaut est obligatoirement utilisé. En l occurence à l école le shell tcsh 11. Le PATH et LAHMOME permettent aux machines virtuelles de trouver LAM, LAMRSH indique que l on utilise ssh et pas rsh. Enfin l alias résoud un problème spécifique au PIE. Les machines virtuelles pourront alors être lancées sur des pcs distants. 11 http://www.tcsh.org 16

5 IAD 5.1 compilation 5.1.1 Paramètres Les seuls paramètres intéressants à modifier sont : BOARD_SIZE : Dans board.h qui représente la taille de la board. MAX_LEVEL : La profondeur d évaluation de l algorithme (dans minmax_othello.h) ELAGUEUR : La puissance des cut-offs de l algorithme alpha-beta (dans minmax_othello.h). 5.1.2 environnement du PIE Pour génerer le configure, il vous faut une version correcte des autotools : export PATH=/u/prof/yaka/bin/:\$PATH./autogen.sh NB : n utilisez surtout pas ceux d akim avec lesquels j ai eu de nombreux problèmes! 5.1.3 le./configure Pour compiler IAD avec MPI il faut faire : CC=mpicc./configure --prefix=\$home/iad && make all install pour compiler avec le débuggage : CC=mpicc./configure --prefix=\$home/iad --enable-debug && make all install cela definira : IAD_DEBUG : macro a utiliser : IAD_DEBUG(command) ; IAD_DEBUG_FLAG : define a utiliser avec un #ifdef./configure --help vous donnera plus d informations. La compilation abouti à deux exécutables dans le répertoire src/ : iad et iadslave. L exécutable iad s occupe de l affichage graphique et de l envoi de données aux esclaves, alors que iadslave s occupe uniquement de retourner les coups (en utilisant minmax) pour une position et une profondeur donnée. 17

5.2 Configuration 5.2.1 Spécification automatique Le "./configure" genère "/tmp/lamhosts" automatiquement avec la machine sur laquelle vous etes en premier (le maître) et une liste de nodes listés dans le fichier lamnodes. Ensuite on lance la vm sur les différents noeuds avec la commande : lamboot /tmp/lamhosts -vd Les deux dernieres lignes du résultat de la commande précédente doivent être les suivantes : topology done lamboot completed successfully Les machines virtuelles sont alors lancées sur les différents noeuds en attente de travaux. 5.2.2 Spécification avancee On peut mettre plus de travaux sur un pc avec l option CPU, le fichier lamhosts ressemblant alors à : localhost machine1 CPU=2 machine2 CPU=1 Le nom (ou l ip) de sa propre machine doit toujours être en debut de liste. 5.3 Exécution Il faut ensuite faire un fichier add.shema qui précise ce qui est lancé sur chaque noeud du réseau : n0 iad -b NETWORK n1 iadslave Ici on a indiqué que le noeud 0 fait tourner iad et le noeud 1 l éxecutable iadslave. NB : verifiez votre PATH pour qu il comprenne bien iad et iadslave. Ensuite pour lancer IAD qui utilisera tous les noeuds du réseau on lance sur le maître la commande : 18

mpirun add.schema NB : Attention bien distinguer les messages affichés par le maître et les esclaves car ils sont tous affichés sur le maître. 5.3.1 LAM/MPI plusieurs esclaves sur une seule machine Il suffit de changer les fichiers précédents avec : $ cat add.schema n0 iad -b NETWORK n0 -np X iadslave $ cat lamhosts localhost Remplacer X par le nombre d esclaves voulu. Ensuite le mpirun add.schema les utilisera tous sur le pc courant. 5.3.2 Autres modes Iad supporte de nombreuses options : Usage: iad [-h] [-b <input>] [-w <input>] [-o <output>] -h Help -b Input player (Black) [GRAPHIC] -w Input player (White) [GRAPHIC] -o Output [GRAPHIC] I/O values: TEXT GRAPHIC PIPE IA NETWORK RANDOM text mode graphic mode pipe mode (interface) EXPERIMENTAL! computer (input only) computer (input only) random mode (input only) Par exemple pour jouer contre l IA sans distribution on peut faire :./iad -b IA Ou pour tester la distribution de l algorithme contre un random :./iad -b NETWORK -w RANDOM 19

6 Résultats 6.1 Résultats techniques Malgré la distribution de l algorithme le jeu reste jouable (environ une seconde entre chaque coup pour une profondeur de 9 avec 15 esclaves 12 ). Les parties ont été testées contre de nombreux autres jeux d othello de niveaux conséquents 13 et les resultats semblent bons. Une procédure de test intensive à été mise au point en utilisant une IA random et l ordinateur gagne à 100% (environ 300 parties testées). Seulement deux points sont à améliorer : MPI ne gère pas facilement la mort des esclaves : si un esclave meurt (sigkill par exemple) la partie s arrete sans alternative : Lamboot stop directement tous les noeuds du réseau y compris le programme maitre. La redistribution des travaux en cas de problèmes ou d esclave inocupés n a pas été faite (problème avec la communication MPI qui ne permet pas d envoyer facilement des types complexes 14 ) Débug MPI du de l envoi et de la réception des coups et coûts : -------------- DEBUT MPI----------------- Je suis le maitre et il y a 13 process (moi compris). Master: debut create jobs: J ai 12 esclaves, chaque esclave va faire AU MIN 1 jobs parmis les 12. job numero 11 [pour player 2] Liste des coup a tester: 53, job numero 10 [pour player 2] Liste des coup a tester: 54, job numero 9 [pour player 2] Liste des coup a tester: 62, job numero 8 [pour player 2] Liste des coup a tester: 63, job numero 7 [pour player 2] Liste des coup a tester: 64, job numero 6 [pour player 2] Liste des coup a tester: 65, job numero 5 [pour player 2] Liste des coup a tester: 70, job numero 4 [pour player 2] Liste des coup a tester: 71, job numero 3 [pour player 2] Liste des coup a tester: 74, 12 Simulé sur un seul ordinateur 13 http://othello.federation.free.fr/info/prog.htm 14 Les structs par exemple 20

FIG. 5 Capture d écran en cours de partie job numero 2 [pour player 2] Liste des coup a tester: 76, job numero 1 [pour player 2] Liste des coup a tester: 78, job numero 0 [pour player 2] Liste des coup a tester: 79, Master: fin create job: 12 jobs crees. Master: debut de l envoi des donnees: Master: send jobs 11 to slave number 1 Master: send jobs 10 to slave number 2 Master: send jobs 9 to slave number 3 Master: send jobs 8 to slave number 4 Master: send jobs 7 to slave number 5 Master: send jobs 6 to slave number 6 Master: send jobs 5 to slave number 7 Master: send jobs 4 to slave number 8 Master: send jobs 3 to slave number 9 Master: send jobs 2 to slave number 10 Master: send jobs 1 to slave number 11 Master: send jobs 0 to slave number 12 21

Master: fin envoi des donnees. Master: debut reception des donnees sur 13 proc. * slave 1: La board recue contient 1 positions a tester pour le player 2. * slave 1: Envoi la meillleure position 53 (coutant 229) au maitre * slave 1: Fin envoi. Attente next job * slave 2: La board recue contient 1 positions a tester pour le player 2. * slave 2: Envoi la meillleure position 54 (coutant 234) au maitre * slave 2: Fin envoi. Attente next job * slave 3: La board recue contient 1 positions a tester pour le player 2. * slave 3: Envoi la meillleure position 62 (coutant 212) au maitre * slave 3: Fin envoi. Attente next job * slave 4: La board recue contient 1 positions a tester pour le player 2. * slave 4: Envoi la meillleure position 63 (coutant 221) au maitre * slave 4: Fin envoi. Attente next job * slave 5: La board recue contient 1 positions a tester pour le player 2. * slave 5: Envoi la meillleure position 64 (coutant 220) au maitre * slave 5: Fin envoi. Attente next job * slave 6: La board recue contient 1 positions a tester pour le player 2. * slave 6: Envoi la meillleure position 65 (coutant 231) au maitre * slave 6: Fin envoi. Attente next job * slave 7: La board recue contient 1 positions a tester pour le player 2. * slave 7: Envoi la meillleure position 70 (coutant 229) au maitre * slave 7: Fin envoi. Attente next job * slave 8: La board recue contient 1 positions a tester pour le player 2. * slave 8: Envoi la meillleure position 71 (coutant 221) au maitre 22

* slave 8: Fin envoi. Attente next job * slave 9: La board recue contient 1 positions a tester pour le player 2. * slave 9: Envoi la meillleure position 74 (coutant 227) au maitre * slave 9: Fin envoi. Attente next job * slave 10: La board recue contient 1 positions a tester pour le player 2. * slave 10: Envoi la meillleure position 76 (coutant 236) au maitre * slave 10: Fin envoi. Attente next job * slave 11: La board recue contient 1 positions a tester pour le player 2. * slave 11: Envoi la meillleure position 78 (coutant 228) au maitre * slave 11: Fin envoi. Attente next job * slave 12: La board recue contient 1 positions a tester pour le player 2. * slave 12: Envoi la meillleure position 79 (coutant 230) au maitre * slave 12: Fin envoi. Attente next job Master: a recut la position 53 avec le cout 229 Master: a recut la position 54 avec le cout 234 Master: a recut la position 62 avec le cout 212 Master: a recut la position 63 avec le cout 221 Master: a recut la position 64 avec le cout 220 Master: a recut la position 65 avec le cout 231 Master: a recut la position 70 avec le cout 229 Master: a recut la position 71 avec le cout 221 Master: a recut la position 74 avec le cout 227 Master: a recut la position 76 avec le cout 236 Master: a recut la position 78 avec le cout 228 Master: a recut la position 79 avec le cout 230 Master: fin reception des donnees Master: Le coup choisi est 76. ---------------FIN MPI resultat:76------- 23

FIG. 6 XMPI 6.2 XMPI Une des caractéristiques les plus intéressantes de LAM est la possibilité d exploiter les traces générées avec l option -ton de LAM mpirun. Le script lamjob appelle automatiquement lamtrace qui collecte ces traces dans le fichier lamjob.lamtr. L application XMPI 15 permet d exploiter les traces produites. A la fin de l exécution du code on lance xmpi sur le noeud maitre. On observe sur la figure 6 page 24 en vert les temps d activité (calcul), en rouge l inactivité et en jaune la communication. 7 Webographie http://othello.federation.free.fr/info/algos.htm http://www.isty-info.uvsq.fr/~guillema/projets_othello.html http://www.coppit.org/othello/jothello/writeup.html http://www.ox.compsoc.net/~djc/othello.shtml 15 http://www.lam-mpi.org/software/xmpi/ 24

Un bon site donnant une vue d ensemble du projet (et un particulier un protocole de communication pour l architecture client-serveur) : http://www.coppit.org/othello/jothello/writeup.html Implémentation du min max pour Othello : http://www.isty-info.uvsq.fr/~guillema/projets_othello.html Un jeux d echec utilisant le calcul distribué http://www.uni-paderborn.de/fachbereich/ag/monien/research/gametree/ Un othello en C : http://www.funducode.com/freec/misc_c/misc_c13/misc_c13.htm Un othello distribué avec algo génétique!! http://www-sop.inria.fr/cafe/olivier.arsac/darwersi/ Une modélisation très globale d othello : http://www.cs.brown.edu/courses/cs015/2003/asgn/finalprojects/othello/initial.htm Asynchronous Parallel Game-Tree Search (1998) : http://citeseer.ist.psu.edu/12065.html Massively Parallel Chess (1994) http://citeseer.ist.psu.edu/joerg94massively.html Heuristic Search in One and Two Player Games (1992) http://citeseer.ist.psu.edu/marsland92heuristic.html Min-Max parralélisé http://www.pressibus.org/ataxx/autre/minimax/paper.html A Taxonomy Of Parallel Game-Tree Search Algorithms (1996) http://citeseer.ist.psu.edu/brockington96taxonomy.html 25