Exercice 2
On désire concevoir une application client-serveur à même de réaliser un calcul parallèle pour la multiplication d'un ensemble de n vecteurs à 4 dimensions par une matrice 4x4.
a) Ecrire une application serveur permettant de réaliser le produit de un vecteur par une matrice et rendant le résultat.
b) Ecrire une application serveur permettant de réaliser le produit de nv vecteurs par une matrice M et rendant les résultats.
c) Ecrire une application cliente initialisant n vecteurs et distribuant leurs produits par une matrice M sur ns serveurs disponibles.
d) Reprendre la question précédente de manière à utiliser des Threads pour réaliser une programmation parallèle.
Application serveur (question a en rouge, question b en vert, question c en magenta).
import java.rmi.* ;
import java.util.Vector ;
public interface InterfaceEx2 extends Remote {
public Vecteur produitMatriceVecteur(Matrice m,Vecteur v)
throws RemoteException ;
public Vector produitMatriceVecteurs(Matrice m,Vector vv)
throws RemoteException ;
}
import java.rmi.* ;
import java.rmi.server.* ;
import java.net.* ;
import java.util.Vector ;
/* ************************************ */
/* Extension de UnicastRemoteObject */
/* Implantation de l'interface distante */
/* ************************************ */
public class ServeurEx2
extends UnicastRemoteObject
implements InterfaceEx2 {
/* ************************************ */
/* Constructeur */
/* ************************************ */
public ServeurEx2()
throws RemoteException {
super() ;
}
/* ************************************ */
/* Produit d'un vecteur par une matrice */
/* ************************************ */
public Vecteur produitMatriceVecteur(Matrice m,Vecteur v)
throws RemoteException {
Vecteur r = new Vecteur() ;
for ( int i = 0 ; i < 4 ; i++ ) {
r.m[i] = 0.0F ;
for ( int j = 0 ; j < 4 ; j++ )
r.m[i] += m.m[i][j]*v.m[j] ; }
return(r) ;
}
/* ************************************ */
/* Produit de plusieurs vecteurs */
/* par une matrice */
/* ************************************ */
public Vector produitMatriceVecteurs(Matrice m,Vector vv)
throws RemoteException {
Vector r = new Vector() ;
int n = vv.size() ;
for ( int v = 0 ; v < n ; v++ ) {
Vecteur vec =(Vecteur) vv.elementAt(v) ;
Vecteur nv = new Vecteur() ;
for ( int i = 0 ; i < 4 ; i++ ) {
nv.m[i] = 0.0F ;
for ( int j = 0 ; j < 4 ; j++ )
nv.m[i] += m.m[i][j]*vec.m[j] ; }
r.addElement(nv) ; }
return(r) ;
}
/* ************************************ */
/* Application serveur assurant */
/* la creation d'un objet distant, */
/* sa referenciation avec namming */
/* sur la rmiregistry de l'hote local */
/* ************************************ */
public static void main(String [] args) {
try {
ServeurEx2 esclave =
new ServeurEx2();
Naming.rebind("Esclave",esclave) ;
ServeurEx2 esclaves[] = new ServeurEx2[10] ;
for ( int i = 0 ; i < 10 ; i++ ) {
esclaves[i] = new ServeurEx2();
Naming.rebind("Esclave"+(i+1),esclaves[i]) ; }
System.out.println("Prêt"); }
catch (RemoteException re) {
System.out.println(re) ; }
catch(MalformedURLException e) {
System.out.println(e) ; }
}
}
import java.io.Serializable ;
/* ************************************ */
/* Classe vecteur 4D */
/* ************************************ */
public class Vecteur implements Serializable {
public float m[] = new float[4] ;
public void annulle() {
for ( int i = 0 ; i < 4 ; i++ )
m[i] = 0.0F ;
}
public void aleatoire() {
for ( int i = 0 ; i < 4 ; i++ )
m[i] =(float) Math.random() ;
}
public String toString() {
return("Vecteur : "+m[0]+" "+m[1]+" "+m[2]+" "+m[3]) ;
}
}
import java.io.Serializable ;
/* ************************************ */
/* Classe matrice 4x4 */
/* ************************************ */
public class Matrice implements Serializable {
public float m[][] = new float[4][4] ;
public void annulle() {
for ( int i = 0 ; i < 4 ; i++ )
for ( int j = 0 ; j < 4 ; j++ )
m[i][j] = 0.0F ;
}
public void identite() {
for ( int i = 0 ; i < 4 ; i++ )
for ( int j = 0 ; j < 4 ; j++ )
m[i][j] = ( i == j ) ? 1.0F : 0.0F ;
}
public void aleatoire() {
for ( int i = 0 ; i < 4 ; i++ )
for ( int j = 0 ; j < 4 ; j++ )
m[i][j] =(float) Math.random() ;
}
public String toString() {
return("Matrice : "+m[0][0]+" "+m[0][1]+" "+m[0][2]+" "+m[0][3]+"\n "+
m[1][0]+" "+m[1][1]+" "+m[1][2]+" "+m[1][3]+"\n "+
m[2][0]+" "+m[2][1]+" "+m[2][2]+" "+m[2][3]+"\n "+
m[3][0]+" "+m[3][1]+" "+m[3][2]+" "+m[3][3]) ;
}
}
Application cliente de la question a.
import java.rmi.* ;
/* ************************************ */
/* Une classe toute simple */
/* pour l'application cliente */
/* ************************************ */
public class ClientEx2v1 {
/* ************************************ */
/* Programme principal */
/* ************************************ */
public static void main(String [] args) {
try {
InterfaceEx2 esclave1 =(InterfaceEx2) Naming.
lookup("Esclave1");
Vecteur v = new Vecteur() ;
Matrice m = new Matrice() ;
v.aleatoire() ;
m.aleatoire() ;
System.out.println(v) ;
System.out.println(m) ;
Vecteur r = esclave1.produitMatriceVecteur(m,v) ;
System.out.println(r) ; }
catch (Exception e) {
System.out.println(e) ; }
}
}
/* ************************************ */
Application cliente de la question b.
import java.rmi.* ;
import java.util.Vector ;
/* ************************************ */
/* Une classe toute simple */
/* pour l'application cliente */
/* ************************************ */
public class ClientEx2v2 {
/* ************************************ */
/* Programme principal */
/* ************************************ */
public static void main(String [] args) {
try {
InterfaceEx2 esclave1 =(InterfaceEx2) Naming.
lookup("Esclave1");
Matrice m = new Matrice() ;
m.aleatoire() ;
System.out.println(m) ;
Vecteur v1 = new Vecteur() ;
v1.aleatoire() ;
Vecteur v2 = new Vecteur() ;
v2.aleatoire() ;
Vecteur v3 = new Vecteur() ;
v3.aleatoire() ;
Vecteur v4 = new Vecteur() ;
v4.aleatoire() ;
System.out.println("Vecteurs initiaux") ;
System.out.println(v1) ;
System.out.println(v2) ;
System.out.println(v3) ;
System.out.println(v4) ;
System.out.println("Apres multiplication:") ;
Vector vec = new Vector() ;
vec.addElement(v1) ;
vec.addElement(v2) ;
vec.addElement(v3) ;
vec.addElement(v4) ;
Vector r = esclave1.produitMatriceVecteurs(m,vec) ;
System.out.println((Vecteur) r.elementAt(0)) ;
System.out.println((Vecteur) r.elementAt(1)) ;
System.out.println((Vecteur) r.elementAt(2)) ;
System.out.println((Vecteur) r.elementAt(3)) ; }
catch (Exception e) {
System.out.println(e) ; }
}
}
/* ************************************ */
Application cliente séquentielle de la question c.
import java.rmi.* ;
import java.util.Vector ;
/* ************************************ */
/* Une classe toute simple */
/* pour l'application cliente */
/* ************************************ */
public class ClientEx2v3 {
/* ************************************ */
/* Programme principal */
/* ************************************ */
public static void main(String [] args) {
int ns = 3 ;
int n = 11 ;
try {
InterfaceEx2 esclaves[] = new InterfaceEx2[ns] ;
for ( int i = 0 ; i < ns ; i++ )
esclaves[i] =(InterfaceEx2) Naming.lookup("Esclave"+(i+1));
Matrice m = new Matrice() ;
m.aleatoire() ;
System.out.println(m) ;
Vecteur vecteurs[] = new Vecteur[n] ;
for ( int i = 0 ; i < n ; i++ ) {
vecteurs[i] = new Vecteur() ;
vecteurs[i].aleatoire() ; }
System.out.println("Vecteurs initiaux") ;
for ( int i = 0 ; i < ns ; i++ ) {
System.out.println(vecteurs[i]) ; }
System.out.println("Apres multiplication:") ;
for ( int i = 0 ; i < ns ; i++ ) {
int d = i * n / ns ;
int nv = ((i+1) * n / ns) - d ;
System.out.println("Esclave "+i+" : "+d+" "+nv) ;
Vector vec = new Vector() ;
for ( int j = d ; j < d+nv ; j++ ) {
vec.addElement(vecteurs[j]) ; }
Vector r = esclaves[i].produitMatriceVecteurs(m,vec) ;
System.out.println(r) ; } }
catch (Exception e) {
System.out.println(e) ; }
}
}
/* ************************************ */
Application cliente parallèle de la question d.
import java.rmi.* ;
import java.util.Vector ;
/* ************************************ */
/* Une classe toute simple */
/* pour l'application cliente */
/* ************************************ */
public class ClientEx2v3v2 {
/* ************************************ */
/* Programme principal */
/* ************************************ */
public static void main(String [] args) {
int ns = 4 ;
int n = 18 ;
try {
InterfaceEx2 esclaves[] = new InterfaceEx2[ns] ;
for ( int i = 0 ; i < ns ; i++ ) {
esclaves[i] =(InterfaceEx2) Naming.
lookup("Esclave"+(i+1)); }
Matrice m = new Matrice() ;
m.aleatoire() ;
System.out.println(m) ;
Vecteur vecteurs[] = new Vecteur[n] ;
for ( int i = 0 ; i < n ; i++ ) {
vecteurs[i] = new Vecteur() ;
vecteurs[i].aleatoire() ; }
System.out.println("Vecteurs initiaux") ;
for ( int i = 0 ; i < ns ; i++ ) {
System.out.println(vecteurs[i]) ; }
System.out.println("Apres multiplication:") ;
ThreadClientEx2 tce[] = new ThreadClientEx2[ns] ;
for ( int i = 0 ; i < ns ; i++ ) {
int d = i * n / ns ;
int nv = ((i+1) * n / ns) - d ;
tce[i] = new ThreadClientEx2(vecteurs,d,nv,esclaves[i],m) ;
System.out.println("Esclave "+i+" : "+d+" "+nv) ; }
for ( int i = 0 ; i < ns ; i++ ) {
tce[i].start() ; }
System.out.println("Debut execution parallele") ;
boolean alive = true ;
while ( alive ) {
alive = false ;
Thread.sleep(100) ;
for ( int i = 0 ; i < ns ; i++ ) {
alive |= tce[i].isAlive() ; } }
System.out.println("Fin execution parallele") ; }
catch (Exception e) {
System.out.println(e) ; }
}
}
/* ************************************ */
import java.rmi.* ;
import java.util.Vector ;
public class ThreadClientEx2 extends Thread {
private InterfaceEx2 esclave ;
private int d ;
private int n ;
private Vecteur vecteurs[] ;
private Matrice matrice ;
private int tempo ;
public ThreadClientEx2(Vecteur [] v,int nd,int nn,InterfaceEx2 esc,Matrice m) {
esclave = esc ;
d = nd ;
n = nn ;
vecteurs = v ;
matrice = m ;
tempo = 2000+(int) (Math.random()*13000) ;
System.out.println(d+" "+tempo) ;
}
public void run() {
try {
Vector vec = new Vector() ;
for ( int j = d ; j < d+n ; j++ ) {
vec.addElement(vecteurs[j]) ; }
Vector r = esclave.produitMatriceVecteurs(matrice,vec) ;
sleep(tempo) ;
System.out.println(d+" "+r) ; }
catch (Exception e) {
System.out.println(e) ; }
}
}
RETOUR