package jaceP2P;
-import java.util.Vector;
+import java.util.ArrayList;
+
public class Backup implements java.io.Serializable {
return taskRank;
}
- public synchronized Vector<Integer> getIterationStep() {
- Vector<Integer> v = new Vector<Integer>();
+ public synchronized ArrayList<Integer> getIterationStep() {
+ ArrayList<Integer> v = new ArrayList<Integer>() ;
v.add(iteration);
v.add(timeStep);
- return v;
+ return v ;
}
public synchronized int getIteration() {
package jaceP2P;
-import java.util.*;
+import java.util.ArrayList;
public class BackupConvg implements java.io.Serializable {
private static final long serialVersionUID = 1L;
public String state;
public boolean underTh;
public int verifNum;
- public Vector<?> resp;
+ public ArrayList<Integer> resp;
public boolean localCV_state;
public int nb_not_recv;
public int sendId;
public String action;
public boolean verdict;
public boolean finalStep;
- public Vector<?> neighbors;
- public Vector<?> neighborsValues;
+ public ArrayList<Integer> neighbors;
+ public ArrayList<Boolean> neighborsValues;
public int timeStep;
public LastSave lastSave;
public int jaceP2P_Iteration;
public boolean recievedVerdict;
- public Vector<?> reduceAll;
+ public ArrayList<Object> reduceAll;
public boolean initialized = false;
public BackupConvg() {
sauv.nb_not_recv = nb_not_recv;
sauv.electedNode = electedNode;
sauv.respSent = respSent;
- sauv.neighbors = (Vector) neighbors.clone();
- sauv.neighborsValues = (Vector) neighborsValues.clone();
- sauv.resp = (Vector) resp.clone();
+ sauv.neighbors = (ArrayList<Integer>) neighbors.clone() ;
+ sauv.neighborsValues = (ArrayList<Boolean>) neighborsValues.clone() ;
+ sauv.resp = (ArrayList<Integer>) resp.clone() ;
sauv.verifNum = verifNum;
sauv.sendId = sendId;
sauv.finalStep = finalStep;
package jaceP2P;
-import java.util.Vector;
+import java.util.ArrayList;
+
public class BackupsManager {
final int MAX_COUNT_NOT_ALIVE = 3;
// attributes
public static BackupsManager Instance;
public int myRank = -1;
- public Vector<Backup> liste = new Vector<Backup>();
- public Vector<Backup> liste_Convg = new Vector<Backup>();
+ public ArrayList<Backup> liste = new ArrayList<Backup>();
+ public ArrayList<Backup> liste_Convg = new ArrayList<Backup>();
// constructors
private BackupsManager() {
int isIn = existBackupTaskOfRank(t.getTaskRank(), tag);
if (isIn == -1) { // si elle y est pas on l'isere
- liste.addElement(t);
+ liste.add( t ) ;
}
int isIn = existBackupTaskOfRank(t.getTaskRank(), tag);
if (isIn == -1) {
- liste_Convg.addElement(t);
+ liste_Convg.add( t ) ;
} else
liste_Convg.set(isIn, t);
}
int ite;
int lastIte = -1;
int lastBackupRank = -1;
- Vector<?> v;
+ ArrayList<Integer> v;
int timeStep;
int lastStep = -1;
boolean ack = false;
int lastBackupRank = -1;
boolean ack = false;
int count;
- Vector<?> v;
+ ArrayList<Integer> v;
int timeStep;
int lastStep = -1;
// ask for ite number of Backups of all my Backup Nodes
import java.rmi.Remote;
import java.rmi.RemoteException;
-import java.util.Vector;
-
+import java.util.ArrayList;
public interface JaceInterface extends Remote {
public int updateRegister(Register newReg, JaceInterface stub, int req)
throws RemoteException;
- public Vector<?> getIterationOfBackup(int remoteRank, int tag)
+ public ArrayList<Integer> getIterationOfBackup(int remoteRank, int tag)
throws RemoteException;
public Backup getRemoteBackup(int remoteRank, int tag)
public void initializeVerif(int tag) throws RemoteException;
public void savOrFinOrRest(int tag, int step, boolean verd,
- Vector<?> reduceAll) throws RemoteException;
+ ArrayList<Object> reduceAll) throws RemoteException;
public boolean setNbNeighboursNotConv(int tag, int idNeigh,
int neighborTimeStep) throws RemoteException;
public int getNbNeighboursNotConv() throws RemoteException;
public void response(int neighId, int tag, int response,
- Vector<?> recievedValue) throws RemoteException;
+ ArrayList<Object> reduceAll) throws RemoteException;
public boolean ping() throws RemoteException;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
+import java.util.ArrayList;
import java.util.Calendar;
import java.util.GregorianCalendar;
-import java.util.Vector;
+
public class JaceServer extends UnicastRemoteObject implements JaceInterface {
}
}
- public Vector<?> getIterationOfBackup(int remoteRank, int tag)
+ public ArrayList<Integer> getIterationOfBackup(int remoteRank, int tag)
throws RemoteException {
Backup b = BackupsManager.Instance().getBackupTaskOfRank(remoteRank,
tag);
- Vector<?> result = b.getIterationStep();
+ ArrayList<Integer> result = b.getIterationStep();
return result;
}
}
public void savOrFinOrRest(int tag, int step, boolean verd,
- Vector<?> recievedValue) throws RemoteException {
+ ArrayList<Object> recievedValue) throws RemoteException {
JaceSession.Instance().getTaskObject().savOrFinOrRest(tag, step, verd,
recievedValue);
}
}
public synchronized void response(int neighId, int tag, int response,
- Vector<?> recievedValue) throws RemoteException {
+ ArrayList<Object> recievedValue) throws RemoteException {
JaceSession.Instance().getTaskObject().response(neighId, tag, response,
recievedValue);
}
import java.rmi.Naming;
import java.rmi.RemoteException;
import java.rmi.UnmarshalException;
+import java.util.ArrayList;
import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.Random;
-import java.util.Vector;
+import java.util.concurrent.Semaphore;
import and.Mapping.Algo;
import and.Mapping.Utils;
private int z = 0;
private static int nbOfDaemonsPerSpawner;
private static int nbOfDeamonsPerThread;
- private Vector<Object> spawnersList;
+ private ArrayList<Object> spawnersList;
private int rank;
private int nbSavingNodes;
private double paramAlgo ;
private String idAlgo ;
+ private Semaphore sema ;
+
// ** Test ** //
private int test;
private double dh ;
nbFault = _nbF ;
faultTime = _fT ;
+ sema = new Semaphore( 1, true ) ;
superNode_IP = superNode;
spawnerPort = port;
idAlgo = _idAlgo ;
+ sema = new Semaphore( 1, true ) ;
+
this.appliName = appliName;
this.nbTasks = nbTasks;
return nbOfDaemonsPerSpawner;
}
- public void startProcess(Vector<Object> spawnersList) {
+ public void startProcess(ArrayList<Object> spawnersList) {
this.spawnersList = spawnersList;
int is = spawnersList.indexOf((Object) Register.Instance()
System.exit( 1 ) ;
}
- public synchronized void signalDeadNode(JaceInterface host, int rankOfDead) {
+ public synchronized void signalDeadNode(JaceInterface host, int rankOfDead )
+ {
+ try {
+ sema.acquire() ;
+ } catch (InterruptedException e3) {
+ System.err.println( "Problem while acquiring the semaphore in signalDeadNode!" ) ;
+ e3.printStackTrace() ;
+ }
- TaskId myTaskId = null;
- int nb = 0;
- int nbC = 0;
- long time = 0;
- RunningApplication.Instance().incrementNumberOfDisconnections();
-
- time = RunningApplication.Instance().getChrono().getValue() / 1000;
- nb = RunningApplication.Instance().getNumberOfDisconnections();
- nbC = RunningApplication.Instance().getNumberOfCouilles();
- System.out.println("At time = " + time + "s, NbDisconnection = "
- + nb + ", NbProblem = " + nbC);
-
- if( host == null )
- System.err.println( "SIGNAL DE NODE NULL" ) ;
-
- // !!!!!!!!!!!!!!actualiser le ListeTask ds le Register
- try {
- myTaskId = Register.Instance().getListeOfTasks()
- .getTaskIdOfHostStub(host);
- } catch( Exception e ) {}
-
- if (myTaskId == null) {
- myTaskId = Register.Instance().getListeOfTasks()
- .getTaskIdOfRank(rankOfDead);
- if( myTaskId == null )
- {
- System.err.println("Houston we have a serious problem!!");
- return ;
- }
-
- JaceInterface deadStub = myTaskId.getHostStub();
+
+ TaskId myTaskId = null;
+ int nb = 0;
+ int nbC = 0;
+ long time = 0;
+ RunningApplication.Instance().incrementNumberOfDisconnections();
+
+ time = RunningApplication.Instance().getChrono().getValue() / 1000;
+ nb = RunningApplication.Instance().getNumberOfDisconnections();
+ nbC = RunningApplication.Instance().getNumberOfProblems();
+ System.out.println( "At time = " + time + "s, NbDisconnection = "
+ + nb + ", NbProblem = " + nbC ) ;
- if( deadStub != null )
- {
- try{
- deadStub.suicide2("Not doing a good work");
- }catch(Exception e){}
- } else {
- System.err.println( "Dead node stub unavailable!" );
- }
- }
-
- Node noeud = Register.Instance().getNodeOfName( myTaskId.getHostName() ) ;
-
- int rankDeaD = myTaskId.getRank();
-
- String nomNoeud = "" ;
+ if( host == null )
+ System.err.println( "Signal of a node null!" ) ;
+
+ // !!!!!!!!!!!!!!actualiser le ListeTask ds le Register
+ try {
+ myTaskId = Register.Instance().getListeOfTasks()
+ .getTaskIdOfHostStub( host ) ;
+ } catch( Exception e ) {}
- if( noeud != null )
+ if (myTaskId == null)
+ {
+ myTaskId = Register.Instance().getListeOfTasks()
+ .getTaskIdOfRank( rankOfDead ) ;
+ if( myTaskId == null )
{
- nomNoeud = noeud.getName();
+ System.err.println( "Houston we have a serious problem!!" ) ;
+ sema.release() ;
+ return ;
}
-
- boolean b = false ;
-
- if( ! nomNoeud.equals( "" ) )
+
+ JaceInterface deadStub = myTaskId.getHostStub() ;
+
+ if( deadStub != null )
{
- b = Register.Instance().removeNodeOfName( nomNoeud ) ;
+ try{
+ deadStub.suicide2( "Not doing a good work" ) ;
+ }catch(Exception e){}
} else {
- System.err.println( "Dead node name unknown!!" ) ;
+ System.err.println( "Dead node stub unavailable!" ) ;
}
+ }
+
+ Node noeud = Register.Instance().getNodeOfName( myTaskId.getHostName() ) ;
+
+ int rankDeaD = myTaskId.getRank() ;
+
+ String nomNoeud = "" ;
+
+ if( noeud != null )
+ {
+ nomNoeud = noeud.getName() ;
+ }
+
+ boolean b = false ;
+
+ if( ! nomNoeud.equals( "" ) )
+ {
+ b = Register.Instance().removeNodeOfName( nomNoeud ) ;
+ } else {
+ System.err.println( "Dead node name unknown!!" ) ;
+ }
- if( ! b )
- {
- b = Register.Instance().removeNode( noeud ) ;
- }
+ if( ! b )
+ {
+ b = Register.Instance().removeNode( noeud ) ;
+ }
- if( b == true )
- {
- System.out.println("Removing Node of rank "
- + rankDeaD + " : size = "
- + Register.Instance().getSize());
- } else {
- System.err
- .println("Cannot remove the Node, it doesn't exist anymore: size = "
- + Register.Instance().getSize());
- }
+ if( b == true )
+ {
+ System.out.println( "Removing Node of rank "
+ + rankDeaD + " : size = "
+ + Register.Instance().getSize() ) ;
+ } else {
+ System.err.println( "Cannot remove the Node, it doesn't exist anymore: size = "
+ + Register.Instance().getSize() ) ;
+ }
- Calendar cal = new GregorianCalendar();
- System.out.println("At time=" + cal.get(Calendar.MINUTE) + ":"
- + cal.get(Calendar.SECOND));
+ Calendar cal = new GregorianCalendar() ;
+ System.out.println( "At time=" + cal.get(Calendar.MINUTE) + ":"
+ + cal.get(Calendar.SECOND) ) ;
- /**** Sébastien Miquée **/
- Node tmpNode = null ;
- int retry = 0, retryMax = 4 ;
+ /**** Sébastien Miquée **/
+ Node tmpNode = null ;
+ boolean ok = false ;
+ int retry = 0, retryMax = 4 ;
+
+ while( tmpNode == null && ! ok )
+ {
+ ok = true ;
while( tmpNode == null )
{
- tmpNode = foundToReplaceThisNode(rankDeaD, nomNoeud, noeud);
+ tmpNode = foundToReplaceThisNode( rankDeaD, nomNoeud, noeud ) ;
if( tmpNode == null )
{
+ System.err.println( "I didn't receive a new Node! (" + retry + ")" ) ;
+
try{
Thread.sleep( 1000 ) ;
} catch( Exception e ) {}
if( retry > retryMax )
{
- System.err.println( "Unable to replace the dead node "+nomNoeud ) ;
+ System.err.println( "Unable to replace the dead node " + nomNoeud ) ;
+ sema.release() ;
return ;
}
}
}
+
+ System.out.println( "Using Node " + tmpNode.getName() + " in order to replace " + nomNoeud + "\n" ) ;
+
+ tmpNode.setAliveFlag( true ) ;
+ tmpNode.setAliveTime() ;
+ tmpNode.setAppliName( RunningApplication.Instance().getName() ) ;
+
+ // Replacing the node in the Register
+ int is = Register.Instance().existNode( tmpNode ) ;
+
+ if( is != -1 )
+ {
+ System.out.println( "The Node is already in the register! I don't add it." ) ;
+ System.out.println( "Node " + tmpNode.getName() + " not added!" ) ;
+ tmpNode = null ;
+ } else {
+ Register.Instance().addNode( tmpNode ) ;
+
+ myTaskId = Register.Instance().getListeOfTasks().getTaskIdOfRank( rankDeaD ) ;
+ myTaskId.setHostIP( tmpNode.getIP() ) ;
+ myTaskId.setHostName( tmpNode.getName() ) ;
+ myTaskId.setHostStub( tmpNode.getStub() ) ;
+
+ int neighborRank ;
+
+ if( rankDeaD == 0 )
+ {
+ neighborRank = Register.Instance().getSize() - 1 ;
+ } else {
+ neighborRank = rankDeaD - 1 ;
+ }
+
+ TaskId neighborTask2 = Register.Instance().getListeOfTasks()
+ .getTaskIdOfRank( neighborRank ) ;
+
+ int loop = 0, MAX_LOOP = 1 ;
+ boolean ook = false ;
+ JaceInterface jaceStub = null ;
+
+ while( !ook && loop < MAX_LOOP )
+ {
+ try {
+ jaceStub = neighborTask2.getHostStub() ;
+ jaceStub.updateHeart( tmpNode.getStub() ) ;
+
+ ook = true ;
+ } catch( Exception e ) {
+ loop++ ;
+
+ if( loop < MAX_LOOP )
+ {
+ try {
+ Thread.sleep( loop * 2000 ) ;
+ } catch( InterruptedException e1 ) {}
+ }
+
+ if( loop == MAX_LOOP )
+ {
+ System.err.println( "Next node unreachable! " + e ) ;
+ }
+ }
+ }
+
+ if( loop == MAX_LOOP && ! ok )
+ {
+
+ try {
+ jaceStub.suicide2( "Not reachable!" ) ;
+ } catch (RemoteException e1) {
+ System.err.println( "Unable to suicide the node!\n"+e1 ) ;
+ }
+
+ try {
+ int pos = Register.Instance().existNodeOfStub( jaceStub ) ;
+
+ if( pos != -1 )
+ {
+ centralServer.delGNodeFromList( Register.Instance().getNodeAt( pos ), 0, LocalHost.Instance().getIP() ) ;
+ } else {
+ System.err.println( "The ping neighbor of " + tmpNode.getName() + " does not respond. It is probably dead ..." ) ;
+ }
+ } catch( RemoteException e ) {
+ System.err.println( "Unable to signal dead node to SuperNode!" ) ;
+ e.printStackTrace() ;
+ }
+ }
+ }
try {
- updateConcernedNodes(rankDeaD, noeud, tmpNode);
+ updateConcernedNodes( rankDeaD, noeud, tmpNode ) ;
- Thread.sleep(500);
- System.out.println("Set scanning on "+tmpNode.getName());
+ Thread.sleep( 500 ) ;
tmpNode.getStub().setScanning( true ) ;
- } catch (Exception e) {
+ System.out.println( "Set scanning on " + tmpNode.getName() ) ;
+ } catch( Exception e ) {
try {
Thread.sleep( 2000 ) ;
tmpNode.getStub().setScanning( true ) ;
- } catch (InterruptedException e1) {
- } catch (RemoteException e2) {
+ } catch( InterruptedException e1 ) {
+ } catch( RemoteException e2 ) {
System.err.println( "Unable to setScanning on for the new node: " + e2 ) ;
+ ok = false ;
}
- System.err.println("Unable to setScanning on for the new node: "
- + e) ;
}
- for (int z = 0; z < spawnersList.size(); z++)
+ for( int z = 0 ; z < spawnersList.size() ; z++ )
{
- if (!((JaceSpawnerInterface) spawnersList.get(z))
- .equals(Register.Instance().getSpawnerStub()))
+ if( !( (JaceSpawnerInterface) spawnersList.get( z ) )
+ .equals(Register.Instance().getSpawnerStub() ) )
{
try {
((JaceSpawnerInterface) spawnersList.get(z))
- .replaceDeamonBy(noeud, tmpNode, rankDeaD);
+ .replaceDeamonBy(noeud, tmpNode, rankDeaD);
} catch (Exception e) {
- System.err
- .println("Unable to broadcast the modifications to all the spawners: "
- + e);
+ System.err.println( "Unable to broadcast the modifications to all the spawners: "
+ + e ) ;
+ ok = false ;
}
}
- }
+ }
+ }
+
+ sema.release() ;
}
// verifie si les noeud notes vivant ds le Register.Instance() du SuperNode
try {
node = null ;
+ if( centralServer == null )
+ {
+ centralServer = LocalHost.Instance().getSuperNodeStub() ;
+
+ if( centralServer == null )
+ {
+ System.err.println( "Connection lost to SuperNode!" ) ;
+ System.err.println( "Reconnecting..." ) ;
+ connectSuperNode() ;
+ }
+ }
+
node = centralServer.getNewNode( idAlgo, theRank ) ;
if( node != null && ! node.getIP().isEmpty() && node.getIP() != null
&& ! node.getIP().equals( "" ) )
{
- found = true ;
+ if( Register.Instance().existNode( node ) != -1 )
+ {
+ found = false ;
+ } else {
+ found = true ;
+ }
} else {
- System.err.println("Returned node is null!");
+ System.err.println( "Returned node is null!" ) ;
nbNull++ ;
try {
Thread.sleep( 2000 ) ;
} catch( Exception e ) {}
}
- } catch (Exception e) {
+ } catch (RemoteException e) {
// trouver un autre superNode et lui demander le noeud a lui
-
- System.err.println("Cannot localize SuperNode ! " + e);
-
- connectSuperNode();
- }
-
- if( Register.Instance().existNode( node ) != -1 )
- {
- found = false ;
+ System.err.println( "Cannot localize SuperNode ! " + e ) ;
+ connectSuperNode() ;
}
}
+ return node ;
- if( node != null )
- {
- System.out.println( "Using Node " + node.getName() + " in order to replace " + nom + "\n" ) ;
-
- node.setAliveFlag(true);
- node.setAliveTime();
-
- // rajouter le noeud ds le Register
- node.setAppliName(RunningApplication.Instance().getName());
-
- // lui envoyer mon stub pr qu'il commence a me pinguer des
- // maintenant
- // TODO a mettre ds un thread ????
-
- /*
- * TaskId
- * neighborTask=Register.Instance().getListeOfTasks().getTaskIdOfRank
- * ((theRank+1)%Register.Instance().getListeOfTasks().getSize());
- * try{ node.getStub().updateHeart(neighborTask.getHostStub()); }
- * catch(Exception e) {
- * System.out.println("nvx noeud deja plu dispo2"); //node = null; }
- */
- // TODO verif pourkoi superNode me le redonne
- // alors qu'il fait deja du calcul
- // int is = Register.Instance().existNode(node.getIP());
- int is = Register.Instance().existNode( node ) ;
+// if( node != null )
+// {
+// System.out.println( "Using Node " + node.getName() + " in order to replace " + nom + "\n" ) ;
+//
+// node.setAliveFlag(true);
+// node.setAliveTime();
+//
+// // rajouter le noeud ds le Register
+// node.setAppliName(RunningApplication.Instance().getName());
+//
+// // lui envoyer mon stub pr qu'il commence a me pinguer des
+// // maintenant
+// // TODO a mettre ds un thread ????
+//
+// /*
+// * TaskId
+// * neighborTask=Register.Instance().getListeOfTasks().getTaskIdOfRank
+// * ((theRank+1)%Register.Instance().getListeOfTasks().getSize());
+// * try{ node.getStub().updateHeart(neighborTask.getHostStub()); }
+// * catch(Exception e) {
+// * System.out.println("nvx noeud deja plu dispo2"); //node = null; }
+// */
+// // TODO verif pourkoi superNode me le redonne
+// // alors qu'il fait deja du calcul
+// // int is = Register.Instance().existNode(node.getIP());
+// int is = Register.Instance().existNode( node ) ;
+//
+// if( is != -1 )
+// {
+// System.out.println("The Node is already in the register ! I don't add it.");
+// System.out.println("Node " + node.getName() + " not added !") ;
+// node = null;
+// } else {
+// Register.Instance().addNode(node);
+//
+// // !!!!!!!!!!!!!!actualiser le ListeTask
+// TaskId myTaskId = Register.Instance().getListeOfTasks()
+// .getTaskIdOfRank(theRank);
+// myTaskId.setHostIP(node.getIP());
+// myTaskId.setHostName(node.getName());
+// myTaskId.setHostStub(node.getStub());
+//
+// int neighborRank;
+// if (theRank == 0)
+// {
+// neighborRank = Register.Instance().getSize() - 1;
+// } else {
+// neighborRank = theRank - 1;
+// }
+//
+// TaskId neighborTask2 = Register.Instance().getListeOfTasks()
+// .getTaskIdOfRank( neighborRank ) ;
+//
+// int loop = 0, MAX_LOOP = 1 ;
+// boolean ok = false ;
+// JaceInterface jaceStub = null ;
+//
+// while( !ok && loop < MAX_LOOP )
+// {
+// try {
+// jaceStub = neighborTask2.getHostStub();
+// jaceStub.updateHeart(node.getStub());
+//
+// ok = true ;
+// } catch( Exception e ) {
+// loop++ ;
+//
+// if( loop < MAX_LOOP )
+// {
+// try {
+// Thread.sleep( loop * 2000 ) ;
+// } catch (InterruptedException e1) {}
+// }
+//
+// if( loop == MAX_LOOP )
+// {
+// System.err.println( "Next node unreachable! " + e ) ;
+// }
+// }
+// }
+//
+// if( loop == MAX_LOOP )
+// {
+//
+// try {
+// node.getStub().suicide2( "Not reachable!" ) ;
+// } catch (RemoteException e1) {
+// System.err.println( "Unable to suicide the node!\n"+e1 ) ;
+// return null ;
+// //signalDeadNode( null, neighborTask2.getRank(), 1 ) ;
+// }
+//
+// try {
+// centralServer.delGNodeFromList( node, 0, LocalHost.Instance().getIP() ) ;
+// } catch( RemoteException e ) {
+// System.err.println( "Unable to signal dead node to SuperNode!" ) ;
+// e.printStackTrace() ;
+// }
+// }
+//
+// }
+//
+// } else {
+// System.out.println( "I didn't receive a new Node !" ) ;
+// }
- if( is != -1 )
- {
- System.out.println("The Node is already in the register ! I don't add it.");
- System.out.println("Node " + node.getName() + " not added !") ;
- node = null;
- } else {
- Register.Instance().addNode(node);
-
- // !!!!!!!!!!!!!!actualiser le ListeTask
- TaskId myTaskId = Register.Instance().getListeOfTasks()
- .getTaskIdOfRank(theRank);
- myTaskId.setHostIP(node.getIP());
- myTaskId.setHostName(node.getName());
- myTaskId.setHostStub(node.getStub());
-
- int neighborRank;
- if (theRank == 0)
- {
- neighborRank = Register.Instance().getSize() - 1;
- } else {
- neighborRank = theRank - 1;
- }
-
- TaskId neighborTask2 = Register.Instance().getListeOfTasks()
- .getTaskIdOfRank( neighborRank ) ;
-
- int loop = 0, MAX_LOOP = 1 ;
- boolean ok = false ;
- JaceInterface jaceStub = null ;
-
- while( !ok && loop < MAX_LOOP )
- {
- try {
- jaceStub = neighborTask2.getHostStub();
- jaceStub.updateHeart(node.getStub());
-
- ok = true ;
- } catch( Exception e ) {
- loop++ ;
-
- if( loop < MAX_LOOP )
- {
- try {
- Thread.sleep( loop * 2000 ) ;
- } catch (InterruptedException e1) {}
- }
-
- if( loop == MAX_LOOP )
- {
- System.err.println( "Next node unreachable! " + e ) ;
- }
- }
- }
-
- if( loop == MAX_LOOP )
- {
-
- try {
- node.getStub().suicide2( "Not reachable!" ) ;
- } catch (RemoteException e1) {
- System.err.println( "Unable to suicide the node!\n"+e1 );
- signalDeadNode( null, neighborTask2.getRank() ) ;
- }
- }
-
- }
-
- } else {
- System.out.println("I didn't receive a new Node !");
- }
- return node;
+// return node ;
}
public void replaceBy(JaceSpawnerInterface oldStub,
JaceSpawnerInterface stub) {
- int index = spawnersList.indexOf((Object) oldStub);
+ int index = spawnersList.indexOf((Object) oldStub) ;
if (index != -1)
- spawnersList.setElementAt(stub, index);
+ spawnersList.set(index, stub ) ;
else
- System.err.println("Spawner's stub not foud in spawnersList !");
+ System.err.println( "Spawner's stub not foud in spawnersList !" ) ;
}
public void getNewSpawner(JaceSpawnerInterface previousSpawner) {
.getNumberOfSpawnerDisconnections(),
nbOfDaemonsPerSpawner, nbOfDeamonsPerThread
, idAlgo);
- spawnersList.setElementAt(spawnerStub, index);
+ spawnersList.set( index, spawnerStub ) ;
new StartProcessThread(index).start();
System.out.println("Application finished successfully !");
System.out.println("TOTAL TIME in s : " + (finalTime / 1000));
- System.out.println("nb of desconnections: " + nbe);
- System.out.println("nb of spawners desconnections: " + nbsdc);
+ System.out.println("Number of node disconnections: " + nbe);
+ System.out.println("Number of spawner disconnections: " + nbsdc);
// ** Tests ** //
- String path = "/home/lyon/smiquee/resultats/execTime_"+algo+"_"+test ;
+ String path = "/home/lyon/smiquee/resultats/execTime_"+algo+"_"+nbFault+"_"+test ;
PrintWriter ecrivain = null ;
ecrivain = new PrintWriter( new OutputStreamWriter( new FileOutputStream( path ), "UTF8" ) ) ;
ecrivain.println( "TOTAL TIME in s : " + (finalTime / 1000));
- ecrivain.println( "nb of desconnections: " + nbe);
- ecrivain.println( "nb of spawners desconnections: " + nbsdc);
+ ecrivain.println( "Number of node disconnections: " + nbe);
+ ecrivain.println( "Number of spawner disconnections: " + nbsdc);
ecrivain.println( "DH = "+dh ) ;
ecrivain.flush() ;
* //si mon appli a besoin d'un noeud //sinon, on fait rien if ((nbTasks
* - Register.Instance().getSize()) > 0) { cptReplaced = 0;
*
- * //TODO demander des paquet de nodes, pas qu'un //on scanne toutes les
+ * //TO DO demander des paquet de nodes, pas qu'un //on scanne toutes les
* taches de cette appli for (int ind = 0; ind < tskList.getSize();
* ind++) { //si 1 tache a pas de noeud, on trouve 1 remplacant
*
// Node node = null;
// // while (found == false) {
// try {
-// // TODO : trouver l'erreur !!!
+// // TO DO : trouver l'erreur !!!
// // msg d'erreur :
// // "pas localise le super node java.lang.NullPointerException"
// if (centralServer == null) {
//
// // lui envoyer mon stub pr qu'il commence a me pinguer des
// // maintenant
-// // TODO a mettre ds un thread ????
+// // TO DO a mettre ds un thread ????
// try {
// TaskId neighborTask = Register.Instance().getListeOfTasks()
// .getTaskIdOfRank(
//
// // int is = Register.Instance().existNode(node.getIP());
// int is = Register.Instance().existNode(node);
-// // TODO verif pourkoi superNode me le redonne
+// // TO DO verif pourkoi superNode me le redonne
// // alors qu'il fait deja du calcul
// if (is != -1) {
// System.out.println("j'ajoute pas le noeud, il y est deja");
// completed with the required number of Daemons
// or gets NULL
public synchronized void getRegisterOnSuperNode() {
- Register registerSpawner = null;
- Node noeud = null;
- boolean recieved = false;
+ Register registerSpawner = null ;
+ Node noeud = null ;
+ boolean recieved = false ;
idAlgo = LocalHost.Instance().getIP() + ":" + LocalHost.Instance().getPort() ;
- System.out.println("Trying to get a Register on the SuperNode");
- int nbExtraSpawners = 0;
+ System.out.println( "Trying to get a Register on the SuperNode" ) ;
+ int nbExtraSpawners = 0 ;
if (nbTasks > nbOfDaemonsPerSpawner) {
- nbExtraSpawners = (nbTasks - 1) / nbOfDaemonsPerSpawner;
+ nbExtraSpawners = (nbTasks - 1) / nbOfDaemonsPerSpawner ;
}
paramAlgo = nbFault ;
}
- while (!recieved) {
+ while( !recieved )
+ {
try {
registerSpawner = centralServer.getRegisterSpawner(idAlgo,
nbTasks, (Task) tache, nbTasks
+ nbExtraSpawners, algo, paramAlgo);
recieved = true;
} catch (Exception e) {
- System.err
- .println("Unable to recieve a register from superNode "
- + e);
- connectSuperNode();
+ System.err.println( "Unable to recieve a register from superNode: " + e ) ;
+ connectSuperNode() ;
}
}
"grid_"+algo+"_"+nbFault+"_"+test+".xml") ;
Utils.writeMapping( al.getMapping(), "/home/lyon/smiquee/resultats/",
"mapping_"+algo+"_"+nbFault+"_"+test+".xml" ) ;
- } catch (RemoteException e1) {
- System.err.println( "Problème avec Algo dans Spawner !" ) ;
- e1.printStackTrace();
+ } catch( RemoteException e1 ) {
+ System.err.println( "Unable to retrieve Algo information in Spawner!" ) ;
+ e1.printStackTrace() ;
}
if (registerSpawner.getSize() != (nbTasks + nbExtraSpawners)) {
System.exit( 1 ) ;
}
- spawnersList = new Vector<Object>();
+ spawnersList = new ArrayList<Object>();
for (int i = 0; i < nbExtraSpawners && i < registerSpawner.getSize(); i++) {
spawnersList.add(registerSpawner.getNodeAt(0));
* nbTasks); } catch(Exception e1) {}
*/
- if (registerSpawner != null) {
- System.out.println("I received the register");
+ if( registerSpawner.getSize() > 0 )
+ {
+ System.out.println( "I received the register" ) ;
// registerSpawner.setVersion(registerVersion);
// registerVersion++;
- Register.Instance().replaceBy(registerSpawner);
- System.out.println("It contains " + Register.Instance().getSize()
- + " Nodes" + " " + nbExtraSpawners + " ExtraSpawners");
+ Register.Instance().replaceBy( registerSpawner ) ;
+ System.out.println( "It contains " + Register.Instance().getSize()
+ + " Nodes" + " " + nbExtraSpawners + " ExtraSpawners" ) ;
// set each Node aliveTime value to the Spawner current time
- for (int i = 0; i < Register.Instance().getSize(); i++) {
- noeud = Register.Instance().getNodeAt(i);
- noeud.setAliveFlag(true);
- noeud.setAliveTime();
+ for (int i = 0; i < Register.Instance().getSize(); i++)
+ {
+ noeud = Register.Instance().getNodeAt( i ) ;
+ noeud.setAliveFlag( true ) ;
+ noeud.setAliveTime() ;
}
} else {
- System.err.println("\n---------------WARNING--------------");
- System.err.println("No Daemon available on the SuperNode dispo, try later, please");
- System.exit(0);
+ System.err.println( "\n---------------WARNING--------------" ) ;
+ System.err.println( "No Daemon available on the SuperNode, try later, please" ) ;
+ System.exit( 0 ) ;
}
}
try {
System.out.println("Trying to transform the spawner ("
+ n.getName() + ") of rank " + i);
- spawnersList.setElementAt(n.getStub().transformIntoSpawner(
+ spawnersList.set( i, n.getStub().transformIntoSpawner(
params, appliName, Register.Instance(), nbTasks,
centralServer, i, heartTime, 0, 0, 0,
- nbOfDaemonsPerSpawner, nbOfDeamonsPerThread, idAlgo), i);
+ nbOfDaemonsPerSpawner, nbOfDeamonsPerThread, idAlgo) ) ;
} catch (Exception e) {
System.err.println("Error while contacting newly acquired spawner ("
+ n.getName() + "): " + e);
Random r = null ;
int next, old = -1 ;
- System.out.println( "Starting fault tolerance !" ) ;
+ System.out.println( "Starting faults simulation!" ) ;
while( ! RunningApplication.Instance().isRunning() )
{
while( RunningApplication.Instance().isRunning() )
{
+ /** Stop too long computation **/
+ if( (RunningApplication.Instance().getChrono().getValue() / 1000) > 700 )
+ {
+ try {
+ Register.Instance().getSpawnerStub().setFinished( true ) ;
+ } catch (RemoteException e) {
+ System.err.println( "Unable to stop the too long computation!" ) ;
+ e.printStackTrace() ;
+ }
+ }
+
/** Waiting some time ... **/
try {
sleep( faultTime * 1000 ) ;
- } catch (InterruptedException e) {
+ } catch( InterruptedException e ) {
}
/** ... and kill some daemons ! **/
- t = Register.Instance().getListeOfTasks();
+ t = Register.Instance().getListeOfTasks() ;
r = new Random() ;
for( int i = 0 ; i < nbFault ; i++ )
}
old = next ;
- Node noeud = null;
+ Node noeud = null ;
try {
- TaskId recev = null;
- System.out.println("Making fault on Task" + next);
+ TaskId recev = null ;
+ System.out.println( "Making fault on Task" + next ) ;
- recev = t.getTaskIdOfRank( next );
+ recev = t.getTaskIdOfRank( next ) ;
- JaceInterface stub = recev.getHostStub();
- System.out.println("name = " + recev.getHostName());
+ JaceInterface stub = recev.getHostStub() ;
+ System.out.println( "name = " + recev.getHostName() ) ;
noeud = Register.Instance().getNodeOfStub( stub ) ;
stub.suicide2( "Test fault tolerance" ) ;
- } catch (UnmarshalException ue ){
- } catch (Exception e) {
+ } catch( UnmarshalException ue ) {
+ } catch( Exception e) {
try {
- System.err.println("Error in FaultMake on node: "
- + noeud.getName() + ". " + e);
+ System.err.println( "Error in FaultMake on node: "
+ + noeud.getName() + ". " + e ) ;
} catch (Exception e2) {
- System.err.println("(Fault)Error in error:" + e2);
+ System.err.println( "(Fault) Error in error:" + e2 ) ;
}
}
try {
sleep( 500 ) ;
- } catch (InterruptedException e) {
+ } catch( InterruptedException e ) {
}
}
}
*/
// System.out.println("start process on spawner of rank "+i);
JaceSpawnerInterface spawnerStub = (JaceSpawnerInterface) spawnersList.get(i);
- spawnerStub.startProcess(spawnersList);
+ spawnerStub.startProcess( spawnersList ) ;
} catch (Exception e) {
e.printStackTrace(System.out);
System.err.println("Unable to start the process on the spawner of rank "
Node n;
int i;
for (i = 0; i < spawnersList.size(); i++) {
- n = (Node) spawnersList.elementAt(i);
+ n = (Node) spawnersList.get( i ) ;
// Register.Instance().getListeOfTasks().viewAll();
// spawnersList.setElementAt(n.getStub().transformIntoSpawner(
for (int j = 0; j < spawnersList.size(); j++) {
System.out.println("waiting till transform of spawner " + j
+ " is finished");
- while ((spawnersList.elementAt(j) instanceof Node))
+ while ((spawnersList.get(j) instanceof Node))
{
try {
for (int j = count; j < nbTasks; j++) {
tsk.addTask(new TaskId(appliName, j, null));
}
- System.out.println("in Register, misses "
+ System.out.println("In Register, misses "
+ (nbTasks - Register.Instance().getSize()) + " nodes");
}
}
}
+ @SuppressWarnings("unchecked")
private synchronized void broadcastScanning() {
Register reg = Register.Instance();
while (broadcasting == true)
} catch (Exception e) {
}
// Register.Instance().viewAll();
- Vector<?> nodes = (Vector<?>) Register.Instance().getListOfNodes().clone();
+ ArrayList<Node> nodes = (ArrayList<Node>) Register.Instance().getListOfNodes().clone();
int x = reg.getListeOfTasks().getSize() / nbOfDaemonsPerSpawner;
int s;
if (rank == x)
}
- @SuppressWarnings("unchecked")
public synchronized Register getRegister( int rank ) {
- ListeTask listOfTasks = Register.Instance().getListeOfTasks();
- Vector dependencies = getDependencies(rank, listOfTasks.getSize());
- Register g = new Register();
- ListeTask newListOfTasks = new ListeTask();
+ ListeTask listOfTasks = Register.Instance().getListeOfTasks() ;
+ ArrayList<Integer> dependencies = getDependencies( rank, listOfTasks.getSize() ) ;
+ Register g = new Register() ;
+ ListeTask newListOfTasks = new ListeTask() ;
- g.setAppliName(Register.Instance().getAppliName());
- g.setParams(Register.Instance().getParams());
- g.setSpawnerStub(Register.Instance().getSpawnerStub());
- g.setNbOfTasks(Register.Instance().getNbOfTasks());
+ g.setAppliName( Register.Instance().getAppliName() ) ;
+ g.setParams( Register.Instance().getParams() ) ;
+ g.setSpawnerStub( Register.Instance().getSpawnerStub() ) ;
+ g.setNbOfTasks( Register.Instance().getNbOfTasks() ) ;
// g.setVersion(reg.getVersion());
- for (int j = 0; j < dependencies.size(); j++) {
- TaskId id = listOfTasks.getTaskIdOfRank(((Integer) dependencies
- .elementAt(j)).intValue());
- newListOfTasks.addTask(id);
- if (id.getHostStub() != null) {
- Node noeud = Register.Instance()
- .getNodeOfName( id.getHostName() ) ;// (id.getHostStub());
+ for( int j = 0 ; j < dependencies.size() ; j++ )
+ {
+ TaskId id = listOfTasks.getTaskIdOfRank( ( (Integer) dependencies
+ .get(j) ).intValue() ) ;
+ newListOfTasks.addTask( id ) ;
+ if( id.getHostStub() != null ) {
+ Node noeud = Register.Instance().getNodeOfName( id.getHostName() ) ;// (id.getHostStub());
if( noeud != null )
+ {
g.addNode( noeud ) ;
- else
+ } else {
System.err.println( "PAS BON DU TOUT" ) ;
+ }
}
}
- g.setListeOfTasks(newListOfTasks);
- return g;
+ g.setListeOfTasks(newListOfTasks) ;
+ return g ;
}
- @SuppressWarnings("unchecked")
private void updateConcernedNodes(int rank, Node oldNode, Node node) {
ListeTask listOfTasks = Register.Instance().getListeOfTasks();
- Vector dependencies = getDependencies(rank, listOfTasks.getSize());
+ ArrayList<Integer> dependencies = getDependencies(rank, listOfTasks.getSize());
System.out.println("List of concerned neighbors of task " + rank+": ");
for (int z = 0; z < dependencies.size(); z++)
- System.out.print(((Integer) dependencies.elementAt(z)).intValue()
+ System.out.print(((Integer) dependencies.get(z)).intValue()
+ " ");
System.out.println();
// Register.Instance().setVersion(registerVersion);
}
}
- private Vector<Integer> getDependencies(int id, int jaceSize) {
+ private ArrayList<Integer> getDependencies( int id, int jaceSize )
+ {
// get computing dependencies
- Vector<Integer> neighbors = new Vector<Integer>();
- int[] dep = tache.getDependencies(id);
- for (int z = 0; z < taille(dep); z++)
- neighbors.add(dep[z]);
+ ArrayList<Integer> neighbors = new ArrayList<Integer>() ;
+ int[] dep = tache.getDependencies( id ) ;
+ for( int z = 0 ; z < taille(dep) ; z++ )
+ {
+ neighbors.add( dep[z] ) ;
+ }
// System.out.println("la liste des voisins de calcul de: "+id+" concerne");
// for(int z=0;z<neighbors.size();z++)
// System.out.print(((Integer)neighbors.elementAt(z)).intValue()+" ");
// System.out.println();
// get convergence neighbors
- int d = 0;
+ int d = 0 ;
while (Math.pow(2, d) < jaceSize) {
if (id < Math.pow(2, d) && ((id + Math.pow(2, d)) < jaceSize))
if (!neighbors.contains((Object) ((int) (id + Math.pow(2, d)))))
neighbors.add(rankOfBackTask);
}
// adds itself
- neighbors.add(id);
- return neighbors;
+ neighbors.add( id ) ;
+ return neighbors ;
}
class StartScanThread extends Thread {
int i, debut;
- Vector<?> nodes;
+ ArrayList<Node> nodes;
int nbOfDeamonsPerThread, nbOfDeamonsPerSpawner;
- StartScanThread(int i, Vector<?> nodes, int debut) {
+ StartScanThread(int i, ArrayList<Node> nodes, int debut) {
this.i = i;
this.nodes = nodes;
this.debut = debut;
&& index < debut + nbOfDeamonsPerSpawner
&& index < nodes.size(); index++) {
- Node node = (Node) nodes.elementAt(index);
+ Node node = (Node) nodes.get(index);
JaceInterface stub = node.getStub();
String name = node.getName();
try {
import java.rmi.Remote;
import java.rmi.RemoteException;
-import java.util.Vector;
+import java.util.ArrayList;
public boolean getFinished() throws RemoteException;
- public void signalDeadNode(JaceInterface host, int rankOfDead)
+ public void signalDeadNode(JaceInterface host, int rankOfDead )
throws RemoteException;
public void beating() throws RemoteException;
public void updateHeart(JaceSpawnerInterface stub) throws RemoteException;
- public void startProcess(Vector<?> spawnersList) throws RemoteException;
+ public void startProcess(ArrayList<Object> spawnersList) throws RemoteException;
public void setOver(boolean bool) throws RemoteException;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
+import java.util.ArrayList;
import java.util.Calendar;
import java.util.GregorianCalendar;
-import java.util.Vector;
public class JaceSpawnerServer extends UnicastRemoteObject implements
super();
}
- @SuppressWarnings("unchecked")
- public void startProcess(Vector spawnersList) throws RemoteException {
+ public void startProcess(ArrayList<Object> spawnersList) throws RemoteException {
JaceSpawner.Instance().startProcess(spawnersList);
}
public boolean getFinished() throws RemoteException {
return finished;
}
+
+ private class Signaler implements Runnable
+ {
+ JaceInterface host ;
+ int rankOfDead ;
+ Signaler( JaceInterface _host, int _rankOfDead )
+ {
+ host = _host ;
+ rankOfDead = _rankOfDead ;
+ }
+
+ @Override
+ public void run()
+ {
+ JaceSpawner.Instance().signalDeadNode( host, rankOfDead ) ;
+ }
+
+ }
- public void signalDeadNode(JaceInterface host, int rankOfDead)
+ public void signalDeadNode(JaceInterface host, int rankOfDead )
throws RemoteException {
- System.out.println("SignalDeadNode of rank " + rankOfDead);
- JaceSpawner.Instance().signalDeadNode(host, rankOfDead);
+ System.out.println( "SignalDeadNode of rank " + rankOfDead ) ;
+
+ new Thread( new Signaler( host, rankOfDead ) ).start() ;
+// JaceSpawner.Instance().signalDeadNode( host, rankOfDead ) ;
}
// heartBeat that detects if a Spawner is dead or alive
next = index + 1;
HeartBeatSNode.Instance().setServer(
((SuperNodeData) SuperNodeListe.Instance().getListe()
- .elementAt(next)).getStub());
+ .get(next)).getStub());
if (index == 0)
previous = SuperNodeListe.Instance().getListe().size() - 1;
else
previous = index - 1;
System.out.println(index + " " + next + " " + previous);
try {
- ((SuperNodeData) SuperNodeListe.Instance().getListe().elementAt(
+ ((SuperNodeData) SuperNodeListe.Instance().getListe().get(
previous)).getStub().updateHeart(
((SuperNodeData) SuperNodeListe.Instance().getListe()
- .elementAt(index)).getStub());
+ .get(index)).getStub());
} catch (Exception e) {
System.err
import java.rmi.Remote;
import java.rmi.RemoteException;
import java.util.ArrayList;
-import java.util.Vector;
import and.Mapping.Algo;
import and.Mapping.GNode;
public Node getNewNode( String spawnerIP, GNode _deadNode ) throws RemoteException;
- public Vector<?> sendStub(String IP, int port, JaceSuperNodeInterface stub)
+ public ArrayList<Object> sendStub(String IP, int port, JaceSuperNodeInterface stub)
throws RemoteException;
public void updateCountNode(String IP, int nb) throws RemoteException;
- public void sendSurplus(Vector<?> nodes, ArrayList<GNode> _gnodes) throws RemoteException;
+ public void sendSurplus(ArrayList<Node> newVector, ArrayList<GNode> _gnodes) throws RemoteException;
public void removeSuperNode(SuperNodeData d) throws RemoteException;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
import java.util.ArrayList;
-import java.util.Vector;
import and.Mapping.Algo;
import and.Mapping.DefaultMapping;
return beat;
}
- public Vector<?> sendStub(String IP, int port, JaceSuperNodeInterface stub)
+ public ArrayList<Object> sendStub(String IP, int port, JaceSuperNodeInterface stub)
throws RemoteException {
SuperNodeListe.Instance().addStubOf(IP, port, stub);
System.out.println("Added new superNode (" + IP
+ ") to list and return List");
- return SuperNodeListe.Instance().getListe();
+ return SuperNodeListe.Instance().getListe() ;
}
public void updateCountNode(String IP, int nb) throws RemoteException {
SuperNodeListe.Instance().viewAll();
}
- public void sendSurplus(Vector<?> nodes, ArrayList<GNode> _gnodes) throws RemoteException {
+ public void sendSurplus(ArrayList<Node> nodes, ArrayList<GNode> _gnodes) throws RemoteException {
System.out.println("Recieved " + nodes.size() + " nodes");
for (int i = 0; i < nodes.size(); i++) {
- Register.Instance().getListe().add((Node) nodes.elementAt(i));
+ Register.Instance().getListe().add((Node) nodes.get(i));
System.out.println("Adding "
- + ((Node) nodes.elementAt(i)).getName());
+ + ((Node) nodes.get(i)).getName());
try {
- ((Node) nodes.elementAt(i)).getStub().updateHeart(
+ ((Node) nodes.get(i)).getStub().updateHeart(
LocalHost.Instance().getSuperNodeStub());
int index = SuperNodeListe.Instance().existSuperNode(
LocalHost.Instance().getIP());
((Maheve) al).setNbSave((int)paramAlgo);
break ;
default:
- al = new DefaultMapping( graph, grid, gnodes ) ;
+ al = new DefaultMapping( graph, grid ) ;
}
if (al != null)
algos.get( i ).getGrid().removeGNode( dead ) ;
Register.Instance().removeNodeOfName( dead.getName() ) ;
SuperNodeListe.Instance().removeGNode( dead, _mode, _spawnerIp ) ;
+
+ // trying to reboot the node
+ try {
+ _n.getStub().suicide2( "Reboot!" ) ;
+ } catch( Exception e ) {
+ System.err.println( "(SN) Unable to reboot the node:" ) ;
+ e.printStackTrace() ;
+ }
}
} else {
System.err.println( "The dead node signaled does not exist!" ) ;
}
return ret ;
- }
-
+ }
}
package jaceP2P;
-import java.util.Vector;
+import java.util.ArrayList;
+
public class ListeTask implements java.io.Serializable, java.lang.Cloneable
{
private static final long serialVersionUID = 1L ;
// attributes
- protected Vector<TaskId> liste = new Vector<TaskId>() ;
+ protected ArrayList<TaskId> liste = new ArrayList<TaskId>() ;
protected TaskId task ;
// constructor
@SuppressWarnings("unchecked")
public synchronized ListeTask clone() {
ListeTask l = new ListeTask();
- l.liste = (Vector<TaskId>) liste.clone();
+ l.liste = (ArrayList<TaskId>) liste.clone();
l.task = task;
return (l);
}
// methods
public synchronized void addTask(TaskId tsk) {
- liste.addElement(tsk);
+ liste.add( tsk ) ;
}
public synchronized TaskId getTaskIdOfHostStub(JaceInterface hostStub) {
if (is != -1) {
return (TaskId) liste.get(is);
} else {
- System.err
- .println("There is no task affected to this host stub !");
+ System.err.println("There is no task affected to this host stub !");
return null;
}
}
package jaceP2P;
-import java.util.Vector;
+import java.util.ArrayList;
+
public class MsgQueue {
public static MsgQueue Instance;
// attributes
- private Vector<Message> liste;
+ private ArrayList<Message> liste;
// constructors
public MsgQueue() {
- liste = new Vector<Message>();
+ liste = new ArrayList<Message>();
}
public synchronized static MsgQueue Instance() {
// si existe deja 1 Message de meme tag ET meme envoyeur, on l'ecrase
if (is != -1) {
// liste.remove(is);
- liste.setElementAt(msg, is);
+ liste.set( is, msg ) ;
}
// si existe pas de Message de meme tag ET meme envoyeur, on l'ajoute
package jaceP2P;
-import java.util.Vector;
+import java.util.ArrayList;
+
public class Register implements java.io.Serializable, java.lang.Cloneable {
// attributes
public static Register Instance;
private String appliName; // name of the appli
- private Vector<Node> liste; // list of the nodes of the Register
+ private ArrayList<Node> liste; // list of the nodes of the Register
// private ListeTask listeOfTasks = null; //liste of the TaskId of the appli
// private int version=0;
private String[] params; // params of the appli
// constructors
public Register() {
- liste = new Vector<Node>();
+ liste = new ArrayList<Node>() ;
}
public synchronized static Register Instance() {
}
public synchronized int existNode(Node node) {
- if (node == null) {
+ if( node == null )
+ {
System.err
.println("Node est null dans existNode");
return -1 ;
}
+
int existe = -1;
int index = 0;
- while ((existe == -1) && (index < liste.size())) {
- if (node.equals((Node) liste.get(index))) {
- existe = index;
- } else
- index++;
+
+ while ((existe == -1) && (index < liste.size()))
+ {
+ if (node.equals((Node) liste.get(index)))
+ {
+ existe = index ;
+ } else {
+ index++ ;
+ }
}
- return existe;
+
+ return existe ;
}
/*
if (is != -1) {
System.out.println("This node exists yet, I replace it");
- liste.setElementAt(host, is);
+ liste.set( is, host ) ;
} else {
- liste.add(host);
+ liste.add( host ) ;
}
return 0 ;
public synchronized void addNodeBeg(Node host) {
int is = -1;
if (host == null) {
- System.err
- .println("In Register.addNode : host.getIP() == null !");
+ System.err.println( "In Register.addNode : host.getIP() == null !" ) ;
}
- is = existNodeOfStub(host.getStub());
+ is = existNodeOfStub( host.getStub() ) ;
if (is != -1) {
- System.out.println("This node exists yet, I replace it");
+ System.out.println( "This node exists yet, I replace it" ) ;
// System.out.println("MERDE !!");
// System.out.println("MERDE !!");
// System.out.println("MERDE !!");
// System.out.println("MERDE !!");
// System.out.println("MERDE !!");
// System.out.println("MERDE !!");
- liste.setElementAt(host, is);
+ liste.set( is, host ) ;
} else {
- liste.add(0,host);
+ liste.add( 0, host ) ;
}
}
return liste.size();
}
- public synchronized Vector<Node> getListe() {
+ public synchronized ArrayList<Node> getListe() {
return liste;
}
public synchronized void purge() {
for (int i = 0; i < liste.size(); i++)
- if (((Node) liste.elementAt(i)).getOutputStream() != null) {
+ if (((Node) liste.get(i)).getOutputStream() != null) {
try {
- ((Node) liste.elementAt(i)).getOutputStream().close();
+ ((Node) liste.get(i)).getOutputStream().close();
} catch (Exception e) {
System.err.println("Unable to close outputStream :" + e);
}
return params;
}
- public synchronized Vector<Node> getListOfNodes() {
+ public synchronized ArrayList<Node> getListOfNodes() {
return liste;
}
private int numberOfSpawnerDisconnections = 0; // nb de deconnection de
// spawners depuis debut
// appli
- private int numberOfCouilles = 0; // nb de deconnection depuis debut appli
+ private int numberOfProblems = 0; // nb de deconnection depuis debut appli
private int numberOfSuicides = 0; // nb de deconnection depuis debut appli
private RunningApplication() {
return name;
}
- public synchronized int getNumberOfCouilles() {
- return numberOfCouilles;
+ public synchronized int getNumberOfProblems() {
+ return numberOfProblems;
}
public synchronized void setNbTasks(int nb) {
numberOfSpawnerDisconnections = nb;
}
- public synchronized void incrementNumberOfCouille() {
- numberOfCouilles++;
+ public synchronized void incrementNumberOfProblems() {
+ numberOfProblems++;
}
public synchronized void incrementNumberOfSuicides() {
if (spawnerStub == null)
System.err.println("SpawnerStub is null");
try {
- spawnerStub.signalDeadNode(jaceStub, neighborRank);
+ spawnerStub.signalDeadNode( jaceStub, neighborRank ) ;
Thread.sleep(10 * beat);
synchronized (SuperNodeListe.Instance()) {
System.out.println("Removing "
+ ((SuperNodeData) SuperNodeListe.Instance()
- .getListe().elementAt(index)).getIP());
+ .getListe().get(index)).getIP());
data = (SuperNodeData) SuperNodeListe.Instance().getListe()
- .elementAt(index);
+ .get(index);
SuperNodeListe.Instance().removeSuperNode(
((SuperNodeData) SuperNodeListe.Instance()
- .getListe().elementAt(index)));
+ .getListe().get(index)));
}
// diffusing the message concerning a dead superNode
for (int i = 0; i < SuperNodeListe.Instance().getListe().size(); i++)
try {
if (!((SuperNodeData) SuperNodeListe.Instance()
- .getListe().elementAt(i)).getIP().equals(
+ .getListe().get(i)).getIP().equals(
LocalHost.Instance().getIP()))
((SuperNodeData) SuperNodeListe.Instance()
- .getListe().elementAt(i)).getStub()
+ .getListe().get(i)).getStub()
.removeSuperNode(data);
} catch (Exception e2) {
System.err
else
index = SuperNodeListe.Instance().getListe().size() - 1;
((SuperNodeData) SuperNodeListe.Instance().getListe()
- .elementAt(index)).getStub().updateHeart(
+ .get(index)).getStub().updateHeart(
LocalHost.Instance().getSuperNodeStub());
}
import java.io.InputStream;
import java.io.InputStreamReader;
import java.rmi.Naming;
+import java.util.ArrayList;
import java.util.Random;
-import java.util.Vector;
import and.Mapping.Algo;
import and.Mapping.GNode;
// attributes
public static SuperNodeListe Instance;
private Random r;
- @SuppressWarnings("unchecked")
- private Vector liste = null;
+ private ArrayList<Object> liste = null;
// constructors
- @SuppressWarnings("unchecked")
public SuperNodeListe() {
- liste = new Vector();
+ liste = new ArrayList<Object>() ;
r = new Random();
}
}
return Instance;
}
-
+
@SuppressWarnings("unchecked")
public synchronized SuperNodeListe clone() {
SuperNodeListe d = new SuperNodeListe();
// d.r = (Random) r.clone();
- d.liste = (Vector) liste.clone();
- return d;
+ d.liste = (ArrayList<Object>) liste.clone() ;
+ return d ;
}
// methods
// in order to discover new superNodes dynamicaly
/* Sébastien Miquée -- ajout de la lecture du fichier de config **/
-
- @SuppressWarnings("unchecked")
public void staticInitialization() {
String adr = "";
String home = System.getProperty("user.home");
// donnees ds un fichier de conf
}
- @SuppressWarnings("unchecked")
- public Vector getListe() {
+
+ public ArrayList<Object> getListe() {
return liste;
}
if (index < 0) {
index = -index;
}
- return (SuperNodeData) liste.elementAt(index);
+ return (SuperNodeData) liste.get(index);
}
public SuperNodeData getSuperNodeData(int i) {
- return (SuperNodeData) liste.elementAt(i);
+ return (SuperNodeData) liste.get(i);
}
// if returns 0, there are no nodes at all
SuperNodeData return_d = null;
for (int i = 0; i < liste.size(); i++) {
- d = (SuperNodeData) liste.elementAt(i);
+ d = (SuperNodeData) liste.get(i);
if (d.getNbOfNodes() > max) {
max = d.getNbOfNodes();
- return_d = (SuperNodeData) liste.elementAt(i);
+ return_d = (SuperNodeData) liste.get(i);
}
}
return return_d;
}
public void addStub(int index, JaceSuperNodeInterface stub) {
- ((SuperNodeData) liste.elementAt(index)).setStub(stub);
+ ((SuperNodeData) liste.get(index)).setStub(stub);
}
- @SuppressWarnings("unchecked")
public void addStubOf(String snode, int port, JaceSuperNodeInterface stub) {
int is = -1;
is = existSuperNode(snode);
if (is != -1) {
- ((SuperNodeData) liste.elementAt(is)).setStub(stub);
+ ((SuperNodeData) liste.get(is)).setStub(stub);
} else {
System.err.println("This superNode does not exist : " + snode);
System.out.println("Add the new SuperNode");
JaceSuperNodeInterface remoteStub = null;
for (int i = 0; i < liste.size(); i++) {
- d = (SuperNodeData) liste.elementAt(i);
+ d = (SuperNodeData) liste.get(i);
if (!d.getIP().equals(LocalHost.Instance().getIP())) {
// if not me, I inform the other super nodes
remoteStub = d.getStub();
int is = -1;
is = existSuperNode(IP);
if (is != -1) {
- SuperNodeData d = (SuperNodeData) liste.elementAt(is);
+ SuperNodeData d = (SuperNodeData) liste.get(is);
d.setNbOfNodes(nb);
} else {
System.err.println("This SuperNode does not exists in my list: " + IP);
}
}
- @SuppressWarnings("unchecked")
public void locateSuperNodes(JaceSuperNodeInterface stub) {
String remoteIP;
int remotePort;
boolean inStaticList = false;
while (i < liste.size() && !connected) {
remoteIP = LocalHost.Instance().resolve(
- ((SuperNodeData) liste.elementAt(i)).getIP());
- remotePort = ((SuperNodeData) liste.elementAt(i)).getPort();
+ ((SuperNodeData) liste.get(i)).getIP());
+ remotePort = ((SuperNodeData) liste.get(i)).getPort();
// If I'm not this superNode, I locate the others
if (!remoteIP.equals(LocalHost.Instance().getIP())) {
// SuperNodeListe.Instance().addStub(i, remoteStub);
// Send my stub to this corresponding remote SuperNode
- liste = (Vector<?>) remoteStub.sendStub(LocalHost.Instance()
+ liste = (ArrayList<Object>) remoteStub.sendStub(LocalHost.Instance()
.getIP(), LocalHost.Instance().getPort(), stub);
System.out.println("Recieved List");
connected = true;
// get the nb of Daemons the remote SuperNode has already
// registered
// nb = remoteStub.getNbOfNodes();
- // ((SuperNodeData)liste.elementAt(i)).setNbOfNodes(nb);
+ // ((SuperNodeData)liste.get(i)).setNbOfNodes(nb);
// System.out.println("bien envoye mon stub a " + remoteIP);
System.out.println("size:" + liste.size());
}
- @SuppressWarnings("unchecked")
public void addSuperNode(SuperNodeData d) {
int is = -1;
String name = d.getIP();
is = existSuperNode(name);
if (is != -1) {
- liste.setElementAt(d, is);
+ liste.set( is, d ) ;
} else {
liste.add(d);
}
System.out.println("\nConfig of the superNodes :");
String msg = "";
for (int i = 0; i < liste.size(); i++) {
- SuperNodeData d = (SuperNodeData) liste.elementAt(i);
+ SuperNodeData d = (SuperNodeData) liste.get(i);
if (d.getIP().equals(LocalHost.Instance().getIP())) {
msg = "me : " + Register.Instance().getSize();
} else {
System.out.println(d.getIP() + " : "
- + ((SuperNodeData) liste.elementAt(i)).getNbOfNodes());
+ + ((SuperNodeData) liste.get(i)).getNbOfNodes());
}
}
System.out.println(msg);
for( int i = 0 ; i < liste.size() ; i++ )
{
- d = (SuperNodeData) liste.elementAt( i ) ;
+ d = (SuperNodeData) liste.get( i ) ;
if( ! d.getIP().equals(LocalHost.Instance().getIP() ) )
{
// if not me, I inform the other super nodes
for( int i = 0 ; i < liste.size() ; i++ )
{
- d = (SuperNodeData) liste.elementAt( i ) ;
+ d = (SuperNodeData) liste.get( i ) ;
if( ! d.getIP().equals(LocalHost.Instance().getIP() ) )
{
// if not me, I inform the other super nodes
for( int i = 0 ; i < liste.size() ; i++ )
{
- d = (SuperNodeData) liste.elementAt( i ) ;
+ d = (SuperNodeData) liste.get( i ) ;
if( ! d.getIP().equals(LocalHost.Instance().getIP() ) )
{
// if not me, I inform the other super nodes
for( int i = 0 ; i < liste.size() ; i++ )
{
- d = (SuperNodeData) liste.elementAt( i ) ;
+ d = (SuperNodeData) liste.get( i ) ;
if( ! d.getIP().equals(LocalHost.Instance().getIP() ) )
{
// if not me, I inform the other super nodes
for( int i = 0 ; i < liste.size() ; i++ )
{
- d = (SuperNodeData) liste.elementAt( i ) ;
+ d = (SuperNodeData) liste.get( i ) ;
if( ! d.getIP().equals(LocalHost.Instance().getIP() ) )
{
// if not me, I inform the other super nodes
for( int i = 0 ; i < liste.size() ; i++ )
{
- d = (SuperNodeData) liste.elementAt( i ) ;
+ d = (SuperNodeData) liste.get( i ) ;
if( ! d.getIP().equals(LocalHost.Instance().getIP() ) )
{
// if not me, I inform the other super nodes
for( int i = 0 ; i < liste.size() ; i++ )
{
- d = (SuperNodeData) liste.elementAt( i ) ;
+ d = (SuperNodeData) liste.get( i ) ;
if( ! d.getIP().equals( LocalHost.Instance().getIP() ) )
{
// if not me, I inform the other super nodes
for( int i = 0 ; i < liste.size() ; i++ )
{
- d = (SuperNodeData) liste.elementAt( i ) ;
+ d = (SuperNodeData) liste.get( i ) ;
if( ! d.getIP().equals( LocalHost.Instance().getIP() ) )
{
// if not me, I inform the other super nodes
import java.io.ObjectOutputStream;
import java.rmi.ConnectException;
import java.rmi.RemoteException;
-import java.util.Vector;
+import java.util.ArrayList;
//import java.util.Calendar;
//import java.util.GregorianCalendar;
public int nb_not_recv;
public boolean electedNode = false;
public boolean respSent = false;
- public Vector<Integer> resp;
+ public ArrayList<Integer> resp;
public int verifNum = 0;
public LastSave lastSave = new LastSave();
- public Vector<Integer> neighbors;
- public Vector<Boolean> neighborsValues;
- public Vector<Integer> dependancies;
- public Vector<Boolean> values;
+ public ArrayList<Integer> neighbors;
+ public ArrayList<Boolean> neighborsValues;
+ public ArrayList<Integer> dependancies;
+ public ArrayList<Boolean> values;
public int sendId;
public String action = "nothing";
public boolean verdict = false;
public Task sauv;
public BackupConvg sauvConvg = new BackupConvg();
public boolean postReloading = false;
- @SuppressWarnings("unchecked")
- public Vector reduceAll;
+ public ArrayList<Object> reduceAll;
int cpt = 0;
int count = 0;
Thread th;
public Task() {
- reduceAll = new Vector<Object>();
- dependancies = new Vector<Integer>();
- values = new Vector<Boolean>();
- resp = new Vector<Integer>();
+ reduceAll = new ArrayList<Object>();
+ dependancies = new ArrayList<Integer>();
+ values = new ArrayList<Boolean>();
+ resp = new ArrayList<Integer>();
saved = new boolean[2];
sauv = this;
- neighbors = new Vector<Integer>();
- neighborsValues = new Vector<Boolean>();
+ neighbors = new ArrayList<Integer>();
+ neighborsValues = new ArrayList<Boolean>();
}
public void getBackupForNewNode(int rank) {
}
// method to overload by user in the appli to specify the reduceAll method
- public synchronized void reduceAll(Vector<?> recievedValue) {
+ public synchronized void reduceAll(ArrayList<Object> recievedValue) {
}
public void setId(TaskId Id) {
}
public void reinitializeVectors() throws RemoteException {
- values.removeAllElements();
- dependancies.removeAllElements();
- neighbors.removeAllElements();
- neighborsValues.removeAllElements();
- resp.removeAllElements();
+ values.clear() ;
+ dependancies.clear() ;
+ neighbors.clear() ;
+ neighborsValues.clear() ;
+ resp.clear() ;
}
public long jaceP2P_getChronoValue() {
}
public void setValues(int index, boolean value) {
- values.setElementAt(new Boolean(value), index);
+ values.set( index, new Boolean(value) ) ;
}
@SuppressWarnings("static-access")
sauv.nb_not_recv = nb_not_recv;
sauv.electedNode = electedNode;
sauv.respSent = respSent;
- sauv.neighbors = (Vector) neighbors.clone();
- sauv.neighborsValues = (Vector) neighborsValues.clone();
- sauv.resp = (Vector) resp.clone();
+ sauv.neighbors = (ArrayList<Integer>) neighbors.clone();
+ sauv.neighborsValues = (ArrayList<Boolean>) neighborsValues.clone();
+ sauv.resp = (ArrayList<Integer>) resp.clone();
sauv.verifNum = verifNum;
sauv.sendId = sendId;
sauv.reduceAll = reduceAll;
sauvConvg.nb_not_recv = nb_not_recv;
sauvConvg.electedNode = electedNode;
sauvConvg.respSent = respSent;
- sauvConvg.neighbors = (Vector) neighbors.clone();
- sauvConvg.neighborsValues = (Vector) neighborsValues.clone();
- sauvConvg.resp = (Vector) resp.clone();
+ sauvConvg.neighbors = (ArrayList<Integer>) neighbors.clone();
+ sauvConvg.neighborsValues = (ArrayList<Boolean>) neighborsValues.clone();
+ sauvConvg.resp = (ArrayList<Integer>) resp.clone();
sauvConvg.verifNum = verifNum;
sauvConvg.sendId = sendId;
sauvConvg.finalStep = finalStep;
}
public synchronized void response(int neighId, int tag, int response,
- Vector<?> recievedValue) throws RemoteException {
+ ArrayList<Object> recievedValue) throws RemoteException {
// System.out.println("inside response function");
// System.out.println("sleeping till not reloading");
while (reloading == true) {
if (response == 1
&& !state.equals("SAVING")
- && (((Integer) (resp.elementAt(indexNeigh))).intValue()) != 1) {
+ && (((Integer) (resp.get(indexNeigh))).intValue()) != 1) {
// System.out.println("calling reduceAll()");
reduceAll(recievedValue);
}
// System.out.println("after calculating reduceAll");
- resp.setElementAt(response, indexNeigh);
+ resp.set( indexNeigh, response ) ;
// System.out.println("get response ............");
waitForAck(3);
public void initializeSavLeader() {
for (int i = 0; i < resp.size(); i++)
- resp.setElementAt(0, i);
- respSent = false;
+ resp.set( i, 0 ) ;
+ respSent = false ;
}
public boolean recievedAllResp() {
if (((Boolean) neighborsValues.get(i)).booleanValue() == false) {
nb_not_recv--;
// System.out.println("le noeud "+idNeigh+" a envoyer un message de pseudoconvergence");
- neighborsValues.setElementAt(new Boolean(true), i);
+ neighborsValues.set( i, new Boolean(true) ) ;
waitForAck(3);
}
nb_not_recv = neighbors.size();
for (int i = 0; i < neighbors.size(); i++)
- neighborsValues.setElementAt(new Boolean(false), i);
+ neighborsValues.set( i, new Boolean(false) ) ;
for (int i = 0; i < resp.size(); i++)
- resp.setElementAt(0, i);
+ resp.set( i, 0 ) ;
underTh = false;
electedNode = false;
localCV_state = false;
int neighId = -1;
for (int i = 0; i < neighbors.size(); i++)
if (((Boolean) neighborsValues.get(i)).booleanValue() == false)
- neighId = ((Integer) neighbors.elementAt(i)).intValue();
+ neighId = ((Integer) neighbors.get(i)).intValue();
return neighId;
}
public boolean getValues() {
boolean bool = true;
for (int i = 0; i < values.size(); i++)
- if (((Boolean) values.elementAt(i)).equals(new Boolean(false))) {
+ if (((Boolean) values.get(i)).equals(new Boolean(false))) {
bool = false;
break;
}
public void initializeVerifLeader() throws RemoteException {
reinitializePPEr();
for (int i = 0; i < resp.size(); i++)
- resp.setElementAt(0, i);
+ resp.set( i, 0 ) ;
verifNum++;
respSent = false;
}
action = "sendVerif";
reinitializePPEr();
for (int i = 0; i < resp.size(); i++)
- resp.setElementAt(0, i);
+ resp.set( i, 0 ) ;
verifNum++;
respSent = false;
pseudoPerBeg = false;
pseudoPerEnd = false;
for (int i = 0; i < values.size(); i++)
- values.setElementAt(new Boolean(false), i);
+ values.set( i, new Boolean(false) ) ;
}
}
public void savOrFinOrRest(int tag, int step, boolean verd,
- Vector<?> reduceAll) {
+ ArrayList<Object> reduceAll) {
// System.out.println("Recieved verd "+verd+" sleeping till not reloading");
while (reloading == true) {
try {
action = "sendVerdict";
if (finalStep == true) {
for (int i = 0; i < resp.size(); i++)
- resp.setElementAt(0, i);
+ resp.set( i, 0 ) ;
// System.out.println("sleeping till response is sent");
while (action.equals("sendResponse") || respSent == false)
try {
import java.io.ByteArrayInputStream;
import java.io.ObjectInputStream;
-import java.util.Vector;
+import java.util.ArrayList;
tsk.electedNode = tskConvg.electedNode;
tsk.respSent = tskConvg.respSent;
// System.out.println("avant la copie des vecteurs");
- tsk.neighbors = (Vector) (tskConvg.neighbors)
- .clone();
+ tsk.neighbors = tskConvg.neighbors ;
+ tsk.neighborsValues = tskConvg.neighborsValues ;
- tsk.neighborsValues = (Vector) (tskConvg.neighborsValues)
- .clone();
if (bConvg.getIteration() >= b.getIteration())
- tsk.reduceAll = (Vector) (tskConvg.reduceAll)
- .clone();
- tsk.resp = (Vector) (tskConvg.resp).clone();
+ tsk.reduceAll = tskConvg.reduceAll ;
+ tsk.resp = (ArrayList<Integer>) (tskConvg.resp).clone() ;
// System.out.println("apres la copie des vecteurs");
tsk.underTh = tskConvg.underTh;
tsk.verifNum = tskConvg.verifNum;
import java.rmi.RemoteException;
import java.util.ArrayList;
-import java.util.Vector;
import and.Mapping.*;
public class TokenThread extends Thread {
// System.out.println("finished set token");
}
- @SuppressWarnings("unchecked")
+
public void distribute() {
System.out.println("totalDaemons="
+ SuperNodeListe.Instance().getTotalDaemons());
int nbLocal = Register.Instance().getSize();
int totalDaemons;
- Vector liste = SuperNodeListe.Instance().getListe();
+ ArrayList<Object> liste = SuperNodeListe.Instance().getListe();
/******* Sébastien Miquée ********/
ArrayList<GNode> gnodes = null ;
if (((SuperNodeData) liste.get(i)).getNbOfNodes() < nbDaemons)
try {
// System.out.println("Snode="+i+" nodes="+((SuperNodeData)liste.get(i)).getNbOfNodes());
- Vector nodes = Register.Instance()
+ ArrayList<Node> nodes = Register.Instance()
.getListe();
int amountToSend = nbDaemons
- ((SuperNodeData) liste.get(i))
.getNbOfNodes();
- Vector newVector = new Vector();
+ ArrayList<Node> newVector = new ArrayList<Node>() ;
for (int j = 0; j < amountToSend; j++) {
- newVector.add(nodes.elementAt(j));
+ newVector.add(nodes.get(j));
}
((SuperNodeData) liste.get(i)).getStub()
.sendSurplus(newVector, gnodes);
index = (index + 1) % SuperNodeListe.Instance().getListe().size();
// System.out.println("index="+index);
try {
- ((SuperNodeData) liste.elementAt(index)).getStub().setToken();
+ ((SuperNodeData) liste.get(index)).getStub().setToken();
if (index != SuperNodeListe.Instance().existSuperNode(
LocalHost.Instance().getIP()))
token = false;
} catch (Exception e) {
try {
System.err.println("Unable to send Token to "
- + ((SuperNodeData) liste.elementAt(index)).getIP()
+ + ((SuperNodeData) liste.get(index)).getIP()
+ " :" + e);
/*
* SuperNodeListe.Instance().removeSuperNode(((SuperNodeData)
package jaceP2P;
-import java.util.Vector;
+import java.util.ArrayList;
+//import java.util.Vector;
class UpdateRegisterConcernedThread extends Thread {
Register reg = null;
int requete;
int i, rank;
Task tache = null;
- @SuppressWarnings("unchecked")
- Vector neighbors;
+ ArrayList<Integer> neighbors;
int nbOfDeamonsPerThread;
Node oldNode, node;
- @SuppressWarnings("unchecked")
- public UpdateRegisterConcernedThread(Vector neighbors, Register r, int i,
+
+ public UpdateRegisterConcernedThread(ArrayList<Integer> neighbors, Register r, int i,
int rank, Node noeud, Node tmpNode) {
this.reg = r;
// while( retry )
// {
try {
- if (((Integer) neighbors.elementAt(index)).intValue() == rank) {
+ if (((Integer) neighbors.get(index)).intValue() == rank) {
Register g = new Register();
ListeTask newListOfTasks = new ListeTask();
g.setAppliName(reg.getAppliName());
for (int j = 0; j < neighbors.size(); j++) {
TaskId id = listOfTasks
.getTaskIdOfRank(((Integer) neighbors
- .elementAt(j)).intValue()) ;
+ .get(j)).intValue()) ;
newListOfTasks.addTask( id ) ;
if( id.getHostStub() != null ) {
Node noeud = reg.getNodeOfStub( id.getHostStub() ) ;
TaskId neighborTask = listOfTasks
.getTaskIdOfRank((((Integer) neighbors
- .elementAt(index)).intValue() + 1)
+ .get(index)).intValue() + 1)
% listOfTasks.getSize());
JaceInterface stubVoisin = neighborTask.getHostStub();
JaceInterface stub = listOfTasks.getTaskIdOfRank(
- ((Integer) neighbors.elementAt(index)).intValue())
+ ((Integer) neighbors.get(index)).intValue())
.getHostStub();
if( stub == null || stubVoisin == null )
{
System.out.println("stub NULL");
} else {
name = listOfTasks.getTaskIdOfRank(
- ((Integer) neighbors.elementAt(index))
+ ((Integer) neighbors.get(index))
.intValue()).getHostName();
Node noeud = null ;
//int tag;
TaskId id = listOfTasks
.getTaskIdOfRank(((Integer) neighbors
- .elementAt(index)).intValue());
+ .get(index)).intValue());
name = id.getHostName();
try {
}
@SuppressWarnings("unused")
- private Vector<Integer> getDependencies(int id, int jaceSize) {
+ private ArrayList<Integer> getDependencies(int id, int jaceSize) {
// get computing dependencies
- Vector<Integer> neighbors = new Vector<Integer>();
+ ArrayList<Integer> neighbors = new ArrayList<Integer>();
int[] dep = tache.getDependencies(id);
for (int z = 0; z < taille(dep); z++)
neighbors.add(dep[z]);
neighbors.add(rankOfBackTask);
}
// adds itself
- neighbors.add(id);
- return neighbors;
-
+ neighbors.add( id ) ;
+
+ return neighbors ;
}
public static int taille(int[] vect) {
package jaceP2P;
-import java.util.Vector;
+import java.util.ArrayList;
class UpdateRegisterThread extends Thread {
// Register reg = Register.Instance();
// Node node = Register.Instance().getNodeAt(index);
// Node node = reg.getNodeAt(index);
// Node voisin=reg.getNodeAt((index+1)%reg.getSize());
- Vector<Integer> dependencies = getDependencies(index, listOfTasks.getSize());
+ ArrayList<Integer> dependencies = getDependencies(index, listOfTasks.getSize());
// System.out.println("la liste des voisins de : "+index);
// for(int z=0;z<dependencies.size();z++)
// System.out.print(((Integer)dependencies.elementAt(z)).intValue()+" ");
// g.setVersion(reg.getVersion());
for (int j = 0; j < dependencies.size(); j++) {
TaskId id = listOfTasks.getTaskIdOfRank(((Integer) dependencies
- .elementAt(j)).intValue());
+ .get(j)).intValue());
// System.out.println("got id of :"+((Integer)dependencies.elementAt(j)).intValue());
newListOfTasks.addTask(id);
if (id.getHostStub() != null) {
}
- private Vector<Integer> getDependencies(int id, int jaceSize) {
+ private ArrayList<Integer> getDependencies(int id, int jaceSize) {
// get computing dependencies
- Vector<Integer> neighbors = new Vector<Integer>();
+ ArrayList<Integer> neighbors = new ArrayList<Integer>();
int[] dep = null;
// try{
// if(tache==null)
