From: jzhou Date: Mon, 11 Aug 2008 20:16:49 +0000 (+0000) Subject: bug fixing in Scheduling analysis(combination stage) X-Git-Tag: preEdgeChange~3 X-Git-Url: http://plrg.eecs.uci.edu/git/?p=IRC.git;a=commitdiff_plain;h=f53e59475d07fc91b5146ccd791b7f5b4ba24d83 bug fixing in Scheduling analysis(combination stage) --- diff --git a/Robust/src/Analysis/Scheduling/CombinationUtil.java b/Robust/src/Analysis/Scheduling/CombinationUtil.java index 5ea3d89b..6c180a70 100644 --- a/Robust/src/Analysis/Scheduling/CombinationUtil.java +++ b/Robust/src/Analysis/Scheduling/CombinationUtil.java @@ -51,9 +51,12 @@ public class CombinationUtil { int next = 1; trial = trial(num2choose, next); } else { + if(this.rootNodes.size() == 1) { + return false; + } int next = this.rootNodes.lastElement().elementAt(0).getCid() + 1; int num2choose = 0; - if(next == this.sNodeVecs.size()) { + while(next == this.sNodeVecs.size()) { // backtrack num2choose = this.rootNodes.lastElement().size(); this.rootNodes.removeElementAt(this.rootNodes.size() - 1); @@ -62,8 +65,7 @@ public class CombinationUtil { return false; } next = this.rootNodes.lastElement().elementAt(0).getCid() + 1; - - } + } num2choose++; // reduce one from the last one this.rootNodes.lastElement().removeElementAt(this.rootNodes.lastElement().size() - 1); @@ -81,10 +83,14 @@ public class CombinationUtil { for(int i = 1; i < this.rootNodes.size(); i++) { int tmp = this.rootNodes.elementAt(i).elementAt(0).getCid(); while(next < tmp) { - this.node2Combine.add(new Vector()); Vector toadd = this.sNodeVecs.elementAt(next); - for(index = 0; index < toadd.size(); index++) { - this.node2Combine.lastElement().add(toadd.elementAt(index)); + if(toadd != null) { + this.node2Combine.add(new Vector()); + for(index = 0; index < toadd.size(); index++) { + this.node2Combine.lastElement().add(toadd.elementAt(index)); + } + } else { + this.node2Combine.add(null); } next++; } @@ -98,10 +104,14 @@ public class CombinationUtil { next++; } while(next < this.sNodeVecs.size()) { - this.node2Combine.add(new Vector()); Vector toadd = this.sNodeVecs.elementAt(next); - for(index = 0; index < toadd.size(); index++) { - this.node2Combine.lastElement().add(toadd.elementAt(index)); + if(toadd != null) { + this.node2Combine.add(new Vector()); + for(index = 0; index < toadd.size(); index++) { + this.node2Combine.lastElement().add(toadd.elementAt(index)); + } + } else { + this.node2Combine.add(null); } next++; } @@ -118,14 +128,21 @@ public class CombinationUtil { // no more nodes available to add return false; } - this.rootNodes.add(new Vector()); - first = false; } - this.rootNodes.lastElement().add(this.sNodeVecs.elementAt(next).elementAt(index)); - num2choose--; - index++; - if(index == this.sNodeVecs.elementAt(next).size()) { - index = 0; + if(this.sNodeVecs.elementAt(next) != null) { + if(first) { + this.rootNodes.add(new Vector()); + first = false; + } + this.rootNodes.lastElement().add(this.sNodeVecs.elementAt(next).elementAt(index)); + num2choose--; + index++; + if(index == this.sNodeVecs.elementAt(next).size()) { + index = 0; + next++; + first = true; + } + } else { next++; first = true; } @@ -177,9 +194,13 @@ public class CombinationUtil { } this.combine = new Vector>(); for(int i = 0; i < this.node2Combine.size(); i++) { - this.combine.add(new Vector()); - for(int j = 0; j < this.node2Combine.elementAt(i).size(); j++) { - this.combine.elementAt(i).add(new Combine(this.node2Combine.elementAt(i).elementAt(j))); + if(this.node2Combine.elementAt(i) == null) { + this.combine.add(null); + } else { + this.combine.add(new Vector()); + for(int j = 0; j < this.node2Combine.elementAt(i).size(); j++) { + this.combine.elementAt(i).add(new Combine(this.node2Combine.elementAt(i).elementAt(j))); + } } } this.lastchoices = null; @@ -206,16 +227,24 @@ public class CombinationUtil { // no more available combination under this choice // choose another choice int next = this.node2Combine.size() - 1; - boolean iter = false;; + boolean iter = false; do{ - this.lastchoices[next]++; - if(this.lastchoices[next] > this.node2Combine.elementAt(next).elementAt(0).getCid()) { - // break the rule that a node can only be combined to nodes with smaller colorid. - // backtrack + if(this.node2Combine.elementAt(next) != null) { + this.lastchoices[next]++; + if((this.lastchoices[next] == this.rootNodes.size() || + (this.rootNodes.elementAt(this.lastchoices[next]).elementAt(0).getCid() > + this.node2Combine.elementAt(next).elementAt(0).getCid()))){ + // break the rule that a node can only be combined to nodes with smaller colorid. + // or no more buckets + // backtrack + next--; + iter = true; + } else { + iter = false; + } + } else { next--; iter = true; - } else { - iter = false; } }while(iter && !(next < 0)); if(next < 0) { @@ -249,22 +278,24 @@ public class CombinationUtil { private boolean firstexpand(int next, boolean first) { for(int i = next; i < this.node2Combine.size(); i++) { - int choice = this.lastchoices[i]; - for(int j = 0; j < this.node2Combine.elementAt(i).size(); j++) { - Combine tmp = this.combine.elementAt(i).elementAt(j); - if(!first) { - this.rootNStates.elementAt(tmp.root).elementAt(tmp.index)[next]--; - } - tmp.root = choice; - tmp.index = 0; - if(!first) { - this.rootNStates.elementAt(tmp.root).elementAt(tmp.index)[next]++; + if(this.node2Combine.elementAt(i) != null) { + int choice = this.lastchoices[i]; + for(int j = 0; j < this.node2Combine.elementAt(i).size(); j++) { + Combine tmp = this.combine.elementAt(i).elementAt(j); + if(!first) { + this.rootNStates.elementAt(tmp.root).elementAt(tmp.index)[next]--; + } + tmp.root = choice; + tmp.index = 0; + if(!first) { + this.rootNStates.elementAt(tmp.root).elementAt(tmp.index)[next]++; + } } - } - if(first) { - this.rootNStates.elementAt(choice).elementAt(0)[i] = this.node2Combine.elementAt(i).size(); - for(int j = 1; j < this.rootNodes.elementAt(choice).size(); j++) { - this.rootNStates.elementAt(choice).elementAt(j)[i] = 0; + if(first) { + this.rootNStates.elementAt(choice).elementAt(0)[i] = this.node2Combine.elementAt(i).size(); + for(int j = 1; j < this.rootNodes.elementAt(choice).size(); j++) { + this.rootNStates.elementAt(choice).elementAt(j)[i] = 0; + } } } } @@ -272,6 +303,16 @@ public class CombinationUtil { } private boolean innertrial(int next, int layer) { + if((this.combine.elementAt(next) == null) || + (this.combine.elementAt(next).size() < 2)) { + // skip over empty buckets and bucket with only one obj ( make sure + // at least one obj is existing in the chosen bucket) + if(next - 1 < 0) { + return false; + } else { + return innertrial(next - 1, ++layer); + } + } Combine tmp = this.combine.elementAt(next).lastElement(); // try to move it backward int root = tmp.root; @@ -310,15 +351,28 @@ public class CombinationUtil { return innertrial(next - 1, ++layer); } } else if(tmp.root != root) { + if((tmp.root == this.lastchoices[next]) && + (this.rootNStates.elementAt(this.lastchoices[next]).elementAt(0)[next] == 1)) { + // only 1 obj left in the chosen bucket + // can not move this one + // try the bucket in node2combine before + if(next - 1 < 0) { + return false; + } else { + return innertrial(next - 1, ++layer); + } + } this.rootNStates.elementAt(tmp.root).elementAt(tmp.index)[next]--; - tmp.root = root; + //tmp.root = root; + int newroot = tmp.root + 1; + tmp.root = newroot; tmp.index = 0; this.rootNStates.elementAt(tmp.root).elementAt(tmp.index)[next]++; // make all left things in this color bucket reset - for(t += 1; t < this.combine.elementAt(next).size(); t++) { + for(t++; t < this.combine.elementAt(next).size(); t++) { tmp = this.combine.elementAt(next).elementAt(t); this.rootNStates.elementAt(tmp.root).elementAt(tmp.index)[next]--; - tmp.root = root; + tmp.root = newroot; tmp.index = 0; this.rootNStates.elementAt(tmp.root).elementAt(tmp.index)[next]++; } @@ -346,9 +400,33 @@ public class CombinationUtil { } } else { this.rootNStates.elementAt(tmp.root).elementAt(tmp.index)[next]--; + int tmproot = tmp.root; + int tmpindex = tmp.index; tmp.root = root; tmp.index = index; this.rootNStates.elementAt(tmp.root).elementAt(tmp.index)[next]++; + int desroot = tmp.root; + int desindex = tmp.index; + // make all left things in this color bucket reset + t++; + boolean first = true; + while(t < this.combine.elementAt(next).size()) { + int k = 0; + if(first) { + k = 1; + first = false; + } + for(; (k < this.rootNStates.elementAt(tmproot).elementAt(tmpindex)[next]) && (t < this.combine.elementAt(next).size()); t++) { + tmp = this.combine.elementAt(next).elementAt(t); + this.rootNStates.elementAt(tmp.root).elementAt(tmp.index)[next]--; + tmp.root = desroot; + tmp.index = desindex; + this.rootNStates.elementAt(tmp.root).elementAt(tmp.index)[next]++; + } + if(k == this.rootNStates.elementAt(tmproot).elementAt(tmpindex)[next]) { + desindex++; + } + } if(layer != 0) { return firstexpand(next+1, this.first4choice); } @@ -357,14 +435,25 @@ public class CombinationUtil { } } } else { - this.rootNStates.elementAt(tmp.root).elementAt(tmp.index)[next]--; - tmp.root = root; - tmp.index = index; - this.rootNStates.elementAt(tmp.root).elementAt(tmp.index)[next]++; - if(layer != 0) { - return firstexpand(next+1, this.first4choice); + if((tmp.root != this.lastchoices[next]) || + (this.rootNStates.elementAt(this.lastchoices[next]).elementAt(0)[next] > 1)) { + this.rootNStates.elementAt(tmp.root).elementAt(tmp.index)[next]--; + tmp.root = root; + tmp.index = index; + this.rootNStates.elementAt(tmp.root).elementAt(tmp.index)[next]++; + if(layer != 0) { + return firstexpand(next+1, this.first4choice); + } + return true; + } else { + // only 1 obj with the color next exist on the chosen bucket this time, + // can not move it, try objs in forward color bucket + if(next - 1 < 0) { + return false; + } else { + return innertrial(next - 1, ++layer); + } } - return true; } } @@ -379,35 +468,37 @@ public class CombinationUtil { tmp.index = index; this.rootNStates.elementAt(tmp.root).elementAt(tmp.index)[next]++; t += 2; + Combine tmpt = null; if(this.rootNStates.elementAt(root).elementAt(index - 1)[next] < this.rootNStates.elementAt(root).elementAt(index)[next]) { // need to continue propagate while(t < this.combine.elementAt(next).size()) { - tmp = this.combine.elementAt(next).elementAt(t); - if ((tmp.root != root) || (tmp.index != index)) { + tmpt = this.combine.elementAt(next).elementAt(t); + if ((tmpt.root != root) || (tmpt.index != index)) { break; } t++; } if(t == this.combine.elementAt(next).size()) { + // last element of this color bucket if(index + 1 < this.rootNodes.elementAt(root).size()) { // there is available place inside the same color bucket Combine tmpbk = this.combine.elementAt(next).elementAt(t - 1); boolean suc = propagateOne(next, root, index + 1, t - 1, tmpbk); - if(!suc) { + /*if(!suc) { // fail, roll back this.rootNStates.elementAt(tmp.root).elementAt(tmp.index)[next]--; tmp.root = rootbk; tmp.index = indexbk; this.rootNStates.elementAt(tmp.root).elementAt(tmp.index)[next]++; - } + }*/ return suc; } else if(root+1 < this.rootNodes.size()) { // check if there are another bucket // yes - this.rootNStates.elementAt(tmp.root).elementAt(tmp.index)[next]--; - tmp.root = root + 1; - tmp.index = 0; - this.rootNStates.elementAt(tmp.root).elementAt(tmp.index)[next]++; + this.rootNStates.elementAt(tmpt.root).elementAt(tmpt.index)[next]--; + tmpt.root = root + 1; + tmpt.index = 0; + this.rootNStates.elementAt(tmpt.root).elementAt(tmpt.index)[next]++; return firstexpand(next+1, this.first4choice); } else { // no, roll back @@ -417,26 +508,26 @@ public class CombinationUtil { this.rootNStates.elementAt(tmp.root).elementAt(tmp.index)[next]++; return false; } - } else if(tmp.root != root) { + } else if(tmpt.root != root) { Combine tmpbk = this.combine.elementAt(next).elementAt(t - 1); this.rootNStates.elementAt(tmpbk.root).elementAt(tmpbk.index)[next]--; - tmpbk.root = tmp.root; + tmpbk.root = tmpt.root; tmpbk.index = 0; - root = tmp.root; this.rootNStates.elementAt(tmpbk.root).elementAt(tmpbk.index)[next]++; - index = tmp.index; + root = tmpt.root; + index = tmpt.index; // make all left things in this color bucket reset for(t += 1; t < this.combine.elementAt(next).size(); t++) { - tmp = this.combine.elementAt(next).elementAt(t); - this.rootNStates.elementAt(tmp.root).elementAt(tmp.index)[next]--; - tmp.root = root; - tmp.index = 0; - this.rootNStates.elementAt(tmp.root).elementAt(tmp.index)[next]++; + tmpt = this.combine.elementAt(next).elementAt(t); + this.rootNStates.elementAt(tmpt.root).elementAt(tmpt.index)[next]--; + tmpt.root = root; + tmpt.index = 0; + this.rootNStates.elementAt(tmpt.root).elementAt(tmpt.index)[next]++; } return firstexpand(next+1, this.first4choice); - } else if(tmp.index != index) { + } else if(tmpt.index != index) { Combine tmpbk = this.combine.elementAt(next).elementAt(t - 1); - boolean suc = propagateOne(next, root, tmp.index, t - 1, tmpbk); + boolean suc = propagateOne(next, root, tmpt.index, t - 1, tmpbk); if(!suc) { // fail, roll back this.rootNStates.elementAt(tmp.root).elementAt(tmp.index)[next]--; diff --git a/Robust/src/Analysis/Scheduling/ScheduleAnalysis.java b/Robust/src/Analysis/Scheduling/ScheduleAnalysis.java index d151b1b3..f65c08fe 100644 --- a/Robust/src/Analysis/Scheduling/ScheduleAnalysis.java +++ b/Robust/src/Analysis/Scheduling/ScheduleAnalysis.java @@ -755,13 +755,13 @@ public class ScheduleAnalysis { CombinationUtil.RootsGenerator rGen = CombinationUtil.allocateRootsGenerator(sNodeVecs, this.coreNum); + int gid = 1; while(rGen.nextGen()) { // first get the chosen rootNodes Vector> rootNodes = rGen.getRootNodes(); Vector> nodes2combine = rGen.getNode2Combine(); CombinationUtil.CombineGenerator cGen = CombinationUtil.allocateCombineGenerator(rootNodes, nodes2combine); - int gid = 1; while (cGen.nextGen()) { Vector> combine = cGen.getCombine(); Vector sNodes = generateScheduling(rootNodes, combine, gid++); @@ -997,29 +997,31 @@ public class ScheduleAnalysis { // combine those nodes in combine with corresponding rootnodes for(int i = 0; i < combine.size(); i++) { - for(int j = 0; j < combine.elementAt(i).size(); j++) { - CombinationUtil.Combine tmpcombine = combine.elementAt(i).elementAt(j); - ScheduleNode tocombine = sn2sn.get(tmpcombine.node); - ScheduleNode root = sn2sn.get(rootnodes.elementAt(tmpcombine.root).elementAt(tmpcombine.index)); - ScheduleEdge se = (ScheduleEdge)tocombine.inedges().next(); - try{ - if(root.equals(((ScheduleNode)se.getSource()))) { - root.mergeSEdge(se); - if(ScheduleEdge.NEWEDGE == se.getType()) { - // As se has been changed into an internal edge inside a ScheduleNode, - // change the source and target of se from original ScheduleNodes into ClassNodes. - se.setTarget(se.getTargetCNode()); - se.setSource(se.getSourceCNode()); - se.getTargetCNode().addEdge(se); + if(combine.elementAt(i) != null) { + for(int j = 0; j < combine.elementAt(i).size(); j++) { + CombinationUtil.Combine tmpcombine = combine.elementAt(i).elementAt(j); + ScheduleNode tocombine = sn2sn.get(tmpcombine.node); + ScheduleNode root = sn2sn.get(rootnodes.elementAt(tmpcombine.root).elementAt(tmpcombine.index)); + ScheduleEdge se = (ScheduleEdge)tocombine.inedges().next(); + try{ + if(root.equals(((ScheduleNode)se.getSource()))) { + root.mergeSEdge(se); + if(ScheduleEdge.NEWEDGE == se.getType()) { + // As se has been changed into an internal edge inside a ScheduleNode, + // change the source and target of se from original ScheduleNodes into ClassNodes. + se.setTarget(se.getTargetCNode()); + se.setSource(se.getSourceCNode()); + se.getTargetCNode().addEdge(se); + } + } else { + root.mergeSNode(tocombine); } - } else { - root.mergeSNode(tocombine); + } catch(Exception e) { + e.printStackTrace(); + System.exit(-1); } - } catch(Exception e) { - e.printStackTrace(); - System.exit(-1); + result.removeElement(tocombine); } - result.removeElement(tocombine); } } diff --git a/Robust/src/Analysis/TaskStateAnalysis/FlagState.java b/Robust/src/Analysis/TaskStateAnalysis/FlagState.java index c9787e32..4572dd50 100644 --- a/Robust/src/Analysis/TaskStateAnalysis/FlagState.java +++ b/Robust/src/Analysis/TaskStateAnalysis/FlagState.java @@ -16,6 +16,7 @@ public class FlagState extends GraphNode implements Cloneable { public static final int ONETAG=1; public static final int NOTAGS=0; public static final int MULTITAGS=-1; + public static final int MAXTIME=10; private int uid; private static int nodeid=0; @@ -30,6 +31,7 @@ public class FlagState extends GraphNode implements Cloneable { // jzhou // for static scheduling private int executeTime; + private int visited4time; private int invokeNum; // for building multicore codes private int andmask; @@ -50,6 +52,7 @@ public class FlagState extends GraphNode implements Cloneable { this.uid=FlagState.nodeid++; this.issourcenode=false; this.executeTime = -1; + this.visited4time = -1; this.invokeNum = 0; this.andmask = 0; this.checkmask = 0; @@ -72,6 +75,7 @@ public class FlagState extends GraphNode implements Cloneable { this.uid=FlagState.nodeid++; this.issourcenode=false; this.executeTime = -1; + this.visited4time = -1; this.invokeNum = 0; } @@ -331,7 +335,15 @@ public class FlagState extends GraphNode implements Cloneable { public int getExeTime() { try { if(this.executeTime == -1) { - calExeTime(); + if(this.visited4time == -1) { + this.visited4time = 0; + calExeTime(); + } else { + // visited, this node is in a loop + // TODO + // currently set 10 as the largest time + this.executeTime = FlagState.MAXTIME; + } } } catch (Exception e) { e.printStackTrace(); diff --git a/Robust/src/Benchmarks/Scheduling/JGFSeries/JGFSeriesBench.java b/Robust/src/Benchmarks/Scheduling/JGFSeries/JGFSeriesBench.java index 1ebb878d..adb5e0ce 100644 --- a/Robust/src/Benchmarks/Scheduling/JGFSeries/JGFSeriesBench.java +++ b/Robust/src/Benchmarks/Scheduling/JGFSeries/JGFSeriesBench.java @@ -1,4 +1,4 @@ -/** Bristlecone Version **/ +/** Banboo Version **/ /************************************************************************** * * diff --git a/Robust/src/ClassLibrary/Math.java b/Robust/src/ClassLibrary/Math.java index 247ce63a..e9d790a8 100644 --- a/Robust/src/ClassLibrary/Math.java +++ b/Robust/src/ClassLibrary/Math.java @@ -29,5 +29,6 @@ public class Math { public static native float sinf(float a); public static native float cosf(float a); public static native float sqrtf(float a); + public static native double logf(float a); public static native float powf(float a, float b); } diff --git a/Robust/src/IR/Flat/BuildCodeMultiCore.java b/Robust/src/IR/Flat/BuildCodeMultiCore.java index f737624d..2b9691af 100644 --- a/Robust/src/IR/Flat/BuildCodeMultiCore.java +++ b/Robust/src/IR/Flat/BuildCodeMultiCore.java @@ -648,7 +648,17 @@ public class BuildCodeMultiCore extends BuildCode { super.generateFlatNode(fm, lb, current_node, output); if (current_node.kind()!=FKind.FlatReturnNode) { //output.println(" flushAll();"); + output.println("#ifdef RAW"); + output.println("raw_user_interrupts_off();"); + output.println("#ifdef RAWDEBUG"); + output.println("raw_test_pass(0xec00);"); + output.println("#endif"); output.println("raw_flush_entire_cache();"); + output.println("#ifdef RAWDEBUG"); + output.println("raw_test_pass(0xecff);"); + output.println("#endif"); + output.println("raw_user_interrupts_on();"); + output.println("#endif"); outputTransCode(output); output.println(" return;"); } @@ -1225,7 +1235,17 @@ public class BuildCodeMultiCore extends BuildCode { } else { if(fm.getTask() != null) { //output.println("flushAll();"); + output.println("#ifdef RAW"); + output.println("raw_user_interrupts_off();"); + output.println("#ifdef RAWDEBUG"); + output.println("raw_test_pass(0xec00);"); + output.println("#endif"); output.println("raw_flush_entire_cache();"); + output.println("#ifdef RAWDEBUG"); + output.println("raw_test_pass(0xecff);"); + output.println("#endif"); + output.println("raw_user_interrupts_on();"); + output.println("#endif"); outputTransCode(output); } output.println("return;"); diff --git a/Robust/src/Main/Main.java b/Robust/src/Main/Main.java index 11043b2c..e218d333 100644 --- a/Robust/src/Main/Main.java +++ b/Robust/src/Main/Main.java @@ -307,13 +307,14 @@ public class Main { //int newRate = (j+1)%2+1; int newRate = 1; String cdname = cd.getSymbol(); - if(cdname.equals("SeriesRunner")) { + if((cdname.equals("SeriesRunner")) || + (cdname.equals("MDRunner"))) { newRate = 16; - } else if(cdname.equals("MapWorker")) { - newRate = 6; - } else if(cdname.equals("ReduceWorker")) { + } else if(cdname.equals("SentenceParser")) { + newRate = 4; + } /*else if(cdname.equals("ReduceWorker")) { newRate = 3; - } + }*/ /*do { tint = r.nextInt()%100; } while(tint <= 0); diff --git a/Robust/src/Runtime/math.c b/Robust/src/Runtime/math.c index 3140f1c0..7a54d283 100644 --- a/Robust/src/Runtime/math.c +++ b/Robust/src/Runtime/math.c @@ -54,6 +54,10 @@ float CALL11(___Math______sqrtf____F, float ___a___, float ___a___) { return sqrtf(___a___); } +float CALL11(___Math______logf____F, float ___a___, float ___a___) { + return logf(___a___); +} + float CALL22(___Math______powf____F_F, float ___a___, float ___b___, float ___a___, float ___b___) { return powf(___a___,___b___); } diff --git a/Robust/src/Runtime/multicoretask.c b/Robust/src/Runtime/multicoretask.c index d5e180e6..01516953 100644 --- a/Robust/src/Runtime/multicoretask.c +++ b/Robust/src/Runtime/multicoretask.c @@ -410,6 +410,9 @@ void run(void* arg) { // and try to execute active tasks already enqueued first removeItem(&objqueue, objitem); addNewItem_I(&objqueue, objInfo); +#ifdef INTERRUPT + raw_user_interrupts_on(); +#endif break; } #ifdef INTERRUPT @@ -2785,6 +2788,7 @@ void executetasks() { taskpointerarray[i+OFFSET]=parameter; goto execute; } + lock = true; // require locks for this parameter if it is not a startup object getwritelock(parameter); grount = 0; @@ -2845,6 +2849,7 @@ void executetasks() { taskpointerarray[i+OFFSET]=parameter; goto execute; } + lock = true; if(0 == tmpparam->isolate) { isolateflags[i] = 0; // shared object, need to flush with current value @@ -3056,13 +3061,18 @@ execute: } else { ((void (*) (void **)) currtpd->task->taskptr)(taskpointerarray); } +#ifdef RAWDEBUG + raw_test_pass(0xe998); + raw_test_pass_reg(lock); + #endif + if(lock) { #ifdef RAW for(i = 0; i < numparams; ++i) { int j = 0; struct ___Object___ * tmpparam = (struct ___Object___ *)taskpointerarray[i+OFFSET]; #ifdef RAWDEBUG - raw_test_pass(0xe998); + raw_test_pass(0xe999); raw_test_pass(0xdd100000 + tmpparam->flag); #endif releasewritelock(tmpparam); @@ -3093,6 +3103,11 @@ execute: reverse=NULL; #endif #endif +#ifdef RAWDEBUG + raw_test_pass(0xe99a); + raw_test_pass_reg(lock); + #endif + } } } diff --git a/Robust/src/Runtime/task.c b/Robust/src/Runtime/task.c index 142f076d..57bcbf07 100644 --- a/Robust/src/Runtime/task.c +++ b/Robust/src/Runtime/task.c @@ -903,8 +903,9 @@ int enqueuetasks(struct parameterwrapper *parameter, struct parameterwrapper *pr /* Find initial state */ for(j=0;jiterators[j], taskpointerarray OPTARG(failed))) + if(toiHasNext(¶meter->iterators[j], taskpointerarray OPTARG(failed))){ toiNext(¶meter->iterators[j], taskpointerarray OPTARG(failed)); + } else if (j>0) { /* Need to backtrack */ toiReset(¶meter->iterators[j]); @@ -946,15 +947,16 @@ int enqueuetasks(struct parameterwrapper *parameter, struct parameterwrapper *pr #endif RUNFREE(tpd); } - + /* This loop iterates to the next parameter combination */ if (numiterators==0) return retval; for(j=numiterators-1; jiterators[j], taskpointerarray OPTARG(failed))) + if(toiHasNext(¶meter->iterators[j], taskpointerarray OPTARG(failed))){ toiNext(¶meter->iterators[j], taskpointerarray OPTARG(failed)); + } else if (j>0) { /* Need to backtrack */ toiReset(¶meter->iterators[j]); @@ -1647,7 +1649,8 @@ void toiNext(struct tagobjectiterator *it , void ** objectarray OPTARG(int * fai } } else { /* Iterate object */ - objectarray[it->slot]=(void *)Objkey(&it->it); + void * tmpp = (void *) Objkey(&it->it); + objectarray[it->slot]=tmpp; #ifdef OPTIONAL failed[it->slot]=it->failedstate; if (it->failedstate==0) {