def reset():
"""
Reset the testing environment.
Barrier is needed to stop messages received from nodes already in the next test being removed
"""
PyDOOMS._reset()
PyDOOMS.barrier()
def BarrierTest():
"""
Test barrier by incrementing a single value over multiple barriers
"""
loops = 10
increment = 1
results = []
if myname == 0:
for i in range(nodes):
TestObject(i)
PyDOOMS.barrier()
obj = PyDOOMS.get(myname)
for i in range(loops):
results.append(obj.value)
obj.value += increment
PyDOOMS._comm.addOutgoingUpdate(obj.ID, "value", obj.value)
PyDOOMS.barrier()
results.append(obj.value)
if not (
results[0] == 0 * increment
and results[1] == 1 * increment
and results[2] == 2 * increment
and results[3] == 3 * increment
and results[4] == 4 * increment
):
logging.critical("results: " + str(results))
raise Exception
def reset():
"""
Reset the testing environment.
Barriers are needed to stop workers from resetting the object store
while other workers are running a test.
"""
PyDOOMS.barrier()
PyDOOMS._reset()
PyDOOMS.barrier()
def GetTest1(workerID):
"""
Tests retrieving object references from local object store and accessing objects
"""
numOfObj = 100
if (workerID == 0):
for i in range(numOfObj):
TestObject(i)
PyDOOMS.barrier()
for i in range(numOfObj):
PyDOOMS.get(i).value
def monteCarlo(workerID, myDarts):
if (workerID == 0):
for boardID in range(PyDOOMS.getNumberOfWorkers()):
Board(boardID)
PyDOOMS.barrier()
start = time.time()
board = PyDOOMS.get(workerID)
# Compute
while (myDarts > 0):
x = random.random()
y = random.random()
dist = math.sqrt((x*x)+(y*y))
if (dist <= 1.0):
board.hit()
else:
board.miss()
myDarts = myDarts - 1
board.ready = True
PyDOOMS.objectUpdated(board, "hits")
PyDOOMS.objectUpdated(board, "darts")
PyDOOMS.objectUpdated(board, "ready")
PyDOOMS.barrier()
# Sum result
if (workerID == 0):
pi = 0.0
i = 0
while i < PyDOOMS.getNumberOfWorkers():
b = PyDOOMS.get(i)
if b.ready:
pi = pi + b.calc_pi()
i = i + 1
else:
logging.critical("Board: " + str(i) + " - " + str(b.ready))
time.sleep(1)
logging.info("Pi: " + str(pi / PyDOOMS.getNumberOfWorkers()) + " calculated in " + str(time.time() - start) + " seconds.")
logging.info("Worker: " + str(workerID) + " dead. Worked for " + str(time.time() - start) + " seconds.")
def worker(workerID, myDarts):
if (myname == 0 and workerID == 0):
for boardID in range(totalClients):
Board(boardID)
PyDOOMS.barrier()
board = PyDOOMS.get(myname*threadsPerNode+workerID)
# Compute
while (myDarts > 0):
x = random.random()
y = random.random()
dist = math.sqrt((x*x)+(y*y))
if (dist <= 1.0):
board.hit()
else:
board.miss()
myDarts = myDarts - 1
board.ready = True
PyDOOMS._comm.addOutgoingUpdate(board.ID, "hits", board.hits)
PyDOOMS._comm.addOutgoingUpdate(board.ID, "darts", board.darts)
PyDOOMS._comm.addOutgoingUpdate(board.ID, "ready", board.ready)
PyDOOMS.barrier()
# Sum result
pi = 0.0
if (myname == 0 and workerID == 0):
i = 0
while i < totalClients:
b = PyDOOMS.get(i)
if b.ready:
pi = pi + b.calc_pi()
i = i + 1
else:
print "board ",i,":",b.ready
time.sleep(1)
logging.debug("Pi: " + str(pi / totalClients) + " calculated in " + str(time.time() - start) + " seconds.")
logging.debug("Worker: " + str(myname) + "_" + str(workerID) + " dead. Worked for " + str(time.time() - start) + " seconds.")
def AttributeTest1():
"""
Tests adding a new attribute to a shared object
"""
if myname == 0:
TestObject(1)
PyDOOMS.barrier()
obj = PyDOOMS.get(1)
if myname == 0:
obj.newAttr = 2
PyDOOMS._comm.addOutgoingUpdate(obj.ID, "newAttr", obj.newAttr)
PyDOOMS.barrier()
val = obj.newAttr
if not (val == 2):
logging.critical("Process " + str(myname) + " Value is:" + str(val))
raise Exception
def SpreadTest1(workerID):
"""
Tests creation and spreading of objects created in node 0
All nodes should have all objects in their local object store at the end of the test
"""
numOfObj = 500
if (workerID == 0):
for i in range(numOfObj):
TestObject(i)
PyDOOMS.barrier()
# The python dictionary appears to do non-blocking inserts into the object store dict.
# Our PyDOOMS.get() function will wait for inserts to be made, but when checking the length of the dict
# (which should not be done outside perhaps testing) we must first wait for all inserts to complete
time.sleep(0.02)
if (len(PyDOOMS._store.objects) != numOfObj):
logging.critical("Worker " + str(workerID) + " Number of objects:" + str(len(PyDOOMS._store.objects)))
printDict()
raise Exception
def SpreadTest1():
"""
Tests creation and spreading of objects residing in node 0
All nodes should have all objects in their local object store
"""
numOfObj = 500
if myname == 0:
for i in range(numOfObj):
TestObject(i)
PyDOOMS.barrier()
# The python dictionary appears to do non-blocking non-immediate inserts into the object store dict.
# Our PyDOOMS.get() function will wait for inserts to be made, but when checking the length of the dict
# (which should never be done outside perhaps testing) we must first wait for all inserts to complete
time.sleep(0.0001)
if len(PyDOOMS._store.objects) != numOfObj:
logging.critical("Process " + str(myname) + " Number of objects:" + str(len(PyDOOMS._store.objects)))
printDict()
raise Exception
def BarrierTest(workerID):
"""
Test barrier by incrementing a single value over multiple barriers
"""
loops = 10
increment = 1
results = []
if (workerID == 0):
for i in range(PyDOOMS.getNumberOfWorkers()):
TestObject(i)
PyDOOMS.barrier()
obj = PyDOOMS.get(workerID)
PyDOOMS.barrier()
for i in range(loops):
results.append(obj.value)
obj.value += increment
PyDOOMS.objectUpdated(obj,"value")
PyDOOMS.barrier()
results.append(obj.value)
if not (results[0] == 0*increment and results[1] == 1*increment and results[2] == 2*increment and
results[3] == 3*increment and results[4] == 4*increment):
logging.critical("Worker" + str(workerID) + ", results: " + str(results))
raise Exception
def ObjectAttributeTest1(workerID):
"""
Tests reading from a shared object before and after object value has been changed by another node.
The value being changed is a TestObject2 object
"""
if (workerID == 0):
TestObject(1)
PyDOOMS.barrier()
obj = PyDOOMS.get(1)
oldObj = obj.objectAttr
oldObjA = oldObj.a
oldObjB = oldObj.b
PyDOOMS.barrier()
if (workerID == 0):
obj.objectAttr = TestObject2()
obj.objectAttr.a = 2
obj.objectAttr.b = 2
PyDOOMS.objectUpdated(obj, "objectAttr")
PyDOOMS.barrier()
obj = PyDOOMS.get(1)
if not (isinstance(oldObj,TestObject2) and oldObjA == 0 and oldObjB == 1 and
isinstance(obj, TestObject) and isinstance(obj.objectAttr,TestObject2) and obj.objectAttr.a == 2 and obj.objectAttr.b == 2):
logging.critical("Worker " + str(workerID) + " Values are:"
+ str(oldObjA) + "," + str(oldObjB) + " "
+ str(PyDOOMS.get(1).objectAttr.a) + "," + str(obj.objectAttr.b))
raise Exception
def ReadLoopTest1(workerID):
"""
Tests reading from a shared object before and after object value has been changed by another node
"""
if (workerID == 0):
TestObject(1)
PyDOOMS.barrier()
obj = PyDOOMS.get(1)
oldValue = obj.value
PyDOOMS.barrier()
if (workerID == 0):
obj.value = 1
PyDOOMS.objectUpdated(obj, "value")
PyDOOMS.barrier()
obj = PyDOOMS.get(1)
if not (oldValue == 0 and obj.value == 1):
logging.critical("Worker " + str(workerID) + " Values are:"
+ str(oldValue) + "," + str(obj.value) + " ")
raise Exception
def WriteLoopTest1(workerID):
"""
Test all nodes writing and reading to/from a single shared object, one at a time
"""
nodes = PyDOOMS.getNumberOfNodes()
if (workerID == 0):
TestObject(1)
PyDOOMS.barrier()
oldObjValue = PyDOOMS.get(1).value
PyDOOMS.barrier()
for i in range(nodes):
if (workerID == i):
obj = PyDOOMS.get(1)
obj.value += 1
PyDOOMS.objectUpdated(obj,"value")
PyDOOMS.barrier()
if not (oldObjValue == 0 and PyDOOMS.get(1).value == nodes):
logging.critical("Worker " + str(workerID) + " Values are:"
+ str(oldObjValue) + "," + str(PyDOOMS.get(1).value) + " ")
raise Exception
def SpreadTest2():
"""
Tests creation and spreading of objects residing in several different processes
All nodes should have all objects in their local object store
"""
objectsPerNode = 100
for i in range(nodes):
if myname == i:
for i in range(i * objectsPerNode, i * objectsPerNode + objectsPerNode):
TestObject(i)
PyDOOMS.barrier()
# The python dictionary appears to do non-blocking non-immediate inserts into the object store dict.
# Our PyDOOMS.get() function will wait for inserts to be made, but when checking the length of the dict
# we must first wait for all inserts to complete
time.sleep(0.0001)
if len(PyDOOMS._store.objects) != objectsPerNode * nodes:
logging.critical("Process " + str(myname) + " Number of objects:" + str(len(PyDOOMS._store.objects)))
printDict()
raise Exception
def ReadLoopTest3():
"""
Tests reading from multiple shard objects by doing a busy-wait for attribute change
Changes are synchronized in one barrier
"""
if myname == 0:
TestObject(1)
TestObject(2)
TestObject(3)
PyDOOMS.barrier()
obj1 = PyDOOMS.get(1)
obj2 = PyDOOMS.get(2)
obj3 = PyDOOMS.get(3)
oldObj1Value = obj1.value
oldObj2Value = obj2.value
oldObj3Value = obj3.value
if myname is not 0:
while obj1.value == 0 or obj2.value == 0 or obj3.value == 0:
PyDOOMS.barrier()
elif myname == 0:
obj1.value = obj1.value + 1
obj2.value = obj2.value + 1
obj3.value = obj3.value + 1
PyDOOMS._comm.addOutgoingUpdate(1, "value", 1)
PyDOOMS._comm.addOutgoingUpdate(2, "value", 1)
PyDOOMS._comm.addOutgoingUpdate(3, "value", 1)
PyDOOMS.barrier()
if not (
oldObj1Value == 0
and oldObj2Value == 0
and oldObj3Value == 0
and obj1.value == 1
and obj2.value == 1
and obj3.value == 1
):
logging.critical(
"Process "
+ str(myname)
+ " Values are:"
+ str(oldObj1Value)
+ ","
+ str(obj1.value)
+ " "
+ str(oldObj2Value)
+ ","
+ str(obj2.value)
+ " "
+ str(oldObj3Value)
+ ","
+ str(obj3.value)
+ " "
)
raise Exception
def ReadLoopTest1():
"""
Tests reading from a shared object before and after object value has been changed by another node
"""
if myname == 0:
TestObject(1)
PyDOOMS.barrier()
obj = PyDOOMS.get(1)
oldValue = obj.value
if myname == 0:
obj.value = 1
PyDOOMS._comm.addOutgoingUpdate(1, "value", obj.value)
PyDOOMS.barrier()
if not (oldValue == 0 and obj.value == 1):
logging.critical("Process " + str(myname) + " Values are:" + str(oldValue) + "," + str(obj.value) + " ")
raise Exception
def WriteLoopTest1():
"""
Test all nodes writing and reading to/from a single shared object, one at a time
"""
if myname == 0:
TestObject(1)
PyDOOMS.barrier()
obj = PyDOOMS.get(1)
oldObjValue = obj.value
for i in range(nodes):
if myname == i:
obj.value += 1
PyDOOMS._comm.addOutgoingUpdate(1, "value", obj.value)
PyDOOMS.barrier()
if not (oldObjValue == 0 and obj.value == nodes):
logging.critical("Process " + str(myname) + " Values are:" + str(oldObjValue) + "," + str(obj.value) + " ")
raise Exception
def SpreadTest2(workerID):
"""
Tests creation and spreading of objects created in several different nodes
All nodes should have all objects in their local object store at the end of the test
"""
nodes = PyDOOMS.getNumberOfNodes()
objectsPerNode = 100
for i in range(nodes):
if (workerID == i):
for i in range(i*objectsPerNode,i*objectsPerNode+objectsPerNode):
TestObject(i)
PyDOOMS.barrier()
# The python dictionary appears to do non-blocking inserts into the object store dict.
# Our PyDOOMS.get() function will wait for inserts to be made, but when checking the length of the dict
# we must first wait for all inserts to complete
time.sleep(0.02)
if (len(PyDOOMS._store.objects) != objectsPerNode*nodes):
logging.critical("Worker " + str(workerID) + " Number of objects:" + str(len(PyDOOMS._store.objects)))
printDict()
raise Exception
def ReadLoopTest3(workerID):
"""
Tests reading from multiple shared objects before and after an object value has been changed.
Changes are synchronized in one barrier
"""
if (workerID == 0):
TestObject(1)
TestObject(2)
TestObject(3)
PyDOOMS.barrier()
oldObj1Value = PyDOOMS.get(1).value
oldObj2Value = PyDOOMS.get(2).value
oldObj3Value = PyDOOMS.get(3).value
PyDOOMS.barrier()
if (workerID is not 0):
PyDOOMS.barrier()
elif (workerID == 0):
obj1 = PyDOOMS.get(1)
obj2 = PyDOOMS.get(2)
obj3 = PyDOOMS.get(3)
obj1.value = obj1.value + 1
obj2.value = obj2.value + 1
obj3.value = obj3.value + 1
PyDOOMS.objectUpdated(obj1,"value")
PyDOOMS.objectUpdated(obj2,"value")
PyDOOMS.objectUpdated(obj3,"value")
PyDOOMS.barrier()
if not (oldObj1Value == 0 and oldObj2Value == 0 and oldObj3Value == 0 and PyDOOMS.get(1).value == 1 and PyDOOMS.get(2).value == 1 and PyDOOMS.get(3).value == 1):
logging.critical("Worker " + str(workerID) + " Values are:"
+ str(oldObj1Value) + "," + str(PyDOOMS.get(1).value) + " "
+ str(oldObj2Value) + "," + str(PyDOOMS.get(2).value) + " "
+ str(oldObj3Value) + "," + str(PyDOOMS.get(3).value) + " ")
raise Exception
def WriteLoopTest3(workerID):
"""
Test writing and reading to/from multiple shared object from each node
"""
nodes = PyDOOMS.getNumberOfNodes()
if (workerID == 0):
TestObject(0)
TestObject(1)
TestObject(2)
TestObject(3)
PyDOOMS.barrier()
oldObj0Value = PyDOOMS.get(0).value
oldObj1Value = PyDOOMS.get(1).value
oldObj2Value = PyDOOMS.get(2).value
oldObj3Value = PyDOOMS.get(3).value
PyDOOMS.barrier()
for i in range(nodes):
if (workerID == i):
obj0 = PyDOOMS.get(0)
obj1 = PyDOOMS.get(1)
obj2 = PyDOOMS.get(2)
obj3 = PyDOOMS.get(3)
obj0.value += 1
obj1.value += 1
obj2.value += 1
obj3.value += 1
PyDOOMS.objectUpdated(obj0,"value")
PyDOOMS.objectUpdated(obj1,"value")
PyDOOMS.objectUpdated(obj2,"value")
PyDOOMS.objectUpdated(obj3,"value")
PyDOOMS.barrier()
if not (oldObj0Value == 0 and oldObj1Value == 0 and oldObj2Value == 0 and oldObj3Value == 0 and
PyDOOMS.get(0).value == nodes and PyDOOMS.get(1).value == nodes and PyDOOMS.get(2).value == nodes and PyDOOMS.get(3).value == nodes):
logging.critical("Worker " + str(workerID) + " Values are:"
+ str(oldObj0Value) + "," + str(PyDOOMS.get(0).value) + " "
+ str(oldObj1Value) + "," + str(PyDOOMS.get(1).value) + " "
+ str(oldObj2Value) + "," + str(PyDOOMS.get(2).value) + " "
+ str(oldObj3Value) + "," + str(PyDOOMS.get(3).value) + " ")
raise Exception
def AttributeTest1(workerID):
"""
Tests adding a new attribute to a shared object
"""
if (workerID == 0):
TestObject(1)
PyDOOMS.barrier()
obj = PyDOOMS.get(1)
PyDOOMS.barrier()
if (workerID == 0):
obj.newAttr = 2
PyDOOMS.objectUpdated(obj,"newAttr")
PyDOOMS.barrier()
val = PyDOOMS.get(1).newAttr
if not (val == 2):
logging.critical("Worker " + str(workerID) + " Value is:"
+ str(val))
raise Exception
def RedBlackGaussSeidel(workerID, matrixSize):
global numberOfWorkers, matrixOffset
numberOfWorkers = PyDOOMS.getNumberOfWorkers()
matrixOffset = 100
chunkSize = (matrixSize-2) / numberOfWorkers
if workerID == 0:
if ((matrixSize - 2) % numberOfWorkers) != 0:
print "Warning: Matrix size - 2 is not divisible with number of workers, some columns may not be calculated"
start = time.time()
generateSharedMatrixRows(matrixSize)
logging.info("Time to generate shared matrix rows: " + str(time.time()-start))
for w in range(numberOfWorkers):
WorkerInfo(w)
PyDOOMS.barrier()
logging.info("Worker: " + str(workerID) + " assigned rows " + str(workerID*chunkSize+1) + "-" + str(workerID*chunkSize + chunkSize + 1))
start = time.time()
for iteration in range(1):
workerInfo = PyDOOMS.get(workerID)
workerInfo.error = 0.0
enum = dict(enumerate(['Red', 'Black']))
for color in enum:
for row in range(workerID*chunkSize + 1,workerID*chunkSize + chunkSize + 1):
northRow = PyDOOMS.get(matrixOffset + row - 1)
centerRow = PyDOOMS.get(matrixOffset + row)
southRow = PyDOOMS.get(matrixOffset + row + 1)
for column in range((color + row) % 2 + 1, matrixSize-1, 2):
newValue = 0.25 * (northRow.row[column] + southRow.row[column] +
centerRow.row[column-1] + centerRow.row[column+1])
workerInfo.error += abs(centerRow.row[column] - newValue)
centerRow.row[column] = newValue
PyDOOMS. objectUpdated(centerRow, "row")
PyDOOMS.objectUpdated(workerInfo, "error")
PyDOOMS.barrier()
if (workerID == numberOfWorkers - 1):
globalError = 0.0
for w in range(numberOfWorkers):
globalError += PyDOOMS.get(w).error
logging.info("Iteration " + str(iteration+1) + " global error = " + str(globalError))
logging.info("Worker: " + str(workerID) + " done in " + str(time.time() - start) + " seconds")
def LUdecomp(workerID):
if workerID==0:
setupStart = time.time()
generateSharedMatrixBlocks(size)
print "Setup done in ", time.time() - setupStart, "seconds."
#print "Matrix:"
#printBlockMatrix(matrixOffset)
start = time.time()
for x in range(blocksPerSide):
if workerID == workerList.pop():
logging.debug("Worker" +str(workerID) + "working on diagonal " + str(x) + str(",") + str(x))
A = getMatrixBlock(matrixOffset, x, x)
L = getMatrixBlock(LOffset, x, x)
U = getMatrixBlock(UOffset, x, x)
l,u = betterLU(A.block)
L.block = l
U.block = u
PyDOOMS.objectUpdated(L, "block")
PyDOOMS.objectUpdated(U, "block")
PyDOOMS.barrier()
for i in range(x+1,blocksPerSide):
if workerID == workerList.pop():
logging.debug("Worker" +str(workerID) + "working on U " + str(x) + str(",") + str(i))
A = getMatrixBlock(matrixOffset, x, i)
L = getMatrixBlock(LOffset, x, x)
U = getMatrixBlock(UOffset, x, i)
U.block = multiplyMatrix(invertMatrix(L.block), A.block)
PyDOOMS.objectUpdated(U, "block")
for j in range(x+1,blocksPerSide):
if workerID == workerList.pop():
logging.debug("Worker" +str(workerID) + "working on L " + str(j) + str(",") + str(x))
A = getMatrixBlock(matrixOffset, j, x)
L = getMatrixBlock(LOffset, j, x)
U = getMatrixBlock(UOffset, x, x)
L.block = multiplyMatrix(A.block, invertMatrix(U.block))
PyDOOMS.objectUpdated(L, "block")
PyDOOMS.barrier()
for j in range(x+1, blocksPerSide):
for k in range(x+1, blocksPerSide):
if workerID == workerList.pop():
logging.debug("Worker" +str(workerID) + "working on sub-block " + str(k) + str(",") + str(j))
A = getMatrixBlock(matrixOffset, k, j)
L = getMatrixBlock(LOffset, k, x)
U = getMatrixBlock(UOffset, x, j)
A.block = subtractMatrix(A.block, multiplyMatrix(L.block, U.block))
PyDOOMS.objectUpdated(A, "block")
PyDOOMS.barrier()
if workerID == 0:
print "Done in ", time.time() - start, "seconds."
def WriteLoopTest2():
"""
Tests all nodes writing to different shared objects (one object is written by only one node)
and all nodes reading from all shared objects
"""
threshold = 10
if myname == 0:
TestObject(0)
TestObject(1)
TestObject(2)
TestObject(3)
PyDOOMS.barrier()
obj0 = PyDOOMS.get(0)
obj1 = PyDOOMS.get(1)
obj2 = PyDOOMS.get(2)
obj3 = PyDOOMS.get(3)
oldObj0Value = obj0.value
oldObj1Value = obj1.value
oldObj2Value = obj2.value
oldObj3Value = obj3.value
while PyDOOMS.get(myname).value < threshold:
obj = PyDOOMS.get(myname)
obj.value += 1
PyDOOMS._comm.addOutgoingUpdate(myname, "value", obj.value)
PyDOOMS.barrier()
if not (
oldObj0Value == 0
and oldObj1Value == 0
and oldObj2Value == 0
and oldObj3Value == 0
and obj0.value == threshold
and obj1.value == threshold
and obj2.value == threshold
and obj3.value == threshold
):
logging.critical(
"Process "
+ str(myname)
+ " Values are:"
+ str(oldObj0Value)
+ ","
+ str(obj0.value)
+ " "
+ str(oldObj1Value)
+ ","
+ str(obj1.value)
+ " "
+ str(oldObj2Value)
+ ","
+ str(obj2.value)
+ " "
+ str(oldObj3Value)
+ ","
+ str(obj3.value)
+ " "
)
raise Exception
def WriteLoopTest3():
"""
Test writing and reading to/from multiple shared object from each node
"""
if myname == 0:
TestObject(0)
TestObject(1)
TestObject(2)
TestObject(3)
PyDOOMS.barrier()
obj0 = PyDOOMS.get(0)
obj1 = PyDOOMS.get(1)
obj2 = PyDOOMS.get(2)
obj3 = PyDOOMS.get(3)
oldObj0Value = obj0.value
oldObj1Value = obj1.value
oldObj2Value = obj2.value
oldObj3Value = obj3.value
for i in range(nodes):
if myname == i:
obj0.value += 1
obj1.value += 1
obj2.value += 1
obj3.value += 1
PyDOOMS._comm.addOutgoingUpdate(obj0.ID, "value", obj0.value)
PyDOOMS._comm.addOutgoingUpdate(obj1.ID, "value", obj1.value)
PyDOOMS._comm.addOutgoingUpdate(obj2.ID, "value", obj2.value)
PyDOOMS._comm.addOutgoingUpdate(obj3.ID, "value", obj3.value)
PyDOOMS.barrier()
if not (
oldObj0Value == 0
and oldObj1Value == 0
and oldObj2Value == 0
and oldObj3Value == 0
and obj0.value == nodes
and obj1.value == nodes
and obj2.value == nodes
and obj3.value == nodes
):
logging.critical(
"Process "
+ str(myname)
+ " Values are:"
+ str(oldObj0Value)
+ ","
+ str(obj0.value)
+ " "
+ str(oldObj1Value)
+ ","
+ str(obj1.value)
+ " "
+ str(oldObj2Value)
+ ","
+ str(obj2.value)
+ " "
+ str(oldObj3Value)
+ ","
+ str(obj3.value)
+ " "
)
raise Exception
def gaussSeidel(workerID, matrixSize):
global numberOfWorkers, matrixOffset
numberOfWorkers = PyDOOMS.getNumberOfWorkers()
matrixOffset = 100
chunkSize = (matrixSize-2) / numberOfWorkers
if workerID == 0:
if ((matrixSize - 2) % numberOfWorkers) != 0:
print "Warning: Matrix size incompatible with number of workers, some columns may not be calculated"
matrix = generateMatrix(matrixSize)
generateSharedRowChunks(matrix, chunkSize)
for w in range(numberOfWorkers):
WorkerInfo(w)
PyDOOMS.barrier()
logging.info("Worker: " + str(workerID) + " assigned chunk " + str(workerID+1))
start = time.time()
for iteration in range(1):
workerInfo = PyDOOMS.get(workerID)
workerInfo.error = 0.0
for row in range(1,matrixSize-1):
if (workerID != 0):
while (PyDOOMS.get(workerID - 1).progress < row):
PyDOOMS.barrier()
workerChunk = workerID + 1
westChunk = PyDOOMS.get(getChunkRowIndex(row,workerChunk-1))
northChunk = PyDOOMS.get(getChunkRowIndex(row-1,workerChunk))
eastChunk = PyDOOMS.get(getChunkRowIndex(row,workerChunk+1))
southChunk = PyDOOMS.get(getChunkRowIndex(row+1,workerChunk))
centerChunk = PyDOOMS.get(getChunkRowIndex(row,workerChunk))
if chunkSize == 1:
for column in range(len(centerChunk.rowChunk)):
newValue = 0.25 * (northChunk.rowChunk[column] + southChunk.rowChunk[column] +
eastChunk.rowChunk[column] + westChunk.rowChunk[column])
workerInfo.error += abs(centerChunk.rowChunk[column] - newValue)
centerChunk.rowChunk[column] = newValue
else:
for column in range(len(centerChunk.rowChunk)):
if column == 0:
newValue = 0.25 * (northChunk.rowChunk[column] + southChunk.rowChunk[column] +
westChunk.rowChunk[chunkSize-1] + centerChunk.rowChunk[column+1])
elif column == chunkSize-1:
newValue = 0.25 * (northChunk.rowChunk[column] + southChunk.rowChunk[column] +
centerChunk.rowChunk[column-1] + eastChunk.rowChunk[0])
else:
newValue = 0.25 * (northChunk.rowChunk[column] + southChunk.rowChunk[column] +
centerChunk.rowChunk[column-1] + centerChunk.rowChunk[column+1])
workerInfo.error += abs(centerChunk.rowChunk[column] - newValue)
centerChunk.rowChunk[column] = newValue
workerInfo.progress = row
PyDOOMS.objectUpdated(workerInfo, "progress")
PyDOOMS.objectUpdated(workerInfo, "error")
PyDOOMS.objectUpdated(centerChunk, "rowChunk")
PyDOOMS.barrier()
if (workerID != 0):
previousWorker = PyDOOMS.get(workerID - 1)
previousWorker.progress = 0
#PyDOOMS._comm.addOutgoingUpdate(previousWorker.ID, "progress", previousWorker.progress)
if (workerID == numberOfWorkers - 1):
globalError = 0.0
for w in range(numberOfWorkers):
globalError += PyDOOMS.get(w).error
logging.info("GlobalError: " + str(globalError))
for i in range(workerID,numberOfWorkers):
PyDOOMS.barrier()
logging.info("Worker: " + str(workerID) + " done in " + str(time.time() - start) + " seconds")
# SETUP
start = time.time()
myname = eval(sys.argv[1])
numberOfClients = eval(sys.argv[2])
darts = 2000000
totalClients = numberOfClients
darts = darts / totalClients
if myname == 0:
for boardID in range(totalClients):
Board(boardID)
PyDOOMS.barrier()
board = PyDOOMS.get(myname)
# Compute
while (darts > 0):
x = random.random()
y = random.random()
dist = math.sqrt((x*x)+(y*y))
if (dist <= 1.0):
board.hit()
else:
board.miss()
darts = darts - 1
board.ready = True
