Added SESE definition support to compiler

diff --git a/Robust/src/IR/Flat/BuildCode.java b/Robust/src/IR/Flat/BuildCode.java
index 402e99f67ae56b14438e6a02c19a2b2ef4a5840b..14d135ddb528b93d62cee97f396b8b0d7002f989 100644 (file)
--- a/Robust/src/IR/Flat/BuildCode.java
+++ b/Robust/src/IR/Flat/BuildCode.java
@@ -1431,6 +1431,14 @@ public class BuildCode {
       generateFlatAtomicExitNode(fm, lb, (FlatAtomicExitNode) fn, output);
       return;
 
+    case FKind.FlatSESEEnterNode:
+      generateFlatSESEEnterNode(fm, lb, (FlatSESEEnterNode) fn, output);
+      return;
+
+    case FKind.FlatSESEExitNode:
+      generateFlatSESEExitNode(fm, lb, (FlatSESEExitNode) fn, output);
+      return;
+
     case FKind.FlatGlobalConvNode:
       generateFlatGlobalConvNode(fm, lb, (FlatGlobalConvNode) fn, output);
       return;
@@ -1761,6 +1769,14 @@ public class BuildCode {
     output.println("}");
   }
 
+  public void generateFlatSESEEnterNode(FlatMethod fm,  LocalityBinding lb, FlatSESEEnterNode faen, PrintWriter output) {
+    
+  }
+
+  public void generateFlatSESEExitNode(FlatMethod fm,  LocalityBinding lb, FlatSESEExitNode faen, PrintWriter output) {
+    
+  }
+
   private void generateFlatCheckNode(FlatMethod fm,  LocalityBinding lb, FlatCheckNode fcn, PrintWriter output) {
     if (state.CONSCHECK) {
       String specname=fcn.getSpec();

diff --git a/Robust/src/IR/Flat/BuildFlat.java b/Robust/src/IR/Flat/BuildFlat.java
index 243f6a88d1b3aa6c262dff902284ccdbef1c2fae..9ed529d8da3a5e75a8316407988618925e3756e5 100644 (file)
--- a/Robust/src/IR/Flat/BuildFlat.java
+++ b/Robust/src/IR/Flat/BuildFlat.java
@@ -1009,6 +1009,20 @@ public class BuildFlat {
     return new NodePair(faen, faexn);
   }
 
+  private NodePair flattenSESENode(SESENode sn) {
+    if( sn.isStart() ) {
+      FlatSESEEnterNode fsen=new FlatSESEEnterNode(sn);
+      sn.setFlatEnter(fsen);
+      return new NodePair(fsen, fsen);
+    }
+
+    FlatSESEExitNode fsexn=new FlatSESEExitNode(sn);
+    sn.setFlatExit(fsexn);
+    fsexn.setFlatEnter( sn.getStart().getFlatEnter() );
+    sn.getStart().getFlatEnter().setFlatExit( fsexn );
+    return new NodePair(fsexn, fsexn);
+  }
+
   private NodePair flattenBlockStatementNode(BlockStatementNode bsn) {
     switch(bsn.kind()) {
     case Kind.BlockExpressionNode:
@@ -1038,6 +1052,8 @@ public class BuildFlat {
     case Kind.AtomicNode:
       return flattenAtomicNode((AtomicNode)bsn);
 
+    case Kind.SESENode:
+      return flattenSESENode((SESENode)bsn);
     }
     throw new Error();
   }

diff --git a/Robust/src/IR/Flat/FKind.java b/Robust/src/IR/Flat/FKind.java
index 9789a3af3add17149b93f93414324e0032605903..4108296a922ec4d222706626bc9c0cf255e898a0 100644 (file)
--- a/Robust/src/IR/Flat/FKind.java
+++ b/Robust/src/IR/Flat/FKind.java
@@ -23,4 +23,6 @@ public class FKind {
   public static final int FlatGlobalConvNode=20;
   public static final int FlatPrefetchNode=21;
   public static final int FlatOffsetNode=22;
+  public static final int FlatSESEEnterNode=23;
+  public static final int FlatSESEExitNode=24;
 }

diff --git a/Robust/src/IR/Flat/FlatSESEEnterNode.java b/Robust/src/IR/Flat/FlatSESEEnterNode.java
new file mode 100644 (file)
index 0000000..344526f
--- /dev/null
+++ b/Robust/src/IR/Flat/FlatSESEEnterNode.java
@@ -0,0 +1,39 @@
+package IR.Flat;
+import IR.Tree.SESENode;
+import java.util.Vector;
+
+public class FlatSESEEnterNode extends FlatNode {
+  private static int identifier=0;
+  private int id;
+  protected FlatSESEExitNode exit;
+  protected SESENode treeNode;
+
+  public FlatSESEEnterNode( SESENode sn ) {
+    this.id=identifier++;
+    treeNode = sn;
+  }
+
+  public SESENode getTreeNode() {
+    return treeNode;
+  }
+
+  public int getIdentifier() {
+    return id;
+  }
+
+  public String toString() {
+    return "sese enter";
+  }
+
+  public void setFlatExit( FlatSESEExitNode fsexn ) {
+    exit = fsexn;
+  }
+
+  public FlatSESEExitNode getFlatExit() {
+    return exit;
+  }
+
+  public int kind() {
+    return FKind.FlatSESEEnterNode;
+  }
+}

diff --git a/Robust/src/IR/Flat/FlatSESEExitNode.java b/Robust/src/IR/Flat/FlatSESEExitNode.java
new file mode 100644 (file)
index 0000000..a5b4f9b
--- /dev/null
+++ b/Robust/src/IR/Flat/FlatSESEExitNode.java
@@ -0,0 +1,32 @@
+package IR.Flat;
+import IR.Tree.SESENode;
+import java.util.Vector;
+
+public class FlatSESEExitNode extends FlatNode {
+  protected SESENode treeNode;
+  FlatSESEEnterNode enter;
+
+  public FlatSESEExitNode( SESENode sn ) {
+    treeNode = sn;
+  }
+
+  public SESENode getTreeNode() {
+    return treeNode;
+  }
+
+  public void setFlatEnter( FlatSESEEnterNode fsen ) {
+    enter = fsen;
+  }
+
+  public FlatSESEEnterNode getSESEEnter() {
+    return enter;
+  }
+
+  public String toString() {
+    return "seseexit";
+  }
+
+  public int kind() {
+    return FKind.FlatSESEExitNode;
+  }
+}

diff --git a/Robust/src/IR/Tree/BuildIR.java b/Robust/src/IR/Tree/BuildIR.java
index d6b84a1d2b74cec0f214d7d8e2a37b501d0d1a43..d577cbb115e6a9eded0a984449ac9160af9c8bdc 100644 (file)
--- a/Robust/src/IR/Tree/BuildIR.java
+++ b/Robust/src/IR/Tree/BuildIR.java
@@ -599,6 +599,15 @@ public class BuildIR {
     return bn;
   }
 
+  public Vector parseSESEBlock(Vector parentbs, ParseNode pn) {
+    ParseNodeVector pnv=pn.getChildren();
+    Vector bv=new Vector();
+    for(int i=0; i<pnv.size(); i++) {
+      bv.addAll(parseBlockStatement(pnv.elementAt(i)));
+    }
+    return bv;
+  }
+
   public Vector parseBlockStatement(ParseNode pn) {
     Vector blockstatements=new Vector();
     if (isNode(pn,"tag_declaration")) {
@@ -685,6 +694,14 @@ public class BuildIR {
       ExpressionNode condition=parseExpression(pn.getChild("condition").getFirstChild());
       BlockNode body=parseSingleBlock(pn.getChild("statement").getFirstChild());
       blockstatements.add(new LoopNode(condition,body,LoopNode.DOWHILELOOP));
+    } else if (isNode(pn,"sese")) {
+      SESENode start=new SESENode();
+      SESENode end  =new SESENode();
+      start.setEnd( end   );
+      end.setStart( start );
+      blockstatements.add(start);
+      blockstatements.addAll(parseSESEBlock(blockstatements,pn.getChild("body").getFirstChild()));
+      blockstatements.add(end);
     } else {
       System.out.println("---------------");
       System.out.println(pn.PPrint(3,true));

diff --git a/Robust/src/IR/Tree/Kind.java b/Robust/src/IR/Tree/Kind.java
index e57358d5acd37642723dd79b4309aa77c231421b..82afcf5fbbd41af88c8688c501f4f10070e3b89a 100644 (file)
--- a/Robust/src/IR/Tree/Kind.java
+++ b/Robust/src/IR/Tree/Kind.java
@@ -23,4 +23,5 @@ public class Kind {
   public final static int TagDeclarationNode=20;
   public final static int AtomicNode=21;
   public final static int OffsetNode=22;
+  public final static int SESENode=23;
 }

diff --git a/Robust/src/IR/Tree/Modifiers.java b/Robust/src/IR/Tree/Modifiers.java
index 5b7b0ea9b2e26de9a14d2e089d7fddb2524639b4..7f2ae46ef570c934350dec97c461ed9fabad42b6 100644 (file)
--- a/Robust/src/IR/Tree/Modifiers.java
+++ b/Robust/src/IR/Tree/Modifiers.java
@@ -9,10 +9,11 @@ public class Modifiers {
   public static final int FINAL=32;
   public static final int NATIVE=64;
   public static final int SYNCHRONIZED=128;
-  public static final int ATOMIC=2048;
 //     TRANSIENT=256
 //     VOLATILE=512
 //     STRICTFP=1024
+  public static final int ATOMIC=2048;
+
 
   private int value;
 

diff --git a/Robust/src/IR/Tree/SESENode.java b/Robust/src/IR/Tree/SESENode.java
new file mode 100644 (file)
index 0000000..64d0dfb
--- /dev/null
+++ b/Robust/src/IR/Tree/SESENode.java
@@ -0,0 +1,70 @@
+package IR.Tree;
+import IR.Flat.FlatSESEEnterNode;
+import IR.Flat.FlatSESEExitNode;
+
+public class SESENode extends BlockStatementNode {
+
+  protected SESENode start;
+  protected SESENode end;
+
+  protected FlatSESEEnterNode enter;
+  protected FlatSESEExitNode  exit;
+
+
+  public SESENode() {
+    start = null;
+    end   = null;
+    enter = null;
+    exit  = null;
+  }
+
+
+  public void setStart( SESENode n ) {
+    start = n;
+  }
+
+  public void setEnd( SESENode n ) {
+    end = n;
+  }
+
+  public boolean isStart() {
+    return end != null;
+  }
+
+  public SESENode getStart() {
+    return start;
+  }
+
+  public SESENode getEnd() {
+    return end;
+  }
+
+  public void setFlatEnter( FlatSESEEnterNode fsen ) {
+    enter = fsen;
+  }
+
+  public void setFlatExit( FlatSESEExitNode fsexn ) {
+    exit = fsexn;
+  }
+
+  public FlatSESEEnterNode getFlatEnter() {
+    return enter;
+  }
+
+  public FlatSESEExitNode getFlatExit() {
+    return exit;
+  }
+
+
+  public String printNode(int indent) {
+    if( isStart() ) {
+      return printSpace(indent)+"START SESE\n";
+    } else {
+      return printSpace(indent)+"END SESE\n";
+    }
+  }
+
+  public int kind() {
+    return Kind.SESENode;
+  }
+}

diff --git a/Robust/src/IR/Tree/SemanticCheck.java b/Robust/src/IR/Tree/SemanticCheck.java
index 708ae78c55b7a6cfedefd5ae0dc3f20b46305ff3..045961a68ee837d98322ddb79a2ea99a348480c4 100644 (file)
--- a/Robust/src/IR/Tree/SemanticCheck.java
+++ b/Robust/src/IR/Tree/SemanticCheck.java
@@ -266,7 +266,12 @@ public class SemanticCheck {
     case Kind.AtomicNode:
       checkAtomicNode(md, nametable, (AtomicNode)bsn);
       return;
-    }
+  
+    case Kind.SESENode:
+      // do nothing, no semantic check for SESEs
+      return;
+    }  
+
     throw new Error();
   }
 

diff --git a/Robust/src/Lex/Keyword.java b/Robust/src/Lex/Keyword.java
index 40f078db888c5d5e03e82f53d5add87a21c7d4d4..634b0a9ead3f1863dcafb23d7a4a4b0239309229 100644 (file)
--- a/Robust/src/Lex/Keyword.java
+++ b/Robust/src/Lex/Keyword.java
@@ -54,7 +54,7 @@ class Keyword extends Token {
     key_table.put("private", new Integer(Sym.PRIVATE));
     key_table.put("protected", new Integer(Sym.PROTECTED));
     key_table.put("public", new Integer(Sym.PUBLIC));
-    key_table.put("return", new Integer(Sym.RETURN));
+    key_table.put("return", new Integer(Sym.RETURN));    
     key_table.put("short", new Integer(Sym.SHORT));
     key_table.put("static", new Integer(Sym.STATIC));
     key_table.put("strictfp", new Integer(Sym.STRICTFP));
@@ -81,5 +81,7 @@ class Keyword extends Token {
     key_table.put("global", new Integer(Sym.GLOBAL));
     //Keywords for hacking prefetch calls in java
     key_table.put("getoffset", new Integer(Sym.GETOFFSET));
+    //Keywords for coarse-grain parallelization
+    key_table.put("sese", new Integer(Sym.SESE));
   }
 }

diff --git a/Robust/src/Lex/Lexer.java b/Robust/src/Lex/Lexer.java
index 18b935acc88f62b1f3fe84a0d235c7b20cfd7c5d..7aaa638a869983619f9c1585ed80a1a3eda8c23b 100644 (file)
--- a/Robust/src/Lex/Lexer.java
+++ b/Robust/src/Lex/Lexer.java
@@ -262,7 +262,7 @@ public class Lexer {
     "implements", "import", "instanceof", "int", "interface", "isavailable",
     "long",
     "native", "new", "optional", "package", "private", "protected", "public",
-    "return", "short", "static", "strictfp", "super", "switch", "synchronized",
+    "return", "sese", "short", "static", "strictfp", "super", "switch", "synchronized",
     "tag", "task", "taskexit", //keywords for failure aware computation
     "this", "throw", "throws", "transient", "try", "void",
     "volatile", "while"

diff --git a/Robust/src/Parse/java14.cup b/Robust/src/Parse/java14.cup
index ad4063596df41d34e56b94b0deca2b2b6e2dd757..a41025fb3a56e01f3d3e68649389dd21bbcdb34a 100644 (file)
--- a/Robust/src/Parse/java14.cup
+++ b/Robust/src/Parse/java14.cup
@@ -260,6 +260,10 @@ terminal GETOFFSET;
 non terminal ParseNode atomic_statement;
 non terminal ParseNode getoffset_expression;
 
+//coarse-grain parallelization
+terminal SESE;
+non terminal ParseNode sese_statement;
+
 
 start with goal;
 
@@ -1153,6 +1157,7 @@ statement_without_trailing_substatement ::=
        |       return_statement:st {: RESULT=st; :}
        |       task_exitstatement:st {: RESULT=st; :}
        |       atomic_statement:st {: RESULT=st; :}
+       |       sese_statement:st {: RESULT=st; :}
 //     |       synchronized_statement
 //     |       throw_statement
 //     |       try_statement
@@ -1335,6 +1340,19 @@ atomic_statement ::=
        RESULT=(new ParseNode("atomic")).addChild(blk).getRoot();
        :}
        ;
+sese_statement ::=
+
+//            SESE variable_declarator_id:id LBRACE statement:st RBRACE {: 
+
+              SESE block:blk {: 
+              ParseNode pn = new ParseNode("sese");
+
+//            pn.addChild("identifier").addChild(id);
+
+              pn.addChild("body").addChild(blk);
+              RESULT=pn;
+       :}
+       ;
 //try_statement ::=
 //             TRY block catches
 //     |       TRY block catches_opt finally

diff --git a/Robust/src/Tests/mlp/syntaxTest/makefile b/Robust/src/Tests/mlp/syntaxTest/makefile
new file mode 100644 (file)
index 0000000..385858a
--- /dev/null
+++ b/Robust/src/Tests/mlp/syntaxTest/makefile
@@ -0,0 +1,27 @@
+PROGRAM=test
+
+SOURCE_FILES=$(PROGRAM).java
+
+BUILDSCRIPT=~/research/Robust/src/buildscript
+BSFLAGS= -recover -ownership -ownallocdepth 1 -ownaliasfile aliases.txt -ownwritedots final -enable-assertions -flatirtasks
+
+all: $(PROGRAM).bin
+
+view: PNGs
+       eog *.png &
+
+PNGs: DOTs
+       d2p *COMPLETE*.dot
+
+DOTs: $(PROGRAM).bin
+
+$(PROGRAM).bin: $(SOURCE_FILES)
+       $(BUILDSCRIPT) $(BSFLAGS) -o $(PROGRAM) $(SOURCE_FILES)
+
+clean:
+       rm -f  $(PROGRAM).bin
+       rm -fr tmpbuilddirectory
+       rm -f  *~
+       rm -f  *.dot
+       rm -f  *.png
+       rm -f  aliases.txt

diff --git a/Robust/src/Tests/mlp/syntaxTest/test.java b/Robust/src/Tests/mlp/syntaxTest/test.java
new file mode 100644 (file)
index 0000000..9e01205
--- /dev/null
+++ b/Robust/src/Tests/mlp/syntaxTest/test.java
@@ -0,0 +1,29 @@
+
+
+task Startup( StartupObject s{ initialstate } ) {
+
+  int a = 0;
+
+  sese {
+    int x = 3;
+  }
+  
+  a = x;
+  
+  
+  sese {
+    int y = 4;
+    y+=4;
+
+    sese {
+      int z = x + y;
+      z+=6;
+      Integer n=new Integer(23);
+    }
+  }
+
+  x = y + z;
+
+
+  taskexit( s{ !initialstate } );
+}