Robust/src/IR/Flat/BuildCodeMGC.java

   1 package IR.Flat;
   2
   3 import java.io.FileOutputStream;
   4 import java.io.PrintWriter;
   5 import java.util.HashSet;
   6 import java.util.Hashtable;
   7 import java.util.Iterator;
   8 import java.util.LinkedList;
   9 import java.util.Queue;
  10 import java.util.Set;
  11 import java.util.Vector;
  12
  13 import Analysis.Locality.LocalityBinding;
  14 import Analysis.Scheduling.Schedule;
  15 import Analysis.TaskStateAnalysis.FEdge;
  16 import Analysis.TaskStateAnalysis.FlagState;
  17 import Analysis.TaskStateAnalysis.SafetyAnalysis;
  18 import Analysis.OwnershipAnalysis.AllocationSite;
  19 import Analysis.OwnershipAnalysis.OwnershipAnalysis;
  20 import Analysis.OwnershipAnalysis.HeapRegionNode;
  21 import Analysis.Prefetch.*;
  22 import IR.ClassDescriptor;
  23 import IR.Descriptor;
  24 import IR.FlagDescriptor;
  25 import IR.MethodDescriptor;
  26 import IR.State;
  27 import IR.TagVarDescriptor;
  28 import IR.TaskDescriptor;
  29 import IR.TypeDescriptor;
  30 import IR.TypeUtil;
  31 import IR.VarDescriptor;
  32 import IR.Tree.DNFFlag;
  33 import IR.Tree.DNFFlagAtom;
  34 import IR.Tree.FlagExpressionNode;
  35 import IR.Tree.TagExpressionList;
  36
  37 public class BuildCodeMGC extends BuildCode {
  38   int coreNum;
  39   int tcoreNum;
  40   int gcoreNum;
  41   int startupcorenum;    // record the core containing startup task, s
  42   // uppose only one core can have startup object
  43
  44   public BuildCodeMGC(State st,
  45                       Hashtable temptovar,
  46                       TypeUtil typeutil,
  47                       SafetyAnalysis sa,
  48                       int coreNum,
  49                       int tcoreNum,
  50                       int gcoreNum,
  51                       PrefetchAnalysis pa) {
  52     super(st, temptovar, typeutil, sa, pa);
  53     this.coreNum = coreNum; // # of the active cores
  54     this.tcoreNum = tcoreNum; // # of the total number of cores
  55     this.gcoreNum = gcoreNum; // # of the cores for gc if any
  56     this.startupcorenum = 0;
  57   }
  58
  59   public void buildCode() {
  60     /* Create output streams to write to */
  61     PrintWriter outclassdefs=null;
  62     PrintWriter outstructs=null;
  63     PrintWriter outmethodheader=null;
  64     PrintWriter outmethod=null;
  65     PrintWriter outvirtual=null;
  66
  67     try {
  68       outstructs=new PrintWriter(new FileOutputStream(PREFIX+"structdefs.h"), true);
  69       outmethodheader=new PrintWriter(new FileOutputStream(PREFIX+"methodheaders.h"), true);
  70       outclassdefs=new PrintWriter(new FileOutputStream(PREFIX+"classdefs.h"), true);
  71       outvirtual=new PrintWriter(new FileOutputStream(PREFIX+"virtualtable.h"), true);
  72       outmethod=new PrintWriter(new FileOutputStream(PREFIX+"methods.c"), true);
  73     } catch (Exception e) {
  74       e.printStackTrace();
  75       System.exit(-1);
  76     }
  77
  78     /* Build the virtual dispatch tables */
  79     super.buildVirtualTables(outvirtual);
  80
  81     /* Output includes */
  82     outmethodheader.println("#ifndef METHODHEADERS_H");
  83     outmethodheader.println("#define METHODHEADERS_H");
  84     outmethodheader.println("#include \"structdefs.h\"");
  85
  86     /* Output Structures */
  87     super.outputStructs(outstructs);
  88
  89     // Output the C class declarations
  90     // These could mutually reference each other
  91     super.outputClassDeclarations(outclassdefs);
  92
  93     // Output function prototypes and structures for parameters
  94     Iterator it=state.getClassSymbolTable().getDescriptorsIterator();
  95     int numclasses = this.state.numClasses();
  96     while(it.hasNext()) {
  97       ClassDescriptor cn=(ClassDescriptor)it.next();
  98       super.generateCallStructs(cn, outclassdefs, outstructs, outmethodheader);
  99     }
 100     outclassdefs.close();
 101
 102     /* Build the actual methods */
 103     super.outputMethods(outmethod);
 104
 105     /* Record maximum number of task parameters */
 106     //outstructs.println("#define MAXTASKPARAMS "+maxtaskparams);
 107     /* Record maximum number of all types, i.e. length of classsize[] */
 108     outstructs.println("#define NUMTYPES "+(state.numClasses() + state.numArrays()));
 109     /* Record number of total cores */
 110     outstructs.println("#define NUMCORES "+this.tcoreNum);
 111     /* Record number of active cores */
 112     outstructs.println("#define NUMCORESACTIVE "+this.coreNum); // this.coreNum
 113                                     // can be reset by the scheduling analysis
 114     /* Record number of garbage collection cores */
 115     outstructs.println("#ifdef MULTICORE_GC");
 116     outstructs.println("#define NUMCORES4GC "+this.gcoreNum);
 117     outstructs.println("#endif");
 118     /* Record number of core containing startup task */
 119     outstructs.println("#define STARTUPCORE "+this.startupcorenum);
 120
 121     if (state.main!=null) {
 122     /* Generate main method */
 123       outputMainMethod(outmethod);
 124     }
 125
 126     /* Close files */
 127     outmethodheader.println("#endif");
 128     outmethodheader.close();
 129     outmethod.close();
 130     outstructs.println("#endif");
 131     outstructs.close();
 132   }
 133
 134   protected void outputMainMethod(PrintWriter outmethod) {
 135     outmethod.println("int mgc_main(int argc, const char *argv[]) {");
 136     outmethod.println("  int i;");
 137
 138     if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
 139       outmethod.println("  struct ArrayObject * stringarray=allocate_newarray(NULL, STRINGARRAYTYPE, argc-1);");
 140     } else {
 141       outmethod.println("  struct ArrayObject * stringarray=allocate_newarray(STRINGARRAYTYPE, argc-1);");
 142     }
 143     outmethod.println("  for(i=1;i<argc;i++) {");
 144     outmethod.println("    int length=strlen(argv[i]);");
 145     if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
 146       outmethod.println("    struct ___String___ *newstring=NewString(NULL, argv[i], length);");
 147     } else {
 148       outmethod.println("    struct ___String___ *newstring=NewString(argv[i], length);");
 149     }
 150     outmethod.println("    ((void **)(((char *)& stringarray->___length___)+sizeof(int)))[i-1]=newstring;");
 151     outmethod.println("  }");
 152
 153     MethodDescriptor md=typeutil.getMain();
 154     ClassDescriptor cd=typeutil.getMainClass();
 155
 156     outmethod.println("   {");
 157     if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
 158       outmethod.print("       struct "+cd.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params __parameterlist__={");
 159       outmethod.println("1, NULL,"+"stringarray};");
 160       outmethod.println("     "+cd.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(& __parameterlist__);");
 161     } else {
 162       outmethod.println("     "+cd.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(stringarray);");
 163     }
 164     outmethod.println("   }");
 165
 166     outmethod.println("}");
 167   }
 168 }