changes to build script to increase java heap memory

[IRC.git] / Robust / src / Analysis / Scheduling / Schedule.java

diff --git a/Robust/src/Analysis/Scheduling/Schedule.java b/Robust/src/Analysis/Scheduling/Schedule.java
index 3fedbb6c8e20d7530966c2dab080785125e2c4f8..a04c629b64419f056a9d37394d1256c22e131e47 100644 (file)
--- a/Robust/src/Analysis/Scheduling/Schedule.java
+++ b/Robust/src/Analysis/Scheduling/Schedule.java
@@ -14,9 +14,9 @@ public class Schedule {
     private int coreNum;
     private Vector<TaskDescriptor> tasks;
     private Hashtable<FlagState, Queue<Integer>> targetCores;
-    private Hashtable<FlagState, FlagState> targetFState;
-    private Vector<Integer> ancestorCores;
-    private Vector<Integer> childCores;
+    private Hashtable<FlagState, FlagState> targetFState; // only affected by transimit edges
+    private Hashtable<FlagState, Vector<Integer>> allyCores;
+    private Hashtable<TaskDescriptor, Vector<FlagState>> td2fs;
     
     public Schedule(int coreNum) {
        super();
@@ -24,7 +24,8 @@ public class Schedule {
        this.tasks = null;
        this.targetCores = null;
        this.targetFState = null;
-       this.ancestorCores = null;
+       this.allyCores = null;
+       this.td2fs = null;
     }
 
     public int getCoreNum() {
@@ -52,18 +53,38 @@ public class Schedule {
        }
        return targetFState.get(fstate);
     }
+    
+    public Hashtable<FlagState, Vector<Integer>> getAllyCoreTable() {
+        return this.allyCores;
+    }
+    
+    public Vector<Integer> getAllyCores(FlagState fstate) {
+       if(this.allyCores == null) {
+           return null;
+       }
+       return this.allyCores.get(fstate);
+    }
+    
+    public Hashtable<TaskDescriptor, Vector<FlagState>> getTd2FsTable() {
+        return this.td2fs;
+    }
+    
+    public Vector<FlagState> getFStates4TD(TaskDescriptor td) {
+       if(this.td2fs == null) {
+           return null;
+       }
+       return this.td2fs.get(td);
+    }
 
-    public void addTargetCore(FlagState fstate, Integer targetCore/*, Integer num*/) {
+    public void addTargetCore(FlagState fstate, Integer targetCore) {
        if(this.targetCores == null) {
            this.targetCores = new Hashtable<FlagState, Queue<Integer>>();
        }
        if(!this.targetCores.containsKey(fstate)) {
            this.targetCores.put(fstate, new LinkedList<Integer>());
        }
-       //if(!this.targetCores.get(fstate).contains(targetCore)) {
-           this.targetCores.get(fstate).add(targetCore); // there may have some duplicate items,
-                                                         // which reflects probabilities.
-       //}
+       this.targetCores.get(fstate).add(targetCore); // there may have some duplicate items,
+                                                     // which reflects probabilities.
     }
     
     public void addTargetCore(FlagState fstate, Integer targetCore, FlagState tfstate) {
@@ -73,76 +94,48 @@ public class Schedule {
        if(!this.targetCores.containsKey(fstate)) {
            this.targetCores.put(fstate, new LinkedList<Integer>());
        }
-       //if(!this.targetCores.get(fstate).contains(targetCore)) {
-           this.targetCores.get(fstate).add(targetCore);
-       //}
+       this.targetCores.get(fstate).add(targetCore);
        if(this.targetFState == null) {
            this.targetFState = new Hashtable<FlagState, FlagState>();
        }
-       //if(!this.targetFState.containsKey(fstate)) {
-           this.targetFState.put(fstate, tfstate);
-       //}
+       this.targetFState.put(fstate, tfstate);
     }
-
-    public Vector<TaskDescriptor> getTasks() {
-        return tasks;
-    }
-
-    public void addTask(TaskDescriptor task) {
-       if(this.tasks == null) {
-           this.tasks = new Vector<TaskDescriptor>();
-       }
-       if(!this.tasks.contains(task)) {
-           this.tasks.add(task);
+    
+    public void addAllyCore(FlagState fstate, Integer targetCore) {
+       if(this.allyCores == null) {
+           this.allyCores = new Hashtable<FlagState, Vector<Integer>>();
        }
-    }
-
-    public Vector<Integer> getAncestorCores() {
-        return ancestorCores;
-    }
-
-    public void setAncestorCores(Vector<Integer> ancestorCores) {
-        this.ancestorCores = ancestorCores;
-    }
-
-    public void addAncestorCores(Integer ancestorCore) {
-       if(this.ancestorCores == null) {
-           this.ancestorCores = new Vector<Integer>();
+       if(!this.allyCores.containsKey(fstate)) {
+           this.allyCores.put(fstate, new Vector<Integer>());
        }
-       if((ancestorCore.intValue() != this.coreNum) && (!this.ancestorCores.contains(ancestorCore))) {
-           this.ancestorCores.addElement(ancestorCore);
+       if((this.coreNum != targetCore.intValue()) && (!this.allyCores.get(fstate).contains(targetCore))) {
+           this.allyCores.get(fstate).add(targetCore); // there may have some duplicate items,
+                                                       // which reflects probabilities.
        }
     }
     
-    public int ancestorCoresNum() {
-       if(this.ancestorCores == null) {
-           return 0;
+    public void addFState4TD(TaskDescriptor td, FlagState fstate) {
+       if(this.td2fs == null) {
+           this.td2fs = new Hashtable<TaskDescriptor, Vector<FlagState>>();
+       }
+       if(!this.td2fs.containsKey(td)) {
+           this.td2fs.put(td, new Vector<FlagState>());
+       }
+       if(!this.td2fs.get(td).contains(fstate)) {
+           this.td2fs.get(td).add(fstate);
        }
-       return this.ancestorCores.size();
     }
 
-    public Vector<Integer> getChildCores() {
-        return childCores;
+    public Vector<TaskDescriptor> getTasks() {
+        return tasks;
     }
 
-    public void setChildCores(Vector<Integer> childCores) {
-        this.childCores = childCores;
-    }
-    
-    public void addChildCores(Integer childCore) {
-       if(this.childCores == null) {
-           this.childCores = new Vector<Integer>();
-       }
-       if((childCore.intValue() != this.coreNum) && (!this.childCores.contains(childCore))) {
-           this.childCores.addElement(childCore);
+    public void addTask(TaskDescriptor task) {
+       if(this.tasks == null) {
+           this.tasks = new Vector<TaskDescriptor>();
        }
-    }
-    
-    public int childCoresNum() {
-       if(this.childCores == null) {
-           return 0;
+       if(!this.tasks.contains(task)) {
+           this.tasks.add(task);
        }
-       return this.childCores.size();
-    }
-    
+    }    
 }
\ No newline at end of file