M08:10

il y a des coupures que chez moi ?

herda sirine08:11

oui

Hanane Guemmouma08:11

oui chez toi

Vous08:12

- un objet : un agent

Vous08:14

1- lancer un agent

setup()

Vous08:15

-OnShotBehaviour

Vous08:16

- CyclicBehaviour

_Generic Behaviour (Behvaviour)

action () done()

A M08:20

madame si vous pouvez utiliser un fichier word pour ecrire ce que vous envoyer dans le chat

car en cas de perte de connextion

on perd tout

le chat

Communication

1
send / receive

ACL

ENVOI

ACLMessage m = new ACLMessage (ACLMessafe.INFORM);

m. addReceiver <--- AID

m.setcontent ( string) <--- l'information à envoyer ( une valeur / une chaine de caractères)

send(m);

this.myAgent.send();

exemple;

import jade.lang.acl.*;

c= 10;

ACLMessage m = new ACLMessage(ACLMessage.INFORM);

m.addReceiver(new AID("A2",AID.ISLOCALNAME));
m.addReceiver(new AID("A3",AID.ISLOCALNAME));
m.setContent(Integer.toString(c));
myAgent.send(m);

receive

blockingReceive

ACLMessage m1;

m1=myAgent.blockingReceive();
if(m1!=null){System.out.println("Je suis A1 :" +
m1.getContent());}

m1= receive();

while (m1==null) {block();}

2
cas d'un tableau

ACLMessage m = new ACLMessage(ACLMessage.INFORM);

m.addReceiver(new AID("A2",AID.ISLOCALNAME));
m.addReceiver(new AID("A3",AID.ISLOCALNAME));
try {m.setContentObject(T);}
catch (IOException e) {e.printStackTrace();}
myAgent.send(m);

int [] T = new int [10];

try {T =(int[]) m1.getContentObject();}
catch (UnreadableException e)
{e.printStackTrace();}
int S = 0;
for (int i=0;i<T.length;i++){
if(T[i] % 2 == 0)
{S = S + T[i];}
}
r="Somme des Nombres paires : "+S;
m.setContent(r);

getArguments()

Object [] T = getArguments();

String a = (String) T[0];

String b = (String) T[1];

int c = Integer.parseInt(a)+ Integer.parseInt(b);

System.out.println(" Je suis "+ this.getLocalName()+ " La somme que j'ai trouvée est : "+c);

- Main : programme principal qui lance les agents (les noms d'agents, l'environnement
jade (GUI), les arguments.

- méthode 1 : run configuration

class main jade.Boot

arguments -gui le_nom_d'agent_à_créeer:le_nom_du_package.le nom_de_la_classe

3
- méthode 2: programmer la configuration (méthode 1)

public class Main extends Agent {

public static void main(String[] args) {

String [] jadeArg = new String [2];
StringBuffer SbAgent = new StringBuffer();
SbAgent.append("S1:Main;");
SbAgent.append("S2:Main;");
SbAgent.append("S3:Main;");
jadeArg[0]="-gui";
jadeArg[1]=SbAgent.toString();
jade.Boot.main(jadeArg);
}

- méthode 3: runtime, profile

public class dadi_agent extends Agent {

public static void main(String[] args)
{
// préparer les arguments pout le conteneur JADE
Properties prop = new ExtendedProperties();
// demander la fenêtre de contrôle
prop.setProperty(Profile.GUI, "true");
// nommer les agents
prop.setProperty(Profile.AGENTS,
"a1:Test.dadi_agent;a2:Test.dadi_agent;a3:Test.dadi_agent");
// créer le profile pour le conteneur principal
ProfileImpl profMain = new ProfileImpl(prop);

// lancer le conteneur principal

jade.core.Runtime rt = jade.core.Runtime.instance();
rt.createMainContainer(profMain);
}

par défaut les agents se trouvent sur le MAincontainer.

MainContainer un seul

Container (s) plusieurs groupe d'agents

4
DF: Directory Facilator: enregistrer les agents par service.

Jade

5
6
-la programmation à mémoire partagée ( threads)

variables locales / globales

threads en java, pthreads en C , threads en OpenMP

- la programamtion à mémoire distribuée (

le seul moyen de communication via messages

MPI

OpenMPI, MPICH, ..

MPI: Message Passing Interface

7
PMD

Programme.c

- Linux OpenMPI

- Windows: SDK (simuler un cluster)

mpicc programme.c -o programme ---- génerer .exe

mpirun -np 4 ./programme -- lancer l'application sur une architecture parallèle ayant 4
processus.

4 le nombre de processus /processeurs

mpirun -np 8 ./programme

8 le nombre de processus /processeurs

mpirun -np 3 ./programme

3 le nombre de processus /processeurs

mpirun -np 65 ./programme

5 le nombre de processus /processeurs

SPMD: Single Program Multiple Data

1- Initialiser MPI

8
MPI_Init(&argc, &rgv);

MPI_Comm_rank (MPI_COMM_WORLD, & my_rank);

MPI_Comm_size (MPI_COMM_WORLD, & p);

COMMUNICATION

- Communication point à point

- communication collective.

- Communication point à point

ecrire un programme MPI où le processus 0 envoi une valeur au processus 1.

MPI_Send(void* buf, int

count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm):

MPI_Recv(void* buf, int count, MPI_Datatype datatype, int source, int tag,
MPI_Comm comm, MPI_Status *status);

Solution

#include "mpi.h"
int my_rank; /* Rang du processus */
int p; /* Nombre de processus */
int val;
int tag= 666;
, MPI_Status status;
...
main (int argc, char *argv []) {
...
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &my_rank);
MPI_Comm_size(MPI_COMM_WORLD, &p);

if (my_rank==0) { val = 10;

MPI_send (&val, 1, MPI_INT,1, tag, MPI_COMM_WORLD);

9
}

if (my_rank==1) {

MPI_Recv(&val, 1, MPI_INT, 0, tag, MPI_COMM_WORLD, &status);

printf (" j'ai reçu la valeur %d", val);

MPI_Finalize () ;
...
}

EXO 2:

ecrire un programme MPI où le processus 0 envoi un tableau d'entiers de 100 valeurs au

processus 1.

Solution

#include "mpi.h"
int my_rank; /* Rang du processus */
int p; /* Nombre de processus */
int [100] val;
int tag= 666;
, MPI_Status status;
...
main (int argc, char *argv []) {
...
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &my_rank);
MPI_Comm_size(MPI_COMM_WORLD, &p);

if (my_rank==0) {

/* Remplir le tableau de valeurs */

for (int i =0; i<100; i++) val[i] =i;

/* Envoyer le tableau

MPI_send (val, 100, MPI_INT,1, tag, MPI_COMM_WORLD);

}

if (my_rank==1) {

MPI_Recv(val, 100, MPI_INT, 0, tag, MPI_COMM_WORLD, &status);

printf (" j'ai reçu la valeur %d", val);

MPI_Finalize () ;

10
}

MPI_Send(message, strlen(message)+1, MPI_CHAR, 0, tag,

MPI_COMM_WORLD);

if ( my_rank == 0)
for (source = 1; source < p; source++) {
MPI_Recv(message, 100, MPI_CHAR, source, tag,
MPI_COMM_WORLD, &status);
printf("%s\n", message);
}

Exercice

Ecrire un programme MPI ou les processus du rang impair communiquent entre eux en
envoyant un tableau de 20 caractères qui se strouve intialement chez le processus P1
(rang =1). utiliser la communication point à point.

11
12