BiGraph create(int numNodes, int numDegree, boolean verbose, Random r)
{
- Node newnode = new Node();
+ Node newnode = global new Node();
// making nodes (we create a table)
//if (verbose) System.printString("making nodes (tables in orig. version)");
- Node[] hTable = newnode.fillTable(numNodes, numDegree, r);
- Node[] eTable = newnode.fillTable(numNodes, numDegree, r);
+ Node[] hTable = global new Node[numNodes];
+ Node[] eTable = global new Node[numNodes];
+ hTable = newnode.fillTable(numNodes, numDegree, r);
+ eTable = newnode.fillTable(numNodes, numDegree, r);
// making neighbors
//if (verbose) System.printString("updating from and coeffs");
n.updateFromNodes(r);
}
- BiGraph g = new BiGraph(eTable[0], hTable[0]);
+ BiGraph g = global new BiGraph(eTable[0], hTable[0]);
return g;
}
BiGraph bg;
int upperlimit;
int lowerlimit;
- //Random rand;
Barrier mybarr;
public Em3d() {
public void run() {
int iteration;
+ int b;
+
atomic {
iteration = numIter;
+ b = mybarr.numthreads;
}
for (int i = 0; i < iteration; i++) {
Barrier runBarrier = new Barrier();
/* for eNodes */
- Node prev, curr;
atomic {
+ Node prev, curr;
prev = bg.eNodes;
curr = null;
for(int j = 0; j<lowerlimit; j++){
curr = curr.next;
}
runBarrier.enterBarrier(mybarr);
- //mybarr.reset();
}
/* for hNodes */
atomic {
+ Node prev, curr;
prev = bg.hNodes;
curr = null;
for(int j = 0; j<lowerlimit; j++){
curr = curr.next;
}
runBarrier.enterBarrier(mybarr);
- //mybarr.reset();
}
}
}
**/
public static void main(String args[])
{
- Random rand = new Random(783);
Em3d em;
atomic {
em = global new Em3d();
}
BiGraph graph;
BiGraph graph1;
+ Random rand;
+ atomic {
+ rand = global new Random(783);
+ }
atomic {
graph1 = global new BiGraph();
graph = global new BiGraph();
{
value = r.nextDouble();
// create empty array for holding toNodes
- toNodes = new Node[degree];
+ toNodes = global new Node[degree];
next = null;
for (int i = 0; i<fromCount; i++) {
**/
public Node[] fillTable(int size, int degree, Random r)
{
- Node[] table = new Node[size];
+ Node[] table = global new Node[size];
- Node prevNode = new Node(degree, r);
+ Node prevNode = global new Node(degree, r);
table[0] = prevNode;
for (int i = 1; i < size; i++) {
- Node curNode = new Node(degree, r);
+ Node curNode = global new Node(degree, r);
table[i] = curNode;
prevNode.next = curNode;
prevNode = curNode;
// find a node with the random index in the given table
otherNode = nodeTable[index];
- for (k = 0; (k < filled) && (!isBreak); k++) {
+ for (k = 0; (k < filled) && (isBreak==false); k++) {
if (otherNode == toNodes[filled])
isBreak = true;
//break;
}
}
- /*
- public void makeUniqueNeighborsThread(Node[] nodeTable, Random rand, int l, int u)
- {
- for (int filled = 0; filled < toNodes.length; filled++) {
- int k;
- Node otherNode;
- boolean isBreak;
-
- do {
- isBreak = false;
- // generate a random number in the correct range
- int index = rand.nextInt();
- if (index < 0) index = -index;
- index = index % nodeTable.length;
-
- // find a node with the random index in the given table
- otherNode = nodeTable[index];
-
- for (k = 0; (k < filled) && (!isBreak); k++) {
- if (otherNode == toNodes[filled])
- isBreak = true;
- //break;
- }
- } while (k < filled);
-
- // other node is definitely unique among "filled" toNodes
- toNodes[filled] = otherNode;
-
- // update fromCount for the other node
- otherNode.fromCount++;
- }
- }
- */
-
-
/**
* Allocate the right number of FromNodes for this node. This
* step can only happen once we know the right number of from nodes
**/
public void makeFromNodes()
{
- fromNodes = new Node[fromCount]; // nodes fill be filled in later
- coeffs = new double[fromCount];
+ fromNodes = global new Node[fromCount]; // nodes fill be filled in later
+ coeffs = global new double[fromCount];
}
/**
* Get the new value of the current node based on its neighboring
* from_nodes and coefficients.
**/
- /*
- public void run() {
- Node tmp = this;
- while(tmp!= null) {
- Node n = tmp;
- for (int i = 0; i < n.fromCount; i++) {
- n.value -= n.coeffs[i] * n.fromNodes[i].value;
- }
- tmp = tmp.next;
- }
- }
+ /*
public void computeNewValue()
{
for (int i = 0; i < fromCount; i++) {