Пример #1
0
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
Пример #2
0
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
Пример #3
0
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()
Пример #4
0
def multiplyLU():
    L = [[0.0 for i in range(size)] for j in range(size)]
    U = [[0.0 for i in range(size)] for j in range(size)]

    for id in range(LOffset, LOffset + blocksPerSide*blocksPerSide):
        m = PyDOOMS.get(id)
        #print "adding block",id,"with x,y",m.r,m.c
        for r in range(len(m.block)):
            for c in range(len(m.block)):
                L[m.r + r][m.c + c] = m.block[r][c]

    for id in range(UOffset, UOffset + blocksPerSide*blocksPerSide):
        m = PyDOOMS.get(id)
        #print "adding block",id,"with x,y",m.r,m.c
        for r in range(len(m.block)):
            for c in range(len(m.block)):
                U[m.r + r][m.c + c] = m.block[r][c]

    #print "L:"
    #printMatrix(L)
    #print "U:"
    #printMatrix(U)
    R = multiplyMatrix(L,U)
    print "R:"
    printMatrix(R)
Пример #5
0
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
Пример #6
0
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
Пример #7
0
def ShutdownTest(workerID):
    """
    Test shutdown commands
    """
    # Send shutdown message to commThread
    PyDOOMS.shutdown()

    # Wait for thread to shutdown with a timeout
    PyDOOMS._comm.commThread.join(1)

    if (PyDOOMS._comm.commThread.isAlive()):
        logging.critical("isAlive(): " + str(PyDOOMS._comm.commThread.isAlive()))
        raise Exception
Пример #8
0
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
Пример #9
0
def printDict():
    """
    Prints the contents of the local object store.
    """
    objects = PyDOOMS._store.objects.copy()
    logging.debug("-------------------------------------Node: " + str(PyDOOMS.getNodeID()) + " --------------------------------------------")
    for element in objects:
        if (isinstance(objects[element],TestObject)):
            logging.debug(str(element) + "  -  " + str(objects[element]))
Пример #10
0
def printBlockMatrix(startingID):
    M = [[0.0 for i in range(size)] for j in range(size)]

    for id in range(startingID, startingID + blocksPerSide*blocksPerSide):
        m = PyDOOMS.get(id)
        #print "adding block",id,"with x,y",m.r,m.c
        for r in range(len(m.block)):
            for c in range(len(m.block)):
                M[m.r + r][m.c + c] = m.block[r][c]

    printMatrix(M)
Пример #11
0
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
Пример #12
0
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
Пример #13
0
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
Пример #14
0
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
Пример #15
0
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
Пример #16
0
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
Пример #17
0
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
Пример #18
0
def ShutdownTest():
    """
    Test shutdown commands
    """
    # Send several shutdown messages to commThread
    PyDOOMS.shutdown()
    PyDOOMS.shutdown()
    PyDOOMS.shutdown()

    # Restart commThread
    PyDOOMS._reset()

    # commThread should be alive
    if not (PyDOOMS._comm.commThread.isAlive()):
        logging.critical("isAlive(): " + str(PyDOOMS._comm.commThread.isAlive()))
        raise Exception
Пример #19
0
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()
Пример #20
0
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
Пример #21
0
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.")
Пример #22
0
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
Пример #23
0
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")
Пример #24
0
        # Create regular chunks
        for i in range(0,numberOfWorkers):
            RowChunk(getChunkRowIndex(row,i+1), matrix[row][i*chunkSize + 1:i*chunkSize+chunkSize+1])

        # Last column has single element chunks
        lastColumn = matrix[row][matrixSize-1:matrixSize]

        # Pad to use it as any other chunk
        rightmostChunk = []
        rightmostChunk.append(lastColumn[0])
        for e in range(chunkSize-1):
            rightmostChunk.append(None)

        RowChunk(getChunkRowIndex(row,numberOfWorkers+1),rightmostChunk)


def generateMatrix(size):
    random_matrix = [[float(randrange(0,10)) for e in range(size)] for e in range(size)]
    return random_matrix


def printMatrix(matrix):
    for i in range(len(matrix)):
        print(str(matrix[i]))



matrixSize = 1200

PyDOOMS.execute(gaussSeidel, matrixSize)
Пример #25
0
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
Пример #26
0
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
Пример #27
0
    #logging.info("WriteLoopTest1 finished")
    reset()

    #WriteLoopTest2(workerID)
    #logging.info("WriteLoopTest2 finished")
    #reset()

    WriteLoopTest3(workerID)
    #logging.info("WriteLoopTest3 finished")
    reset()

    AttributeTest1(workerID)
    #logging.info("AttributeTest1 finished")
    reset()

    ObjectAttributeTest1(workerID)
    #logging.info("ObjectAttributeTest1 finished")

    ShutdownTest(workerID)
    #logging.info("ShutdownTest finished")


try:
    PyDOOMS.execute(testSuite)

    if (PyDOOMS.getNodeID() == 0):
        logging.info("All tests passed")

except Exception as e:
    logging.exception(e)
    logging.critical("Tests failed")
Пример #28
0
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
Пример #29
0
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
Пример #30
0
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