Fig. 8.6 – Computation d’un agent P : P vide sa inbox puis modifie sa m´emoire et sa outbox.
applications de simulation) ou engendr´e par la r´eaction de l’environnement aux computations des agents dans le cas d’un syst`eme informatique classique (avec des agents ´evoluant `a un rythme non contrˆol´e). La dynamique d’un terme MIC∗ correspond ainsi `a l’application d’une suite de fonctions sur un terme MIC∗ initial, µ ◦ ϕ ◦ γ ◦ γ ◦ γ ◦ ϕ ◦ µ ◦ γ ◦ ϕ par exemple (c’est-`a-dire M ◦ I ◦ C ◦ C ◦ C ◦ I ◦ M ◦ C ◦ I).
8.3.3 Impl´ementations et disponibilit´e du mod`ele MIC∗
Depuis son ´elaboration, le mod`ele MIC∗a fait l’objet de plusieurs prototypes. Aujourd’hui, il existe essentiellement deux versions du mod`ele, l’une en Java et l’autre en C++. Le projet ´etant d´evelopp´e sur le principe du logiciel libre, ces diff´erentes versions peuvent ˆetre r´ecup´er´ees sur la page Internet du projet :sourceforge.net/projects/mic. La figure8.7pr´esente une version ´elagu´ee du diagramme de classe correspondant `a la version du noyau Java qui impl´emente les principes du mod`ele MIC∗ 4.
8.4
Exemple : le Jeu de la vie en MIC
∗8.4.1 Principe du Jeu de la vie
D´ecrit pour la premi`ere fois par John Conway dans la fin des ann´ees 60, le Jeu de la vie fait partie des applications qui concernent le domaine des automates cellulaires. L’automate cellulaire du Jeu de la vie est d´efini par une grille r´eguli`ere o`u chaque cellule poss`ede un ´etat binaire : vivante ou morte. Une cellule a pour voisines les huit cases adjacentes (voisinage de Moore). Les r`egles d’´evolution de chaque cellule sont les suivantes :
– lorsque la cellule est morte : si elle a exactement trois voisines vivantes, la cellule devient vivante. Dans les autres cas elle reste morte.
– lorsque la cellule est vivante : si elle a deux ou trois voisines vivantes, la cellule reste vivante. Dans les autres cas elle meurt.
4Il faut noter que ce diagramme peut ne plus correspondre exactement aux versions actuellement impl´emen-
Fig. 8.7 – Impl´ementation du mod`ele MIC∗.
Dans ce syst`eme, l’ensemble des cellules ´evolue de fa¸con synchrone. Par ailleurs, la grille est toro¨ıdale, c’est-`a-dire que les cellules qui se trouvent au bord de la grille ont pour voisines les cases qui se trouvent de l’autre cˆot´e, y compris en diagonale. La figure 8.8 montre un exemple de cette dynamique pour six pas de temps.
1 3
6 5
4
2
Fig. 8.8 – Exemple d’´evolution de l’automate cellulaire du Jeu de la vie.
Pour illustrer la mani`ere dont on peut mod´eliser un syst`eme `a l’aide du mod`ele MIC∗, nous allons maintenant mod´eliser cet automate cellulaire et sa dynamique en d´efinissant un ensemble d’agents et un environnement de d´eploiement ad´equats. Avant d’aller plus loin, il est important de noter que la mod´elisation que nous allons proposer ne repr´esente qu’une solution parmi les nombreuses fa¸cons dont il est possible de mod´eliser ce syst`eme `a l’aide de MIC∗.
8.4 Exemple : le Jeu de la vie en MIC∗ 179
8.4.2 Description statique
Pour mod´eliser ce syst`eme, nous allons tout d’abord consid´erer qu’`a chaque cellule de coordonn´ees (x, y) correspond un espace d’interaction J(x,y). A cela nous ajoutons un espace
d’interaction particulier J0 qui, bien que non indispensable, nous permettra d’illustrer une loi
de mouvement.
Les espaces d’interaction que nous venons de d´efinir seront peupl´es par des agents dont le processus de calcul repr´esentera la dynamique d’une cellule. On a donc un agent par cellule. Cependant, un agent sera non seulement pr´esent dans l’espace d’interaction de la cellule qu’il repr´esente mais aussi dans chaque espace d’interaction d´efinissant les cellules voisines. Ce qui lui permettra d’interagir avec ses voisins. Pour cela, la outbox d’un agent sera d´efinie par l’un ou l’autre des deux objets d’interaction suivants :
– CellOwner qui d´ecrit la repr´esentation de l’agent dans l’espace d’interaction de la cellule qu’il habite (une information bool´eenne : vivant au mort).
– Neighbor qui d´efinit la repr´esentation de l’agent dans les espaces d’interaction repr´esen- tant les cellules voisines.
Pour peupler la grille, nous allons utiliser une loi de mouvement. Pour cela, tous les agents sont initialement plac´es dans l’espace d’interaction J0 avec une repr´esentation, un objet d’interac-
tion InitialAgentRep, qui va engendrer pour chaque agent les neuf mouvements n´ecessaires `a leur placement dans les bons espaces d’interaction et avec les bons objets d’interaction. La figure8.9illustre cette phase initiale et montre la mani`ere dont les boˆıtes d’´emission de l’agent repr´esentant la cellule (2, 2) sont d´efinies sur chacun des neufs espaces d’interaction o`u l’agent existe. J0 Mouvements CellOwner Neighbor InitialAgentRep Boîtes démission d’un agent
Fig. 8.9 – Un agent est pr´esent dans neuf espaces d’interaction : sa cellule et ses voisines.
8.4.3 Description de la dynamique
Pour obtenir la dynamique du Jeu de la vie, nous allons maintenant d´efinir la mani`ere dont interagissent les diff´erentes repr´esentations des agents. Pour cela, nous allons sp´eci- fier une unique loi d’interaction tr`es simple, commune `a tous les espaces d’interaction, qui fait intervenir les deux objets d’interaction pr´ec´edents. Nous allons poser qu’un objet d’in- teraction CellOwner r´eagit `a un objet d’interaction N eighbor de mani`ere `a cr´eer, dans la inbox de l’agent concern´e, un nouvel objet d’interaction N eighborComputation qui va repr´esenter la perception qu’un agent a de son voisin, ce qui lui permettra de connaˆıtre
son ´etat. Plus formellement, cette loi correspond `a l’application de la fonction suivante : interactionjdl(CellOwner, N eighbor) = N eighborComputation. En Java par exemple, cette
loi d’interaction se r´esume au code suivant :
p u b l i c I n t e r a c t i o n O b j e c t i n t e r a c t i o n ( I n t e r a c t i o n O b j e c t t a r g e t , I n t e r a c t i o n O b j e c t from ) {
i f( t a r g e t i n s t a n c e o f CellOwner && from i n s t a n c e o f N e i g h b o r )
r e t u r n t a r g e t . i n t e r a c t i o n ( from ) ; // r e t u r n s a NeighborComputation IO r e t u r n I n t e r a c t i o n O b j e c t . z e r o ;
}
Ainsi, lorsque cette loi est appliqu´ee `a l’ensemble des espaces d’interaction et pour tous les couples d’objets d’interaction possibles, tous les agents obtiennent dans leur inbox un ensemble d’objets d’interaction N eighborComputation qui repr´esente l’´etat dans lequel se trouvent ses voisins. La figure8.10illustre l’application de cette loi sur l’espace d’interaction de coordonn´ees (2, 2).
Interaction (
,
objets d'interaction présents dans les boîtes d'émission de
l'espace d'interaction (2,2)
) =
Interaction (
,
) =Interactions sur l'espace (2,2)
objets d’interaction reçus dans la inbox de l'agent représentant la cellule (2,2)
OUTBOX INBOX
CellOwner Neighbor NeighborCompuation
Fig. 8.10 – Application de la loi d’interaction sur l’espace de coordonn´ees (2, 2).
A partir de l`a, un agent est donc capable de percevoir via sa inbox l’´etat dans lequel se trouvent ses voisins. Le deuxi`eme temps de la dynamique du syst`eme consiste alors `a faire calculer l’ensemble des agents pour que ceux-ci mettent `a jour leurs repr´esentations dans les diff´erents espaces o`u il se trouve. Pour cela, un agent effectue un calcul tr`es simple pour savoir l’´etat dans lequel il doit se trouver en appliquant les r`egles du Jeu de la vie.
Voici le code utilis´e dans la structure interne d’un agent qui correspond `a ce calcul5 : p u b l i c v o i d compute ( ) { Map i n b o x = myPlugin . c a l c u l a t e I n b o x ( ) ; I n t e r a c t i o n O b j e c t r e s u l t=n u l l; f o r( I t e r a t o r i = i n b o x . v a l u e s ( ) . i t e r a t o r ( ) ; i . hasNext ( ) ; ) { r e s u l t = ( I n t e r a c t i o n O b j e c t P l u s ) i . n e x t ( ) ; } Debug . l o g ( ”computing ”+r e s u l t ) ; V e c t o r v = new V e c t o r ( ) ; r e s u l t . g e t L i s t O b j e c t ( v ) ; 5
La complexit´e apparente de ce code est principalement due au fait que le moteur MIC∗´ecrit en Java est une version exp´erimentale ou de tr`es nombreuses choses restent `a encapsuler.
8.4 Exemple : le Jeu de la vie en MIC∗ 181
computation ( ) =
computation
OUTBOX INBOX
objets d’interaction reçus dans la inbox de l'agent représentant la cellule (2,2)
l'agent représentant la cellule (2,2) met à jour ses représentations dans les
neuf espaces où il se trouve
Fig. 8.11 – Computation dun agent d’un agent : perception via la inbox puis mise `a jour de ses repr´esentations dans sa outbox.
i n t a l i v e N e i g h b o r s = 0 ; f o r( I t e r a t o r i=v . i t e r a t o r ( ) ; i . hasNext ( ) ; ) i f( ( ( NeighborComputation ) i . n e x t ( ) ) . g e t S t a t e ( ) ) a l i v e N e i g h b o r s ++; i f ( s t a t e && ( a l i v e N e i g h b o r s < 2 | | a l i v e N e i g h b o r s >3) ) s t a t e=f a l s e; e l s e i f ( a l i v e N e i g h b o r s == 3 ) s t a t e=t r u e; myPlugin . r e f r e s h L o c a l O u t b o x C o p y ( ) ; f o r( I t e r a t o r i=g e t A g e n t P l u g i n ( ) . l o c a l O u t b o x C o p y . e n t r y S e t ( ) . i t e r a t o r ( ) ; i . hasNext ( ) ; ) {
Map . Entry e = (Map . Entry ) i . n e x t ( ) ;
i f( e . g e t V a l u e ( ) i n s t a n c e o f CellOwner ) e . s e t V a l u e (new CellOwner ( s t a t e ) ) ; e l s e e . s e t V a l u e (new N e i g h b o r ( s t a t e ) ) ; } Debug . l o g ( ”computing 2 ”+g e t A g e n t P l u g i n ( ) . l o c a l O u t b o x C o p y ) ; g e t A g e n t P l u g i n ( ) . p u b l i s h C o m p u t a t i o n ( ) ; }
Finalement, pour obtenir la dynamique globale qui correspond `a l’´evolution de l’automate cellulaire du Jeu de la vie, il suffit d’alterner l’application de la loi d’interaction avec la loi de computation des agents. La loi d’interaction permet dans un premier temps de r´ecup´erer l’´etat des voisins qui est ensuite utilis´e dans un deuxi`eme temps pour calculer l’´etat suivant d’un agent. Autrement dit, du point de vue du mod`ele MIC∗, on applique la s´equence suivante : (I ◦ C)∗. Dans l’annexeA, nous donnons quasiment l’int´egralit´e du code correspondant `a cette application : les objets d’interaction (sectionA.1page225), les espaces d’interaction (section A.2page226), le processus de calcul correspondant `a une cellule (sectionA.3 page227) et le programme principal qui contrˆole la dynamique globale du syst`eme (sectionA.4 page229).
8.4.4 Remarques
La mod´elisation que nous venons de pr´esenter se distingue de la fa¸con dont on programme g´en´eralement un automate cellulaire en int´egrant les principes du paradigme agent. Tout
d’abord, il est int´eressant de noter que les agents n’ont aucune repr´esentation de leur localisa- tion absolue, c’est-`a-dire de leurs coordonn´ees dans l’environnement global : ils ne poss`edent pas l’information (i, j). Par ailleurs, ils n’ont pas d’acc`es direct `a l’´etat de leurs voisins et agissent uniquement en fonction de la perception qu’ils en ont. Leur perception est unique- ment bas´ee sur des crit`eres locaux.
Autre point tr`es important, dans un contexte classique, la dynamique du Jeu de la vie n´ecessite l’utilisation d’un ´etat tampon dans lequel on stocke les nouvelles valeurs qui sont calcul´ees pour l’´etat suivant d’une cellule. En effet, il est n´ecessaire de ne pas mettre `a jour directement l’´etat d’une cellule de mani`ere `a ce que les cellules voisines puissent effectuer leurs propres calculs sur les bonnes donn´ees. Ici, cela n’a pas ´et´e n´ecessaire dans le sens o`u un agent peut mettre `a jour son ´etat interne et ses repr´esentations d`es le moment du calcul.
En fait, l’une des plus importantes caract´eristiques du mod`ele MIC∗repose sur le fait qu’il propose une distinction claire entre le temps de l’interaction et le temps du calcul. En fait, il s’agit ici bien sˆur d’une mise en œuvre du principe Influence/R´eaction. En effet, outre le fait que les objets d’interaction sont utilis´es pour signifier l’existence des agents dans le syst`eme, ils peuvent aussi ˆetre vus comme des influences produites par le calcul des agents. La r´eaction de l’environnement `a ces influences correspond alors `a l’application des r`egles d’interaction sur les diff´erents objets d’interaction.
MIC∗ ne propose pas uniquement une mani`ere ad´equate d’appliquer le principe Influen- ce/R´eaction mais il constitue aussi une formalisation ´el´egante des diff´erentes solutions que nous avons envisag´ees pour les contraintes que nous avons ´enum´er´ees au d´ebut de ce chapitre. Nous allons maintenant mettre cela en ´evidence.