+ generateFlagOrAnd(ffan, fm, lb, temp, output, ormask, andmask);
+ generateObjectDistribute(ffan, fm, lb, temp, output);
+ }
+ }
+
+ protected void generateFlagOrAnd(FlatFlagActionNode ffan, FlatMethod fm, LocalityBinding lb, TempDescriptor temp,
+ PrintWriter output, int ormask, int andmask) {
+ if (ffan.getTaskType()==FlatFlagActionNode.NEWOBJECT) {
+ output.println("flagorandinit("+generateTemp(fm, temp, lb)+", 0x"+Integer.toHexString(ormask)+", 0x"+Integer.toHexString(andmask)+");");
+ } else {
+ output.println("flagorand("+generateTemp(fm, temp, lb)+", 0x"+Integer.toHexString(ormask)+", 0x"+Integer.toHexString(andmask)+");");
+ }
+ }
+
+ protected void generateObjectDistribute(FlatFlagActionNode ffan, FlatMethod fm, LocalityBinding lb, TempDescriptor temp, PrintWriter output) {
+ output.println("enqueueObject("+generateTemp(fm, temp, lb)+");");
+ }
+
+ void generateOptionalHeader(PrintWriter headers) {
+
+ //GENERATE HEADERS
+ headers.println("#include \"task.h\"\n\n");
+ headers.println("#ifndef _OPTIONAL_STRUCT_");
+ headers.println("#define _OPTIONAL_STRUCT_");
+
+ //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 OPTIONALTASKDESCRIPTOR
+ headers.println("struct optionaltaskdescriptor{");
+ headers.println("struct taskdescriptor * task;");
+ headers.println("int index;");
+ headers.println("int numenterflags;");
+ headers.println("int * enterflags;");
+ headers.println("int numpredicatemembers;");
+ headers.println("struct predicatemember ** predicatememberarray;");
+ headers.println("};\n\n");
+
+ //STRUCT TASKFAILURE
+ headers.println("struct taskfailure {");
+ headers.println("struct taskdescriptor * task;");
+ headers.println("int index;");
+ headers.println("int numoptionaltaskdescriptors;");
+ headers.println("struct optionaltaskdescriptor ** optionaltaskdescriptorarray;\n};\n\n");
+
+ //STRUCT FSANALYSISWRAPPER
+ headers.println("struct fsanalysiswrapper{");
+ headers.println("int flags;");
+ headers.println("int numtags;");
+ headers.println("int * tags;");
+ headers.println("int numtaskfailures;");
+ headers.println("struct taskfailure ** taskfailurearray;");
+ headers.println("int numoptionaltaskdescriptors;");
+ headers.println("struct optionaltaskdescriptor ** optionaltaskdescriptorarray;\n};\n\n");
+
+ //STRUCT CLASSANALYSISWRAPPER
+ headers.println("struct classanalysiswrapper{");
+ headers.println("int type;");
+ headers.println("int numotd;");
+ headers.println("struct optionaltaskdescriptor ** otdarray;");
+ headers.println("int numfsanalysiswrappers;");
+ headers.println("struct fsanalysiswrapper ** fsanalysiswrapperarray;\n};");
+
+ headers.println("extern struct classanalysiswrapper * classanalysiswrapperarray[];");
+
+ Iterator taskit=state.getTaskSymbolTable().getDescriptorsIterator();
+ while(taskit.hasNext()) {
+ TaskDescriptor td=(TaskDescriptor)taskit.next();
+ headers.println("extern struct taskdescriptor task_"+td.getSafeSymbol()+";");
+ }
+
+ }
+
+ //CHECK OVER THIS -- THERE COULD BE SOME ERRORS HERE
+ int generateOptionalPredicate(Predicate predicate, OptionalTaskDescriptor otd, ClassDescriptor cdtemp, PrintWriter output) {
+ int predicateindex = 0;
+ //iterate through the classes concerned by the predicate
+ Set c_vard = predicate.vardescriptors;
+ Hashtable<TempDescriptor, Integer> slotnumber=new Hashtable<TempDescriptor, Integer>();
+ int current_slot=0;
+
+ 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) {
+ DNFFlag dflag=fen.getDNF();
+ numberterms+=dflag.size();
+
+ Hashtable flags=(Hashtable)flagorder.get(typed.getClassDesc());
+
+ for(int j=0;j<dflag.size();j++) {
+ if (j!=0)
+ output.println(",");
+ Vector term=dflag.get(j);
+ int andmask=0;
+ int checkmask=0;
+ for(int k=0;k<term.size();k++) {
+ DNFFlagAtom dfa=(DNFFlagAtom)term.get(k);
+ FlagDescriptor fd=dfa.getFlag();
+ boolean negated=dfa.getNegated();
+ int flagid=1<<((Integer)flags.get(fd)).intValue();
+ andmask|=flagid;
+ if (!negated)
+ checkmask|=flagid;
+ }
+ output.print("/*andmask*/0x"+Integer.toHexString(andmask)+", /*checkmask*/0x"+Integer.toHexString(checkmask));
+ }
+ }
+ }
+ }
+ output.println("};\n");
+
+ //generate for tags
+ TagExpressionList tagel = predicate.tags.get(vard.getSymbol());
+ output.println("int predicatetags_"+predicateindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"[]={");
+ int numtags = 0;
+ if (tagel!=null){
+ for(int j=0;j<tagel.numTags();j++) {
+ if (j!=0)
+ output.println(",");
+ TempDescriptor tmp=tagel.getTemp(j);
+ if (!slotnumber.containsKey(tmp)) {
+ Integer slotint=new Integer(current_slot++);
+ slotnumber.put(tmp,slotint);
+ }
+ int slot=slotnumber.get(tmp).intValue();
+ output.println("/* slot */"+ slot+", /*tagid*/"+state.getTagId(tmp.getTag()));
+ }
+ numtags = tagel.numTags();
+ }
+ output.println("};");
+
+ //store the result into a predicatemember struct
+ output.println("struct predicatemember predicatemember_"+predicateindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"={");
+ output.println("/*type*/"+typed.getClassDesc().getId()+",");
+ output.println("/* number of dnf terms */"+numberterms+",");
+ output.println("predicateflags_"+predicateindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+",");
+ output.println("/* number of tag */"+numtags+",");
+ output.println("predicatetags_"+predicateindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+",");
+ output.println("};\n");
+ predicateindex++;
+ }
+
+
+ //generate an array that stores the entire predicate
+ output.println("struct predicatemember * predicatememberarray_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"[]={");
+ for( int j = 0; j<predicateindex; j++){
+ if( j != predicateindex-1)output.println("&predicatemember_"+j+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+",");
+ else output.println("&predicatemember_"+j+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol());
+ }
+ output.println("};\n");
+ return predicateindex;
+ }
+
+
+ void generateOptionalArrays(PrintWriter output, PrintWriter headers, Hashtable<ClassDescriptor, Hashtable<FlagState, Set<OptionalTaskDescriptor>>> safeexecution, Hashtable optionaltaskdescriptors) {
+ generateOptionalHeader(headers);
+ //GENERATE STRUCTS
+ output.println("#include \"optionalstruct.h\"\n\n");
+ output.println("#include \"stdlib.h\"\n");
+
+ HashSet processedcd = new HashSet();
+ int maxotd=0;
+ Enumeration e = safeexecution.keys();
+ while (e.hasMoreElements()) {
+ int numotd=0;
+ //get the class
+ ClassDescriptor cdtemp=(ClassDescriptor)e.nextElement();
+ Hashtable flaginfo=(Hashtable)flagorder.get(cdtemp);//will be used several times
+
+ //Generate the struct of optionals
+ Collection c_otd = ((Hashtable)optionaltaskdescriptors.get(cdtemp)).values();
+ numotd = c_otd.size();
+ if(maxotd<numotd) maxotd = numotd;
+ 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 = generateOptionalPredicate(predicate, otd, cdtemp, output);
+ TreeSet<Integer> fsset=new TreeSet<Integer>();
+ //iterate through possible FSes corresponding to
+ //the state when entering
+
+ for(Iterator fses = otd.enterflagstates.iterator(); fses.hasNext();){
+ FlagState fs = (FlagState)fses.next();
+ int flagid=0;
+ for(Iterator flags = fs.getFlags(); flags.hasNext();){
+ FlagDescriptor flagd = (FlagDescriptor)flags.next();
+ int id=1<<((Integer)flaginfo.get(flagd)).intValue();
+ flagid|=id;
+ }
+ fsset.add(new Integer(flagid));
+ //tag information not needed because tag
+ //changes are not tolerated.
+ }
+
+ output.println("int enterflag_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"[]={");
+ boolean needcomma=false;
+ for(Iterator<Integer> it=fsset.iterator();it.hasNext();) {
+ if(needcomma)
+ output.print(", ");
+ output.println(it.next());
+ }
+
+ output.println("};\n");
+
+
+ //generate optionaltaskdescriptor that actually
+ //includes exit fses, predicate and the task
+ //concerned
+ output.println("struct optionaltaskdescriptor optionaltaskdescriptor_"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"={");
+ output.println("&task_"+otd.td.getSafeSymbol()+",");
+ output.println("/*index*/"+otd.getIndex()+",");
+ output.println("/*number of enter flags*/"+fsset.size()+",");
+ output.println("enterflag_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+",");
+ output.println("/*number of members */"+predicateindex+",");
+ output.println("predicatememberarray_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+",");
+ output.println("};\n");
+ }
+ } else
+ continue;
+ // if there are no optionals, there is no need to build the rest of the struct
+
+ output.println("struct optionaltaskdescriptor * otdarray"+cdtemp.getSafeSymbol()+"[]={");
+ c_otd = ((Hashtable)optionaltaskdescriptors.get(cdtemp)).values();
+ if( !c_otd.isEmpty() ){
+ boolean needcomma=false;
+ for(Iterator otd_it = c_otd.iterator(); otd_it.hasNext();){
+ OptionalTaskDescriptor otd = (OptionalTaskDescriptor)otd_it.next();
+ if(needcomma)
+ output.println(",");
+ needcomma=true;
+ output.println("&optionaltaskdescriptor_"+otd.getuid()+"_"+cdtemp.getSafeSymbol());
+ }
+ }
+ output.println("};\n");
+
+ //get all the possible flagstates reachable by an object
+ Hashtable hashtbtemp = safeexecution.get(cdtemp);
+ int fscounter = 0;
+ TreeSet fsts=new TreeSet(new FlagComparator(flaginfo));
+ fsts.addAll(hashtbtemp.keySet());
+ for(Iterator fsit=fsts.iterator();fsit.hasNext();) {
+ FlagState fs = (FlagState)fsit.next();
+ fscounter++;
+
+ //get the set of OptionalTaskDescriptors corresponding
+ HashSet<OptionalTaskDescriptor> availabletasks = (HashSet<OptionalTaskDescriptor>)hashtbtemp.get(fs);
+ //iterate through the OptionalTaskDescriptors and
+ //store the pointers to the optionals struct (see on
+ //top) into an array
+
+ output.println("struct optionaltaskdescriptor * optionaltaskdescriptorarray_FS"+fscounter+"_"+cdtemp.getSafeSymbol()+"[] = {");
+ for(Iterator<OptionalTaskDescriptor> mos = ordertd(availabletasks).iterator(); mos.hasNext();){
+ OptionalTaskDescriptor mm = mos.next();
+ if(!mos.hasNext())
+ output.println("&optionaltaskdescriptor_"+mm.getuid()+"_"+cdtemp.getSafeSymbol());
+ else
+ output.println("&optionaltaskdescriptor_"+mm.getuid()+"_"+cdtemp.getSafeSymbol()+",");
+ }
+
+ output.println("};\n");
+
+ //process flag information (what the flag after failure is) so we know what optionaltaskdescriptors to choose.
+
+ int flagid=0;
+ for(Iterator flags = fs.getFlags(); flags.hasNext();){
+ FlagDescriptor flagd = (FlagDescriptor)flags.next();
+ int id=1<<((Integer)flaginfo.get(flagd)).intValue();
+ flagid|=id;
+ }
+
+ //process tag information
+
+ int tagcounter = 0;
+ boolean first = true;
+ Enumeration tag_enum = fs.getTags();
+ output.println("int tags_FS"+fscounter+"_"+cdtemp.getSafeSymbol()+"[]={");
+ while(tag_enum.hasMoreElements()){
+ tagcounter++;
+ TagDescriptor tagd = (TagDescriptor)tag_enum.nextElement();
+ if(first==true)
+ first = false;
+ else
+ output.println(", ");
+ output.println("/*tagid*/"+state.getTagId(tagd));
+ }
+ output.println("};");
+
+ Set<TaskIndex> tiset=sa.getTaskIndex(fs);
+ for(Iterator<TaskIndex> itti=tiset.iterator();itti.hasNext();) {
+ TaskIndex ti=itti.next();
+ if (ti.isRuntime())
+ continue;
+
+ Set<OptionalTaskDescriptor> otdset=sa.getOptions(fs, ti);
+
+ output.print("struct optionaltaskdescriptor * optionaltaskfailure_FS"+fscounter+"_"+ti.getTask().getSafeSymbol()+"_"+ti.getIndex()+"_array[] = {");
+ boolean needcomma=false;
+ for(Iterator<OptionalTaskDescriptor> otdit=ordertd(otdset).iterator();otdit.hasNext();) {
+ OptionalTaskDescriptor otd=otdit.next();
+ if(needcomma)
+ output.print(", ");
+ needcomma=true;
+ output.println("&optionaltaskdescriptor_"+otd.getuid()+"_"+cdtemp.getSafeSymbol());
+ }
+ output.println("};");
+
+ output.print("struct taskfailure taskfailure_FS"+fscounter+"_"+ti.getTask().getSafeSymbol()+"_"+ti.getIndex()+" = {");
+ output.print("&task_"+ti.getTask().getSafeSymbol()+", ");
+ output.print(ti.getIndex()+", ");
+ output.print(otdset.size()+", ");
+ output.print("optionaltaskfailure_FS"+fscounter+"_"+ti.getTask().getSafeSymbol()+"_"+ti.getIndex()+"_array");
+ output.println("};");
+ }
+
+ tiset=sa.getTaskIndex(fs);
+ boolean needcomma=false;
+ int runtimeti=0;
+ output.println("struct taskfailure * taskfailurearray"+fscounter+"_"+cdtemp.getSafeSymbol()+"[]={");
+ for(Iterator<TaskIndex> itti=tiset.iterator();itti.hasNext();) {
+ TaskIndex ti=itti.next();
+ if (ti.isRuntime()) {
+ runtimeti++;
+ continue;
+ }
+ if (needcomma)
+ output.print(", ");
+ needcomma=true;
+ output.print("&taskfailure_FS"+fscounter+"_"+ti.getTask().getSafeSymbol()+"_"+ti.getIndex());
+ }
+ output.println("};\n");
+
+ //Store the result in fsanalysiswrapper
+
+ output.println("struct fsanalysiswrapper fsanalysiswrapper_FS"+fscounter+"_"+cdtemp.getSafeSymbol()+"={");
+ output.println("/*flag*/"+flagid+",");
+ output.println("/* number of tags*/"+tagcounter+",");
+ output.println("tags_FS"+fscounter+"_"+cdtemp.getSafeSymbol()+",");
+ output.println("/* numtask failures */"+(tiset.size()-runtimeti)+",");
+ output.println("taskfailurearray"+fscounter+"_"+cdtemp.getSafeSymbol()+",");
+ output.println("/* number of optionaltaskdescriptors */"+availabletasks.size()+",");
+ output.println("optionaltaskdescriptorarray_FS"+fscounter+"_"+cdtemp.getSafeSymbol());
+ output.println("};\n");
+
+ }
+
+ //Build the array of fsanalysiswrappers
+ output.println("struct fsanalysiswrapper * fsanalysiswrapperarray_"+cdtemp.getSafeSymbol()+"[] = {");
+ boolean needcomma=false;
+ for(int i = 0; i<fscounter; i++){
+ if (needcomma) output.print(",");
+ output.println("&fsanalysiswrapper_FS"+(i+1)+"_"+cdtemp.getSafeSymbol());
+ needcomma=true;
+ }
+ output.println("};");
+
+ //Build the classanalysiswrapper referring to the previous array
+ output.println("struct classanalysiswrapper classanalysiswrapper_"+cdtemp.getSafeSymbol()+"={");
+ output.println("/*type*/"+cdtemp.getId()+",");
+ output.println("/*numotd*/"+numotd+",");
+ output.println("otdarray"+cdtemp.getSafeSymbol()+",");
+ output.println("/* number of fsanalysiswrappers */"+fscounter+",");
+ output.println("fsanalysiswrapperarray_"+cdtemp.getSafeSymbol()+"};\n");
+ processedcd.add(cdtemp);
+ }
+
+ //build an array containing every classes for which code has been build
+ output.println("struct classanalysiswrapper * classanalysiswrapperarray[]={");
+ for(int i=0;i<state.numClasses();i++) {
+ ClassDescriptor cn=cdarray[i];
+ if (i>0)
+ output.print(", ");
+ if (processedcd.contains(cn))
+ output.print("&classanalysiswrapper_"+cn.getSafeSymbol());
+ else
+ output.print("NULL");
+ }
+ output.println("};");
+
+ output.println("#define MAXOTD "+maxotd);
+ headers.println("#endif");
+ }
+
+ public List<OptionalTaskDescriptor> ordertd(Set<OptionalTaskDescriptor> otdset) {
+ Relation r=new Relation();
+ for(Iterator<OptionalTaskDescriptor>otdit=otdset.iterator();otdit.hasNext();) {
+ OptionalTaskDescriptor otd=otdit.next();
+ TaskIndex ti=new TaskIndex(otd.td, otd.getIndex());
+ r.put(ti, otd);