Changeset 28 for branches/multithread/src/planet/generic/commonapi/MultiThreadedNetworkImpl.java

Timestamp:

10/02/07 12:49:26 (1 year ago)

Author:

max

Message:

 

Files:

• branches/multithread/src/planet/generic/commonapi/MultiThreadedNetworkImpl.java (modified) (8 diffs)

branches/multithread/src/planet/generic/commonapi/MultiThreadedNetworkImpl.java

@@ -61 +61 @@
      * Containts all nodes to remove from the network.
      */
-    private Stack toRemove;
+    private Stack<NodeHandle> toRemove;
     /**
      * NodeFactory implementation which permits build new nodes.
@@ -80 +80 @@
 
     private final int PROCESSORS;
+    private final Thread[] threads;
+    private final ProcessGroup[] processGroups;
+//    private final Boolean[] continues;
     /**
      * Initialize the network with no nodes and wihtout simulation steps.
@@ -85 +88 @@
     public MultiThreadedNetworkImpl() {
         PROCESSORS = Properties.simulatorProcessors;
+        threads = new Thread[PROCESSORS];
+        processGroups = new ProcessGroup[PROCESSORS];
+        for (int i = 0; i < processGroups.length; i++) {
+                        processGroups[i] = new ProcessGroup();
+                }
+//      continues = new Boolean[PROCESSORS];
         nodes = new HashMap<NodeHandle, Node>();    //to contain all nodes
         toRemove = new Stack<NodeHandle>();
@@ -553 +562 @@
     
         
-        Thread[] threads = new Thread[PROCESSORS];
+        
         Node[] nodes = new Node[this.nodes.size()];
         nodes = this.nodes.values().toArray(nodes);
-        Boolean[] continues = new Boolean[PROCESSORS];
-        //init continues
-        for (int i = 0; i < continues.length; i++) {
-                        continues[i] = false;
-        }
+        
+
 
         
@@ -568 +574 @@
                         
                         int from = i*groupSize;
+                        
                         //if it is the last thread it gets all remaining nodes, i.e. 7 nodes and two processors groupA {0..2} and groupB {3..6}
-                        int to = i==threads.length-1 ? nodes.length : from+groupSize; 
-                        ProcessGroup group = new ProcessGroup(nodes,from,to,continues,i);
-                        Thread thread = new Thread(group);
-                        threads[i] = thread;
+                        int to = i==threads.length-1 ? nodes.length : from+groupSize;
+                        
+                        //ProcessGroup group = new ProcessGroup(nodes,from,to,continues,i);
+                        processGroups[i].setFrom(from);
+                        processGroups[i].setTo(to);
+                        processGroups[i].setNodes(nodes);
+                        threads[i] = new Thread(processGroups[i]);
+                        
+                         
                 }
         //start all threads
@@ -595 +607 @@
           aNode = (Node)it.next();
           // always process the node
-          if (!aNode.isAlive()) { //the node has failed or leaved??
+          if (!aNode.isAlive()) { //the node has failed or left??
               toRemove.add(aNode.getLocalHandle());
           }
         }
         boolean toContinue = false;
-        for (Boolean b : continues) {
-                        toContinue |=b;
+        for (int i = 0; i < processGroups.length; i++) {
+                        toContinue |= processGroups[i].isToContinue();
                 }
         return toContinue;
@@ -836 +848 @@
         private Node[] nodes = null;
         private int from,to;
-        private Boolean[] continues = null;
-        private int nr;
+//      private int nr;
+        private boolean toContinue;
         /**
          * 
@@ -846 +858 @@
          * @param nr the positon where to set in  <b>conitues</b> <code>true</code> or <code>false</code>
          */
-        public ProcessGroup(Node[] nodes, int from, int to,
-                                Boolean[] continues, int nr) {
-                        super();
-                        this.nodes = nodes;
-                        this.from = from;
-                        this.to = to;
-                        this.continues = continues;
-                        this.nr = nr;
-                }
+        
 
                 public void run() {
                         
-                        boolean toContinue = false;
+                        toContinue = false;
                 for (int i = from; i < to; i++) {
                                 Node n = nodes[i];
                                 toContinue |= n.process(totalSteps);
                         }
-                continues[nr]=toContinue;
+                
                 
         }
+                public void setNodes(Node[] nodes) {
+                        this.nodes = nodes;
+                }
+                public void setFrom(int from) {
+                        this.from = from;
+                }
+                public void setTo(int to) {
+                        this.to = to;
+                }
+                public boolean isToContinue() {
+                        return toContinue;
+                }
     }
 }