add a simplifed bh.

diff --git a/Robust/src/Benchmarks/oooJava/simplebh/LeafNodeData.java b/Robust/src/Benchmarks/oooJava/simplebh/LeafNodeData.java
new file mode 100644 (file)
index 0000000..42e0ec7
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/simplebh/LeafNodeData.java
@@ -0,0 +1,7 @@
+public class LeafNodeData {
+
+  int vel;
+  int acc;
+
+
+}

diff --git a/Robust/src/Benchmarks/oooJava/simplebh/TestRunner.java b/Robust/src/Benchmarks/oooJava/simplebh/TestRunner.java
new file mode 100644 (file)
index 0000000..10cbdff
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/simplebh/TestRunner.java
@@ -0,0 +1,115 @@
+public class TestRunner {
+
+  public static void main(String args[]) {
+
+    TestRunner r = new TestRunner();
+    r.run();
+
+  }
+
+  public void run() {
+
+    int nBodies = 50;
+
+    Vector   leafNodeVector=new Vector(nBodies);
+
+//    // body setup
+//    for (int i = 0; i < nBodies; i++) {
+//      leafNodeVector.insertElementAt(new LeafNodeData(), i);
+//    }
+
+    // tree setup
+    TreeIndexGraph tree = new TreeIndexGraph();
+    TreeIndexNode root = tree.createNode(null);
+    tree.addNode(root);
+
+    for (int i = 0; i < nBodies; i++) {
+      LeafNodeData leaf=new LeafNodeData();
+      TreeIndexNode treenode = tree.createNode(leaf);
+      leafNodeVector.insertElementAt(treenode, i);
+      insert(tree, root,leaf);
+    }
+    
+      for(int i=0; i<nBodies;i++){
+        TreeIndexNode body =(TreeIndexNode)  leafNodeVector.elementAt(i);
+        sese par{
+//          body.computeForce(root);
+          body.computeForce(root);
+        }
+      }
+    
+    for(int i=0; i<nBodies;i++){
+      ((TreeIndexNode)leafNodeVector.elementAt(i)).advance();
+    }
+    
+  }
+
+  private void insert(TreeIndexGraph tree, TreeIndexNode nn, LeafNodeData leafNodeData) {
+    if (nn.children[0] == null) {
+      TreeIndexNode newNode = tree.createNode(leafNodeData);
+      tree.addNode(newNode);
+      nn.children[0] = newNode;
+    } else { // if left is already occupied
+      if (nn.children[1] != null) {
+        insert(tree, nn.children[1], leafNodeData);
+      } else {
+        TreeIndexNode newNode = tree.createNode(null);
+        tree.addNode(newNode);
+        nn.children[1] = newNode;
+        insert(tree, newNode, leafNodeData);
+      }
+    }
+  }
+}
+
+// class Body {
+// int pos;
+// int acc;
+// TreeNode root;
+//
+// public void setRoot(TreeNode r) {
+// this.root = r;
+// }
+//
+// public void computeForce() {
+// traverse(root);
+// }
+//
+// public void traverse(TreeNode node) {
+// if (node.body != null) {
+// // if current one is a body
+// acc += node.body.pos;
+// } else {
+// traverse(node.left);
+// traverse(node.right);
+// }
+// }
+// }
+//
+// class TreeNode {
+//
+// TreeNode left;
+// TreeNode right;
+// TreeNode root;
+// Body body;
+//
+// public TreeNode(Body b) {
+// this.body = b;
+// }
+//
+// public void addLeftChild(TreeNode n) {
+// left = n;
+// }
+//
+// public void addRightChild(TreeNode n) {
+// right = n;
+// }
+//
+// public TreeNode getLeftChild() {
+// return left;
+// }
+//
+// public TreeNode getRightChild() {
+// return right;
+// }
+

