From b13f392a8b1e19d96dc7f8064e7be4374253d9d1 Mon Sep 17 00:00:00 2001
From: jjenista <jjenista>
Date: Thu, 29 Jan 2009 23:15:06 +0000
Subject: [PATCH] Added SESE definition support to compiler

---
 Robust/src/IR/Flat/BuildCode.java         | 16 ++++++
 Robust/src/IR/Flat/BuildFlat.java         | 16 ++++++
 Robust/src/IR/Flat/FKind.java             |  2 +
 Robust/src/IR/Flat/FlatSESEEnterNode.java | 39 +++++++++++++
 Robust/src/IR/Flat/FlatSESEExitNode.java  | 32 +++++++++++
 Robust/src/IR/Tree/BuildIR.java           | 17 ++++++
 Robust/src/IR/Tree/Kind.java              |  1 +
 Robust/src/IR/Tree/Modifiers.java         |  3 +-
 Robust/src/IR/Tree/SESENode.java          | 70 +++++++++++++++++++++++
 Robust/src/IR/Tree/SemanticCheck.java     |  7 ++-
 Robust/src/Lex/Keyword.java               |  4 +-
 Robust/src/Lex/Lexer.java                 |  2 +-
 Robust/src/Parse/java14.cup               | 18 ++++++
 Robust/src/Tests/mlp/syntaxTest/makefile  | 27 +++++++++
 Robust/src/Tests/mlp/syntaxTest/test.java | 29 ++++++++++
 15 files changed, 279 insertions(+), 4 deletions(-)
 create mode 100644 Robust/src/IR/Flat/FlatSESEEnterNode.java
 create mode 100644 Robust/src/IR/Flat/FlatSESEExitNode.java
 create mode 100644 Robust/src/IR/Tree/SESENode.java
 create mode 100644 Robust/src/Tests/mlp/syntaxTest/makefile
 create mode 100644 Robust/src/Tests/mlp/syntaxTest/test.java

diff --git a/Robust/src/IR/Flat/BuildCode.java b/Robust/src/IR/Flat/BuildCode.java
index 402e99f6..14d135dd 100644
--- 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 243f6a88..9ed529d8 100644
--- 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 9789a3af..4108296a 100644
--- 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
index 00000000..344526f1
--- /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
index 00000000..a5b4f9b8
--- /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 d6b84a1d..d577cbb1 100644
--- 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 e57358d5..82afcf5f 100644
--- 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 5b7b0ea9..7f2ae46e 100644
--- 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
index 00000000..64d0dfbb
--- /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 708ae78c..045961a6 100644
--- 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 40f078db..634b0a9e 100644
--- 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 18b935ac..7aaa638a 100644
--- 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 ad406359..a41025fb 100644
--- 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
index 00000000..385858ad
--- /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
index 00000000..9e01205b
--- /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 } );
+}
-- 
2.34.1