From e657f2b3171b3fa1c6af965d71b9cf32066e407a Mon Sep 17 00:00:00 2001 From: wmontaz Date: Tue, 7 Aug 2007 18:35:53 +0000 Subject: [PATCH] new class names. build output code for optional tasks. --- .../Analysis/TaskStateAnalysis/FlagState.java | 4 + .../TaskStateAnalysis/MyOptional.java | 45 -- .../OptionalTaskDescriptor.java | 54 +++ .../Analysis/TaskStateAnalysis/Predicate.java | 28 +- .../TaskStateAnalysis/SafetyAnalysis.java | 209 +++++----- Robust/src/IR/Flat/BuildCode.java | 383 ++++++++++++++---- Robust/src/IR/State.java | 12 +- Robust/src/IR/VarDescriptor.java | 1 + Robust/src/Main/Main.java | 2 +- Robust/src/Runtime/task.c | 1 + 10 files changed, 520 insertions(+), 219 deletions(-) delete mode 100644 Robust/src/Analysis/TaskStateAnalysis/MyOptional.java create mode 100644 Robust/src/Analysis/TaskStateAnalysis/OptionalTaskDescriptor.java diff --git a/Robust/src/Analysis/TaskStateAnalysis/FlagState.java b/Robust/src/Analysis/TaskStateAnalysis/FlagState.java index c18f9d90..4f7078ef 100644 --- a/Robust/src/Analysis/TaskStateAnalysis/FlagState.java +++ b/Robust/src/Analysis/TaskStateAnalysis/FlagState.java @@ -114,6 +114,10 @@ public class FlagState extends GraphNode { public Iterator getFlags() { return flagstate.iterator(); } + + public int numFlags(){ + return flagstate.size(); + } public FlagState[] setTag(TagDescriptor tag){ HashSet newset1=(HashSet)flagstate.clone(); diff --git a/Robust/src/Analysis/TaskStateAnalysis/MyOptional.java b/Robust/src/Analysis/TaskStateAnalysis/MyOptional.java deleted file mode 100644 index 1e7d5cb0..00000000 --- a/Robust/src/Analysis/TaskStateAnalysis/MyOptional.java +++ /dev/null @@ -1,45 +0,0 @@ -package Analysis.TaskStateAnalysis; -import java.util.*; -import IR.*; -import IR.Tree.*; -import IR.Flat.*; -import java.io.*; -import Util.Edge; - -public class MyOptional{ - public TaskDescriptor td; - public HashSet flagstates; - public int depth; - public HashSet exitfses; - public Predicate predicate; - - protected MyOptional(TaskDescriptor td, HashSet flagstates, int depth, Predicate predicate){ - this.td = td; - this.flagstates = flagstates; - this.depth = depth; - this.exitfses = new HashSet(); - this.predicate = predicate; - - } - - public boolean equals(Object o){ - if (o instanceof MyOptional) { - MyOptional myo = (MyOptional) o; - if (this.td.getSymbol().compareTo(myo.td.getSymbol())==0) - if(this.flagstates.equals(myo.flagstates)) - return true; - return false; - } - else return false; - - } - - public int hashCode() { - return td.hashCode()+flagstates.hashCode()+exitfses.hashCode(); - } - - public String tostring() { - return "Optional task "+td.getSymbol(); - } - -} diff --git a/Robust/src/Analysis/TaskStateAnalysis/OptionalTaskDescriptor.java b/Robust/src/Analysis/TaskStateAnalysis/OptionalTaskDescriptor.java new file mode 100644 index 00000000..b4f39812 --- /dev/null +++ b/Robust/src/Analysis/TaskStateAnalysis/OptionalTaskDescriptor.java @@ -0,0 +1,54 @@ +package Analysis.TaskStateAnalysis; +import java.util.*; +import IR.*; +import IR.Tree.*; +import IR.Flat.*; +import java.io.*; +import Util.Edge; + +public class OptionalTaskDescriptor{ + public TaskDescriptor td; + public HashSet flagstates; + public int depth; + public HashSet exitfses; + public Predicate predicate; + private static int nodeid=0; + private int uid; + + protected OptionalTaskDescriptor(TaskDescriptor td, HashSet flagstates, int depth, Predicate predicate){ + this.td = td; + this.flagstates = flagstates; + this.depth = depth; + this.exitfses = new HashSet(); + this.predicate = predicate; + this.uid = OptionalTaskDescriptor.nodeid++; + + } + + public boolean equals(Object o){ + if (o instanceof OptionalTaskDescriptor) { + OptionalTaskDescriptor otd = (OptionalTaskDescriptor) o; + if (this.td.getSymbol().compareTo(otd.td.getSymbol())==0) + if(this.flagstates.equals(otd.flagstates)) + if(this.predicate.equals(otd.predicate)) + return true; + return false; + } + else return false; + + } + + public int hashCode() { + return td.getSymbol().hashCode()+flagstates.hashCode()+predicate.hashCode(); + } + + public String tostring() { + return "Optional task "+td.getSymbol(); + } + + public int getuid() { + return uid; + } + + +} diff --git a/Robust/src/Analysis/TaskStateAnalysis/Predicate.java b/Robust/src/Analysis/TaskStateAnalysis/Predicate.java index ea39a952..b00b8984 100644 --- a/Robust/src/Analysis/TaskStateAnalysis/Predicate.java +++ b/Robust/src/Analysis/TaskStateAnalysis/Predicate.java @@ -6,13 +6,29 @@ import IR.Flat.*; import Util.Edge; public class Predicate{ - public HashSet vardescriptors; - public Hashtable> flags; - public Hashtable tags; //if there is a tag change, we stop the analysis + public Hashtable vardescriptors; + public Hashtable> flags; + public Hashtable tags; //if there is a tag change, we stop the analysis public Predicate(){ - this.vardescriptors = new HashSet(); - this.flags = new Hashtable(); - this.tags = new Hashtable(); + this.vardescriptors = new Hashtable(); + this.flags = new Hashtable(); + this.tags = new Hashtable(); } + + public boolean equals(Object o){ + if(o instanceof Predicate){ + Predicate p = (Predicate) o; + if(this.vardescriptors.equals(p.vardescriptors)) + return true; + return false; + } + else return false; + } + + public int hashCode(){ + return vardescriptors.hashCode(); + } + + } diff --git a/Robust/src/Analysis/TaskStateAnalysis/SafetyAnalysis.java b/Robust/src/Analysis/TaskStateAnalysis/SafetyAnalysis.java index 5bfb7e04..8ecab55f 100644 --- a/Robust/src/Analysis/TaskStateAnalysis/SafetyAnalysis.java +++ b/Robust/src/Analysis/TaskStateAnalysis/SafetyAnalysis.java @@ -19,7 +19,7 @@ public class SafetyAnalysis { private String classname; private State state; private TaskAnalysis taskanalysis; - private Hashtable myoptionals; + private Hashtable optionaltaskdescriptors; private ClassDescriptor processedclass; @@ -28,8 +28,8 @@ public class SafetyAnalysis { return safeexecution; } - public Hashtable getMyOptionals(){ - return myoptionals; + public Hashtable getOptionalTaskDescriptors(){ + return optionaltaskdescriptors; } /*Structure that stores a possible optional @@ -45,7 +45,7 @@ public class SafetyAnalysis { this.reducedgraph = new Hashtable(); this.state = state; this.taskanalysis = taskanalysis; - this.myoptionals = new Hashtable(); + this.optionaltaskdescriptors = new Hashtable(); } /*finds the the source node in the execution graph*/ @@ -103,8 +103,8 @@ public class SafetyAnalysis { System.out.println("\nAnalysing class :"); processedclass=(ClassDescriptor)e.nextElement(); classname = processedclass.getSymbol(); - HashSet newhashset = new HashSet(); - myoptionals.put(processedclass, newhashset); + Hashtable newhashtable = new Hashtable(); + optionaltaskdescriptors.put(processedclass, newhashtable); Hashtable cdhashtable = new Hashtable(); System.out.println("\t"+classname+ "\n"); @@ -151,8 +151,8 @@ public class SafetyAnalysis { //removeDoubles(availabletasks); for(Iterator it = availabletasks.iterator(); it.hasNext();){ - MyOptional mo = (MyOptional)it.next(); - resultingFS(mo, classname); + OptionalTaskDescriptor otd = (OptionalTaskDescriptor)it.next(); + resultingFS(otd, classname); } cdhashtable.put(fs, availabletasks); @@ -161,7 +161,7 @@ public class SafetyAnalysis { safeexecution.put(processedclass, cdhashtable); } - + cleanPredicates(); printTEST(); @@ -179,25 +179,26 @@ public class SafetyAnalysis { FlagState fs = (FlagState)fses.nextElement(); System.out.println("\t"+fs.getTextLabel()+"\n\tSafe tasks to execute :\n"); HashSet availabletasks = (HashSet)hashtbtemp.get(fs); - for(Iterator mos = availabletasks.iterator(); mos.hasNext();){ - MyOptional mm = (MyOptional)mos.next(); - System.out.println("\t\tTASK "+mm.td.getSymbol()+"\n"); - System.out.println("\t\tDepth : "+mm.depth); + for(Iterator otd_it = availabletasks.iterator(); otd_it.hasNext();){ + OptionalTaskDescriptor otd = (OptionalTaskDescriptor)otd_it.next(); + System.out.println("\t\tTASK "+otd.td.getSymbol()+" UID : "+otd.getuid()+"\n"); + System.out.println("\t\tDepth : "+otd.depth); System.out.println("\t\twith flags :"); - for(Iterator myfses = mm.flagstates.iterator(); myfses.hasNext();){ + for(Iterator myfses = otd.flagstates.iterator(); myfses.hasNext();){ System.out.println("\t\t\t"+((FlagState)myfses.next()).getTextLabel()); } System.out.println("\t\tand exitflags :"); - for(Iterator fseshash = mm.exitfses.iterator(); fseshash.hasNext();){ + for(Iterator fseshash = otd.exitfses.iterator(); fseshash.hasNext();){ HashSet temphs = (HashSet)fseshash.next(); System.out.println(""); for(Iterator exfses = temphs.iterator(); exfses.hasNext();){ System.out.println("\t\t\t"+((FlagState)exfses.next()).getTextLabel()); } } - Predicate predicate = mm.predicate; + Predicate predicate = otd.predicate; System.out.println("\t\tPredicate constains :"); - for(Iterator varit = predicate.vardescriptors.iterator(); varit.hasNext();){ + Collection c = predicate.vardescriptors.values(); + for(Iterator varit = c.iterator(); varit.hasNext();){ VarDescriptor vard = (VarDescriptor)varit.next(); System.out.println("\t\t\tClass "+vard.getType().getClassDesc().getSymbol()); } @@ -205,28 +206,34 @@ public class SafetyAnalysis { } } - System.out.println("\n\n\n\tMyoptionals contains : "); - for(Iterator myoit = myoptionals.get(cdtemp).iterator(); myoit.hasNext();){ - MyOptional mm = (MyOptional)myoit.next(); - System.out.println("\t\tTASK "+mm.td.getSymbol()+"\n"); - System.out.println("\t\tDepth : "+mm.depth); + System.out.println("\n\n\n\tOptionaltaskdescriptors contains : "); + Collection c_otd = optionaltaskdescriptors.get(cdtemp).values(); + for(Iterator otd_it = c_otd.iterator(); otd_it.hasNext();){ + OptionalTaskDescriptor otd = (OptionalTaskDescriptor)otd_it.next(); + System.out.println("\t\tTASK "+otd.td.getSymbol()+" UID : "+otd.getuid()+"\n"); + System.out.println("\t\tDepth : "+otd.depth); System.out.println("\t\twith flags :"); - for(Iterator myfses = mm.flagstates.iterator(); myfses.hasNext();){ + for(Iterator myfses = otd.flagstates.iterator(); myfses.hasNext();){ System.out.println("\t\t\t"+((FlagState)myfses.next()).getTextLabel()); } System.out.println("\t\tand exitflags :"); - for(Iterator fseshash = mm.exitfses.iterator(); fseshash.hasNext();){ + for(Iterator fseshash = otd.exitfses.iterator(); fseshash.hasNext();){ HashSet temphs = (HashSet)fseshash.next(); System.out.println(""); for(Iterator exfses = temphs.iterator(); exfses.hasNext();){ System.out.println("\t\t\t"+((FlagState)exfses.next()).getTextLabel()); } } - Predicate predicate = mm.predicate; - System.out.println("\t\tPredicate constains :"); - for(Iterator varit = predicate.vardescriptors.iterator(); varit.hasNext();){ + Predicate predicate = otd.predicate; + System.out.println("\t\tPredicate contains :"); + Collection c = predicate.vardescriptors.values(); + for(Iterator varit = c.iterator(); varit.hasNext();){ VarDescriptor vard = (VarDescriptor)varit.next(); System.out.println("\t\t\tClass "+vard.getType().getClassDesc().getSymbol()); + HashSet temphash = predicate.flags.get(vard.getName()); + if(temphash == null) System.out.println("null hashset"); + else System.out.println("\t\t\t"+temphash.size()+" flag(s)"); + } System.out.println("\t\t------------"); } @@ -336,7 +343,7 @@ public class SafetyAnalysis { } - /*recursive method that returns a set of MyOptionals + /*recursive method that returns a set of OptionalTaskDescriptors The computation basically consist in returning the intersection or union of sets depending on the nature of the node : OR -> UNION @@ -358,29 +365,37 @@ public class SafetyAnalysis { } else temppredicate = combinePredicates(temppredicate, predicate); //if the tn is optional and there is no more nodes/presence of a loop - //create the MyOptional and return it as a singleton. + //create the OptionalTaskDescriptor and return it as a singleton. if( !((Iterator)tn.edges()).hasNext() || tn.isSelfLoop()){ HashSet fstemp = new HashSet(); fstemp.add(tn.getFS()); - MyOptional mo = new MyOptional(tn.getTD(), fstemp, depth, temppredicate); - myoptionals.get(processedclass).add(mo); - temp.add(mo); + OptionalTaskDescriptor otd = new OptionalTaskDescriptor(tn.getTD(), fstemp, depth, temppredicate); + //System.out.println("Create Optionaltaskdescriptor number "+otd.getuid()+" hascode "+otd.hashCode()); + if(optionaltaskdescriptors.get(processedclass).get(otd)!=null){ + otd = (OptionalTaskDescriptor)((Hashtable)optionaltaskdescriptors.get(processedclass)).get(otd); + } + else optionaltaskdescriptors.get(processedclass).put(otd, otd); + temp.add(otd); return temp; } else if(visited.contains(tn)){ return temp; } - //else compute the edges, create the MyOptional and add it to the set. + //else compute the edges, create the OptionalTaskDescriptor and add it to the set. else{ int newdepth = depth + 1; visited.add(tn); HashSet newhashset = new HashSet(visited); HashSet fstemp = new HashSet(); fstemp.add(tn.getFS()); - MyOptional mo = new MyOptional(tn.getTD(), fstemp, depth, temppredicate); - myoptionals.get(processedclass).add(mo); + OptionalTaskDescriptor otd = new OptionalTaskDescriptor(tn.getTD(), fstemp, depth, temppredicate); + //System.out.println("Create Optionaltaskdescriptor number "+otd.getuid()+" hascode "+otd.hashCode()); + if(optionaltaskdescriptors.get(processedclass).get(otd)!=null){ + otd = (OptionalTaskDescriptor)((Hashtable)optionaltaskdescriptors.get(processedclass)).get(otd); + } + else optionaltaskdescriptors.get(processedclass).put(otd, otd); temp = computeEdges(tn, newdepth, newhashset, temppredicate); - temp.add(mo); + temp.add(otd); return temp; } } @@ -446,7 +461,7 @@ public class SafetyAnalysis { TempFlagPair tfp=(TempFlagPair)it_tfp.next(); TempDescriptor tempd = tfp.getTemp(); if (classes.contains((ClassDescriptor)((TypeDescriptor)tempd.getType()).getClassDesc())) - return false; + return false;//return false if a taskexit modifies one of the other parameters } continue; // avoid queueing the return node if reachable } @@ -471,12 +486,12 @@ public class SafetyAnalysis { TypeDescriptor typed = td.getParamType(i); if(((ClassDescriptor)typed.getClassDesc()).getSymbol().compareTo(classname)!=0){ VarDescriptor vd = td.getParameter(i); - result.vardescriptors.add(vd); + result.vardescriptors.put(vd.getName(), vd); HashSet flaglist = new HashSet(); flaglist.add((FlagExpressionNode)td.getFlag(vd)); - result.flags.put( vd, flaglist); + result.flags.put( vd.getName(), flaglist); if((TagExpressionList)td.getTag(vd) != null) - result.tags.put( vd, (TagExpressionList)td.getTag(vd)); + result.tags.put( vd.getName(), (TagExpressionList)td.getTag(vd)); } } return result; @@ -672,76 +687,79 @@ public class SafetyAnalysis { return A; } - /*private void removeDoubles( HashSet A ){ - //remove duplicated MyOptionals (might happend in few cases) - Vector toremove = new Vector(); - int i = 0; - for(Iterator itA = A.iterator(); itA.hasNext();){ - MyOptional myA = (MyOptional)itA.next(); - i++; - Iterator itA2 = A.iterator(); - for(int j = 0; j> safeexecution, Hashtable myoptionals) { - - /* SymbolTable classes = state.getClassSymbolTable(); - for( Iterator it = classes.getAllDescriptorsIterator(); it.hasNext();){ - ClassDescriptor cd = (ClassDescriptor)it.next(); - output.println("Class "+cd.getSymbol()); - Hashtable flags=(Hashtable)flagorder.get(cd); - for (Iterator fit = cd.getFlags(); fit.hasNext();){ - FlagDescriptor fd = (FlagDescriptor)fit.next(); - int flagid=1<<((Integer)flags.get(fd)).intValue(); - output.println("\tFlag associated with "+fd.getSymbol()+" : 0x"+Integer.toHexString(flagid)+" bx"+Integer.toBinaryString(flagid)); - } - }*/ + void generateOptionalArrays(PrintWriter output, PrintWriter headers, Hashtable> safeexecution, Hashtable optionaltaskdescriptors) { + + //GENERATE HEADERS + headers.println("#include \"task.h\"\n\n"); + + //STRUCT PREDICATEMEMBER + headers.println("struct predicatemember{"); + headers.println("int type;"); + headers.println("int numdnfterms;"); + headers.println("int * flags;"); + headers.println("int numtags;"); + headers.println("int * tags;\n};\n\n"); + + //STRUCT EXITFLAGSTATE + headers.println("struct exitflagstate{"); + headers.println("int numflags;"); + headers.println("int * flags;"); + /* + headers.println("int numtags;"); + headers.println("int * tags;"); + */ + headers.println("\n};\n\n"); + + //STRUCT EXITSTATES + headers.println("struct exitstates{"); + headers.println("int numexitflagstates;"); + headers.println("struct exitflagstate * exitflagstatearray;\n};\n\n"); + + //STRUCT OPTIONALTASKDESCRIPTOR + headers.println("struct optionaltaskdescriptor{"); + headers.println("struct taskdescriptor * task;"); + headers.println("int numpredicatemembers;"); + headers.println("struct predicatemember * predicatememberarray;"); + headers.println("int numexitstates;"); + headers.println("struct existates * exitstatesarray;\n};\n\n"); + + //STRUCT FSANALYSISWRAPPER + headers.println("struct fsanalysiswrapper{"); + headers.println("int numflags;"); + headers.println("int * flags;"); + headers.println("int numtags;"); + headers.println("int * tags;"); + headers.println("int numoptionaltaskdescriptors;"); + headers.println("struct optionaltaskdescriptor * optionaltaskdescriptorarray;\n};\n\n"); + + //STRUCT CLASSANALYSISWRAPPER + headers.println("struct classanalyiswrapper{"); + headers.println("int type;"); + headers.println("int numfsanalysiswrappers;"); + headers.println("struct fsanalysiswrapper * fsanalysiswrapperarray;\n};\n\n"); + + Iterator taskit=state.getTaskSymbolTable().getDescriptorsIterator(); + while(taskit.hasNext()) { + TaskDescriptor td=(TaskDescriptor)taskit.next(); + headers.println("extern struct taskdescriptor task_"+td.getSafeSymbol()+";"); + } + + + + //GENERATE STRUCTS + output.println("#include \"optionalstruct.h\"\n\n"); + HashSet processedcd = new HashSet(); - int fscounter = 0; - int myocounter = 0; - int classescounter = 0; + Enumeration e = safeexecution.keys(); while (e.hasMoreElements()) { + //get the class ClassDescriptor cdtemp=(ClassDescriptor)e.nextElement(); - for(Iterator myoit = ((HashSet)myoptionals.get(cdtemp)).iterator(); myoit.hasNext();){ - MyOptional myo = (MyOptional)myoit.next(); - output.println("struct myoptional myoptional_"+"/*ID to determine*/"+"_"+"cdtemp.getsafeSymbol()"+"={"); - //insert code to generate the myoptional - output.println("};"); - } - classescounter++; + Hashtable flaginfo=(Hashtable)flagorder.get(cdtemp);//will be used several times + + //Generate the struct of optionals + if((Hashtable)optionaltaskdescriptors.get(cdtemp)==null) System.out.println("Was in cd :"+cdtemp.getSymbol()); + Collection c_otd = ((Hashtable)optionaltaskdescriptors.get(cdtemp)).values(); + if( !c_otd.isEmpty() ){ + for(Iterator otd_it = c_otd.iterator(); otd_it.hasNext();){ + OptionalTaskDescriptor otd = (OptionalTaskDescriptor)otd_it.next(); + + //generate the int arrays for the predicate + Predicate predicate = otd.predicate; + int predicateindex = 0; + //iterate through the classes concerned by the predicate + Collection c_vard = predicate.vardescriptors.values(); + for(Iterator vard_it = c_vard.iterator(); vard_it.hasNext();){ + VarDescriptor vard = (VarDescriptor)vard_it.next(); + TypeDescriptor typed = vard.getType(); + + //generate for flags + HashSet fen_hashset = predicate.flags.get(vard.getSymbol()); + output.println("int predicateflags_"+predicateindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"[]={"); + int numberterms=0; + if (fen_hashset!=null){ + for (Iterator fen_it = fen_hashset.iterator(); fen_it.hasNext();){ + FlagExpressionNode fen = (FlagExpressionNode)fen_it.next(); + if (fen==null) { + //output.println("0x0, 0x0 };"); + //numberterms+=1; + } + else { + + DNFFlag dflag=fen.getDNF(); + numberterms+=dflag.size(); + + Hashtable flags=(Hashtable)flagorder.get(typed.getClassDesc()); + + for(int j=0;j exitfses = otd.exitfses; + int exitindex = 0; + int nbexit = exitfses.size(); + int fsnumber; + + //iterate through possible exits + for(Iterator exitfseshash = exitfses.iterator(); exitfseshash.hasNext();){ + HashSet temp_hashset = (HashSet)exitfseshash.next(); + fsnumber = 0 ; + + //iterate through possible FSes corresponding to the exit + for(Iterator exfses = temp_hashset.iterator(); exfses.hasNext();){ + FlagState fs = (FlagState)exfses.next(); + fsnumber++; + output.println("int flags"+fsnumber+"_EXIT"+exitindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"[]={"); + int counterflag = 0; + for(Iterator flags = fs.getFlags(); flags.hasNext();){ + FlagDescriptor flagd = (FlagDescriptor)flags.next(); + int flagid=1<<((Integer)flaginfo.get(flagd)).intValue(); + if( flags.hasNext() ) output.print("0x"+Integer.toHexString(flagid)+" /*"+Integer.toBinaryString(flagid)+"*/,"); + else output.print("0x"+Integer.toHexString(flagid)+" /*"+Integer.toBinaryString(flagid)+"*/"); + counterflag++; + } + output.println("};\n"); + //do the same for tags; + //maybe not needed because no tag changes tolerated. + + //store the information into a struct + output.println("struct exitflagstate exitflagstate"+fsnumber+"_EXIT"+exitindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"={"); + output.println("/*number of flags*/"+counterflag+","); + output.println("flags"+fsnumber+"_EXIT"+exitindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()); + output.println("};\n"); + } + + //store fses corresponding to this exit into an array + output.println("struct exitflagstate * exitflagstatearray"+"_EXIT"+exitindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+" [] = {"); + for( int j = 0; j #include #include -- 2.34.1