diff --git a/Robust/src/Benchmarks/oooJava/simplebh/TreeDotGen.java b/Robust/src/Benchmarks/oooJava/simplebh/TreeDotGen.java
new file mode 100644 (file)
index 0000000..0f0065e
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/simplebh/TreeDotGen.java
@@ -0,0 +1,49 @@
+import java.io.*;
+
+public class TreeDotGen{
+
+    public int idx;
+    
+    public static void main(String args[]){
+       TreeDotGen t=new TreeDotGen();
+       t.generate();
+    }
+
+    public void generate(){
+       
+       try{
+           FileWriter fstream=new FileWriter("out.dot");
+           BufferedWriter out=new BufferedWriter(fstream);
+   
+           out.write("digraph btree{\n");
+           idx=0;
+           generateTree(0,out);
+
+           out.write("}\n");
+           
+           out.close();
+       }catch(Exception e){
+
+       }
+
+    }
+
+    public void generateTree(int parentIdx,BufferedWriter out) throws IOException{
+
+       
+       //left
+
+       int leftIdx= ++idx;
+       out.write("N"+parentIdx+"->"+"N"+leftIdx+"\n");
+
+       //right
+       int rightIdx= ++idx;
+       out.write("N"+parentIdx+"->"+"N"+rightIdx+"\n");
+
+       if(idx<100){
+           generateTree(leftIdx,out);  
+           generateTree(rightIdx,out); 
+       }
+    }
+
+}
\ No newline at end of file

diff --git a/Robust/src/Benchmarks/oooJava/simplebh/TreeIndexGraph.java b/Robust/src/Benchmarks/oooJava/simplebh/TreeIndexGraph.java
new file mode 100644 (file)
index 0000000..10711ee
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/simplebh/TreeIndexGraph.java
@@ -0,0 +1,18 @@
+public class TreeIndexGraph {
+
+  // HashSet nodes;
+
+  public TreeIndexGraph() {
+    // this.nodes = new HashSet();
+  }
+
+  public TreeIndexNode createNode(LeafNodeData data) {
+    TreeIndexNode treeNode = new TreeIndexNode(data);
+    return treeNode;
+  }
+
+  public void addNode(TreeIndexNode treeIndexNode) {
+    // nodes.add(treeIndexNode);
+  }
+
+}

diff --git a/Robust/src/Benchmarks/oooJava/simplebh/TreeIndexNode.java b/Robust/src/Benchmarks/oooJava/simplebh/TreeIndexNode.java
new file mode 100644 (file)
index 0000000..4224068
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/simplebh/TreeIndexNode.java
@@ -0,0 +1,49 @@
+public class TreeIndexNode {
+
+  LeafNodeData data;
+  TreeIndexNode children[];
+  int pos;
+  int mass;
+
+  // TreeIndexNode left;
+  // TreeIndexNode right;
+
+  public TreeIndexNode(LeafNodeData data) {
+    this.data = data;
+    this.children = new TreeIndexNode[2];
+  }
+
+  public void advance() {
+    pos += data.acc + 10;
+    data.vel += data.acc + 10;
+  }
+
+  public void computeForce(TreeIndexNode root) {
+    data.acc = 0;
+    recurseForce(root);
+    data.vel = 10;
+  }
+
+  private void recurseForce(TreeIndexNode nn) {
+
+    int drPos = nn.pos;
+    int temp = nn.mass;
+
+    if (nn.data == null) { // nn is cell
+
+      if (nn.children[0] != null) {
+        recurseForce(nn.children[0]);
+      }
+
+      if (nn.children[1] != null) {
+        recurseForce(nn.children[1]);
+      }
+
+      // } else { // nn is body
+      if (nn != this) {
+        data.acc += drPos + nn.mass;
+      }
+    }
+  }
+
+}

diff --git a/Robust/src/Benchmarks/oooJava/simplebh/makefile b/Robust/src/Benchmarks/oooJava/simplebh/makefile
new file mode 100644 (file)
index 0000000..15b89d5
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/simplebh/makefile
@@ -0,0 +1,10 @@
+PROGRAM=TestRunner
+
+SOURCE_FILES=TestRunner.java
+
+NUM_OOO_WORKERS=24
+NUM_RCR_WORKERS=31
+
+BMFLAGS= -heapsize-mb 5000
+
+include ../master-makefile