def setUp(self): nbytes = 100 * MPI.DOUBLE.size try: self.mpi_memory = MPI.Alloc_mem(nbytes) self.memory = self.mpi_memory memzero(self.memory) except MPI.Exception: import array self.mpi_memory = None self.memory = array.array('B', [0] * nbytes) self.WIN = MPI.Win.Create(self.memory, 1, self.INFO, self.COMM)
def testAttachDetach(self): mem1 = MPI.Alloc_mem(8) mem2 = MPI.Alloc_mem(16) mem3 = MPI.Alloc_mem(32) for mem in (mem1, mem2, mem3): self.WIN.Attach(mem) self.testMemory() self.WIN.Detach(mem) for mem in (mem1, mem2, mem3): self.WIN.Attach(mem) self.testMemory() for mem in (mem1, mem2, mem3): self.WIN.Detach(mem) for mem in (mem1, mem2, mem3): self.WIN.Attach(mem) self.testMemory() for mem in (mem3, mem2, mem1): self.WIN.Detach(mem) MPI.Free_mem(mem1) MPI.Free_mem(mem2) MPI.Free_mem(mem3)
def testMessageBad(self): sbuf = MPI.Alloc_mem(4) rbuf = MPI.Alloc_mem(4) def f(): Alltoallw([sbuf], [rbuf]) self.assertRaises(ValueError, f) def f(): Alltoallw([sbuf, [0], [0], [MPI.BYTE], None], [rbuf, [0], [0], [MPI.BYTE]]) self.assertRaises(ValueError, f) def f(): Alltoallw([sbuf, [0], [0], [MPI.BYTE]], [rbuf, [0], [0], [MPI.BYTE], None]) self.assertRaises(ValueError, f) MPI.Free_mem(sbuf) MPI.Free_mem(rbuf)
def testCompareAndSwap(self): group = self.WIN.Get_group() size = group.Get_size() rank = group.Get_rank() group.Free() self.WIN.Fence() obuf = MPI.Alloc_mem(1) memzero(obuf) cbuf = MPI.Alloc_mem(1) memzero(cbuf) rbuf = MPI.Alloc_mem(1) memzero(rbuf) try: try: self.WIN.Compare_and_swap([obuf, 1, MPI.BYTE], [cbuf, 1, MPI.BYTE], [rbuf, 1, MPI.BYTE], rank, 0) finally: MPI.Free_mem(obuf) MPI.Free_mem(cbuf) MPI.Free_mem(rbuf) except NotImplementedError: self.skipTest('mpi-win-compare_and_swap') self.WIN.Fence() for array, typecode in arrayimpl.subTest(self): if unittest.is_mpi_gpu('openmpi', array): continue if unittest.is_mpi_gpu('mvapich2', array): continue if typecode in 'fdg': continue if typecode in 'FDG': continue obuf = array(+1, typecode) cbuf = array(0, typecode) rbuf = array(-1, typecode, 2) for rank in range(size): for disp in range(3): self.WIN.Lock(rank) self.WIN.Compare_and_swap(obuf.as_mpi(), cbuf.as_mpi(), rbuf.as_mpi_c(1), rank, disp) self.WIN.Unlock(rank) self.assertEqual(rbuf[1], -1)
def testFetchAndOp(self): group = self.WIN.Get_group() size = group.Get_size() rank = group.Get_rank() group.Free() self.WIN.Fence() blen = MPI.INT.Get_size() obuf = MPI.Alloc_mem(blen) memzero(obuf) rbuf = MPI.Alloc_mem(blen) memzero(rbuf) try: try: self.WIN.Fetch_and_op([obuf, 1, MPI.INT], [rbuf, 1, MPI.INT], rank) finally: MPI.Free_mem(obuf) MPI.Free_mem(rbuf) except NotImplementedError: self.skipTest('mpi-win-fetch_and_op') self.WIN.Fence() for array, typecode in arrayimpl.subTest(self): if unittest.is_mpi_gpu('openmpi', array): continue if unittest.is_mpi_gpu('mvapich2', array): continue if typecode in 'FDG': continue obuf = array(+1, typecode) rbuf = array(-1, typecode, 2) for op in (MPI.SUM, MPI.PROD, MPI.MAX, MPI.MIN, MPI.REPLACE, MPI.NO_OP): for rank in range(size): for disp in range(3): self.WIN.Lock(rank) self.WIN.Fetch_and_op(obuf.as_mpi(), rbuf.as_mpi_c(1), rank, disp, op=op) self.WIN.Unlock(rank) self.assertEqual(rbuf[1], -1)
def testMessageBad(self): buf = MPI.Alloc_mem(4) empty = [None, 0, [0], "B"] def f(): Alltoallv([buf, 0, [0], "i", None], empty) self.assertRaises(ValueError, f) def f(): Alltoallv([buf, 0, [0], "\0"], empty) self.assertRaises(KeyError, f) MPI.Free_mem(buf) buf = [1,2,3,4] def f(): Alltoallv([buf, 0, 0, "i"], empty) self.assertRaises(TypeError, f) buf = {1:2,3:4} def f(): Alltoallv([buf, 0, 0, "i"], empty) self.assertRaises(TypeError, f)
def testCompareAndSwap(self): group = self.WIN.Get_group() size = group.Get_size() rank = group.Get_rank() group.Free() self.WIN.Fence() obuf = MPI.Alloc_mem(1) memzero(obuf) cbuf = MPI.Alloc_mem(1) memzero(cbuf) rbuf = MPI.Alloc_mem(1) memzero(rbuf) try: try: self.WIN.Compare_and_swap([obuf, 1, MPI.BYTE], [cbuf, 1, MPI.BYTE], [rbuf, 1, MPI.BYTE], rank, 0) finally: MPI.Free_mem(obuf) MPI.Free_mem(cbuf) MPI.Free_mem(rbuf) except NotImplementedError: return self.WIN.Fence() for array in arrayimpl.ArrayTypes: for typecode in arrayimpl.TypeMap: if typecode in 'fdg': continue obuf = array(+1, typecode) cbuf = array(0, typecode) rbuf = array(-1, typecode, 2) for rank in range(size): for disp in range(3): self.WIN.Lock(rank) self.WIN.Compare_and_swap(obuf.as_mpi(), cbuf.as_mpi(), rbuf.as_mpi_c(1), rank, disp) self.WIN.Unlock(rank) self.assertEqual(rbuf[1], -1)
def setUp(self): nbytes = 100*MPI.DOUBLE.size try: self.mpi_memory = MPI.Alloc_mem(nbytes) self.memory = self.mpi_memory try: zero = bytearray([0]) except NameError: zero = str('\0') self.memory[:] = zero * len(self.memory) except MPI.Exception: from array import array self.mpi_memory = None self.memory = array('B',[0]*nbytes) self.WIN = MPI.Win.Create(self.memory, 1, self.INFO, self.COMM)
def testFetchAndOp(self): group = self.WIN.Get_group() size = group.Get_size() rank = group.Get_rank() group.Free() self.WIN.Fence() obuf = MPI.Alloc_mem(1) memzero(obuf) rbuf = MPI.Alloc_mem(1) memzero(rbuf) try: try: self.WIN.Fetch_and_op([obuf, 1, MPI.BYTE], [rbuf, 1, MPI.BYTE], rank) finally: MPI.Free_mem(obuf) MPI.Free_mem(rbuf) except NotImplementedError: return self.WIN.Fence() for array in arrayimpl.ArrayTypes: for typecode in arrayimpl.TypeMap: obuf = array(+1, typecode) rbuf = array(-1, typecode, 2) for op in (MPI.SUM, MPI.PROD, MPI.MAX, MPI.MIN, MPI.REPLACE, MPI.NO_OP): for rank in range(size): for disp in range(3): self.WIN.Lock(rank) self.WIN.Fetch_and_op(obuf.as_mpi(), rbuf.as_mpi_c(1), rank, disp, op=op) self.WIN.Unlock(rank) self.assertEqual(rbuf[1], -1)
def testMessageBad(self): buf = MPI.Alloc_mem(5) empty = [None, 0, [0], "B"] def f(): Alltoallv([buf, 0, [0], "i", None], empty) self.assertRaises(ValueError, f) def f(): Alltoallv([buf, 0, [0], "\0"], empty) self.assertRaises(KeyError, f) def f(): Alltoallv([buf, None, [0], MPI.DATATYPE_NULL], empty) self.assertRaises(ValueError, f) def f(): Alltoallv([buf, None, [0], "i"], empty) self.assertRaises(ValueError, f) try: t = MPI.INT.Create_resized(0, -4).Commit() def f(): Alltoallv([buf, None, [0], t], empty) self.assertRaises(ValueError, f) t.Free() except NotImplementedError: pass MPI.Free_mem(buf) buf = [1, 2, 3, 4] def f(): Alltoallv([buf, 0, 0, "i"], empty) self.assertRaises(TypeError, f) buf = {1: 2, 3: 4} def f(): Alltoallv([buf, 0, 0, "i"], empty) self.assertRaises(TypeError, f)
def __init__(self, comm, init=0): # size = comm.Get_size() rank = comm.Get_rank() mask = 1 while mask < size: mask <<= 1 mask >>= 1 idx = 0 get_idx = [] acc_idx = [] while mask >= 1: left = idx + 1 right = idx + (mask << 1) if rank < mask: acc_idx.append(left) get_idx.append(right) idx = left else: acc_idx.append(right) get_idx.append(left) idx = right rank = rank % mask mask >>= 1 # typecode = 'i' datatype = MPI.INT itemsize = datatype.Get_size() # root = 0 rank = comm.Get_rank() if rank == root: nlevels = len(get_idx) + 1 nentries = (1 << nlevels) - 1 self.mem = MPI.Alloc_mem(nentries * itemsize, MPI.INFO_NULL) self.mem[:] = _struct.pack(typecode, init) * nentries else: self.mem = None # self.win = MPI.Win.Create(self.mem, itemsize, MPI.INFO_NULL, comm) self.acc_type = datatype.Create_indexed_block(1, acc_idx).Commit() self.get_type = datatype.Create_indexed_block(1, get_idx).Commit() self.acc_buf = _array_new(len(acc_idx), typecode) self.get_buf = _array_new(len(get_idx), typecode) self.myval = 0
def __init__(self, comm): # size = comm.Get_size() rank = comm.Get_rank() # itemsize = MPI.INT.Get_size() if rank == 0: mem = MPI.Alloc_mem(itemsize * size, MPI.INFO_NULL) mem[:] = _struct.pack('i', 0) * size else: mem = MPI.BOTTOM self.win = MPI.Win.Create(mem, itemsize, MPI.INFO_NULL, comm) # blens = [rank, size - rank - 1] disps = [0, rank + 1] self.dt_get = MPI.INT.Create_indexed(blens, disps).Commit() # self.myval = 0
def setUp(self): try: self.mpi_memory = MPI.Alloc_mem(10) self.memory = self.mpi_memory memzero(self.memory) except MPI.Exception: from array import array self.mpi_memory = None self.memory = array('B', [0] * 10) refcnt = getrefcount(self.memory) self.WIN = MPI.Win.Create(self.memory, 1, self.INFO, self.COMM) if type(self.memory).__name__ == 'buffer': self.assertEqual(getrefcount(self.memory), refcnt + 1) else: if sys.version_info[:3] < (3, 3): self.assertEqual(getrefcount(self.memory), refcnt) else: self.assertEqual(getrefcount(self.memory), refcnt + 1)
def testProcNull(self): comm = self.COMM # comm.Sendrecv(None, MPI.PROC_NULL, 0, None, MPI.PROC_NULL, 0) comm.Sendrecv_replace(None, MPI.PROC_NULL, 0, MPI.PROC_NULL, 0) # comm.Send(None, MPI.PROC_NULL) comm.Isend(None, MPI.PROC_NULL).Wait() req = comm.Send_init(None, MPI.PROC_NULL) req.Start() req.Wait() req.Free() # comm.Ssend(None, MPI.PROC_NULL) comm.Issend(None, MPI.PROC_NULL).Wait() req = comm.Ssend_init(None, MPI.PROC_NULL) req.Start() req.Wait() req.Free() # buf = MPI.Alloc_mem(MPI.BSEND_OVERHEAD) MPI.Attach_buffer(buf) comm.Bsend(None, MPI.PROC_NULL) comm.Ibsend(None, MPI.PROC_NULL).Wait() req = comm.Bsend_init(None, MPI.PROC_NULL) req.Start() req.Wait() req.Free() MPI.Detach_buffer() MPI.Free_mem(buf) # comm.Rsend(None, MPI.PROC_NULL) comm.Irsend(None, MPI.PROC_NULL).Wait() req = comm.Rsend_init(None, MPI.PROC_NULL) req.Start() req.Wait() req.Free() # comm.Recv(None, MPI.PROC_NULL) comm.Irecv(None, MPI.PROC_NULL).Wait() req = comm.Recv_init(None, MPI.PROC_NULL) req.Start() req.Wait() req.Free()
def testIRecvAndBSend(self): comm = self.COMM rank = comm.Get_rank() buf = MPI.Alloc_mem((1<<16)+MPI.BSEND_OVERHEAD) MPI.Attach_buffer(buf) for smess in messages: src = dst = rank req1 = comm.irecv(None, src, 1) req2 = comm.irecv(None, src, 2) req3 = comm.irecv(None, src, 3) comm.bsend(smess, dst, 3) comm.bsend(smess, dst, 2) comm.bsend(smess, dst, 1) self.assertEqual(smess, req3.wait()) self.assertEqual(smess, req2.wait()) self.assertEqual(smess, req1.wait()) comm.bsend(smess, MPI.PROC_NULL, 3) MPI.Detach_buffer() MPI.Free_mem(buf)
def setUp(self): try: self.mpi_memory = MPI.Alloc_mem(10) self.memory = self.mpi_memory try: zero = bytearray([0]) except NameError: zero = str('\0') self.memory[:] = zero * len(self.memory) except MPI.Exception: from array import array self.mpi_memory = None self.memory = array('B', [0] * 10) refcnt = sys.getrefcount(self.memory) self.WIN = MPI.Win.Create(self.memory, 1, self.INFO, self.COMM) if type(self.memory).__name__ == 'buffer': self.assertEqual(sys.getrefcount(self.memory), refcnt + 1) else: self.assertEqual(sys.getrefcount(self.memory), refcnt)
def testMessageBad(self): buf = MPI.Alloc_mem(5) empty = [None, 0, "B"] def f(): Sendrecv([buf, 0, 0, "i", None], empty) self.assertRaises(ValueError, f) def f(): Sendrecv([buf, 0, "\0"], empty) self.assertRaises(KeyError, f) def f(): Sendrecv([buf, -1, "i"], empty) self.assertRaises(ValueError, f) def f(): Sendrecv([buf, 0, -1, "i"], empty) self.assertRaises(ValueError, f) def f(): Sendrecv([buf, 0, +2, "i"], empty) self.assertRaises(ValueError, f) def f(): Sendrecv([None, 1, 0, "i"], empty) self.assertRaises(ValueError, f) def f(): Sendrecv([buf, None, 0, "i"], empty) self.assertRaises(ValueError, f) def f(): Sendrecv([buf, 0, 1, MPI.DATATYPE_NULL], empty) self.assertRaises(ValueError, f) def f(): Sendrecv([buf, None, 0, MPI.DATATYPE_NULL], empty) self.assertRaises(ValueError, f) try: t = MPI.INT.Create_resized(0, -4).Commit() def f(): Sendrecv([buf, None, t], empty) self.assertRaises(ValueError, f) def f(): Sendrecv([buf, 0, 1, t], empty) self.assertRaises(ValueError, f) t.Free() except NotImplementedError: pass MPI.Free_mem(buf) buf = [1,2,3,4] def f(): Sendrecv([buf, 4, 0, "i"], empty) self.assertRaises(TypeError, f) buf = {1:2,3:4} def f(): Sendrecv([buf, 4, 0, "i"], empty) self.assertRaises(TypeError, f) def f(): Sendrecv(b"abc", b"abc") self.assertRaises((BufferError, TypeError, ValueError), f)
def testIRecvAndIBSend(self): comm = self.COMM rank = comm.Get_rank() buf = MPI.Alloc_mem((1 << 16) + MPI.BSEND_OVERHEAD) MPI.Attach_buffer(buf) try: for smess in messages: src = dst = rank req1 = comm.irecv(None, src, 1) req2 = comm.irecv(None, src, 2) req3 = comm.irecv(None, src, 3) req4 = comm.ibsend(smess, dst, 3) req5 = comm.ibsend(smess, dst, 2) req6 = comm.ibsend(smess, dst, 1) MPI.Request.waitall([req4, req5, req6]) self.assertEqual(smess, req3.wait()) self.assertEqual(smess, req2.wait()) self.assertEqual(smess, req1.wait()) comm.ibsend(smess, MPI.PROC_NULL, 3).wait() finally: MPI.Detach_buffer() MPI.Free_mem(buf)
def __init__(self, shape, dtype): self._length = reduce(lambda x, y: x * y, shape) if self._length > 0: self._mpi_alloc_ptr = MPI.Alloc_mem( ctypes.sizeof(dtype) * self._length) pp = ctypes.cast(self._mpi_alloc_ptr.address, ctypes.POINTER(dtype)) # numpy/ctypes will sometimes raise a RuntimeWarning (PEP3118) # relating to the deduced itemsize of the datatype passed. # Here we check that the created array has the correct itemsize, # shape and dtype. self._array = np.ctypeslib.as_array(pp, shape=shape) assert self._array.shape == tuple(shape) assert self._array.itemsize == ctypes.sizeof(dtype) assert self._array.dtype == dtype else: self._array = np.zeros(shape, dtype) self.array = self._array.view(dtype) """Numpy array formed from allocated memory.""" self.array.fill(0)
def testBSendAndRecv(self): buf = MPI.Alloc_mem((1 << 16) + MPI.BSEND_OVERHEAD) MPI.Attach_buffer(buf) try: size = self.COMM.Get_size() rank = self.COMM.Get_rank() for smess in messages: self.COMM.bsend(smess, MPI.PROC_NULL) rmess = self.COMM.recv(None, MPI.PROC_NULL, 0) self.assertEqual(rmess, None) if size == 1: return for smess in messages: if rank == 0: self.COMM.bsend(smess, rank + 1, 0) rmess = smess elif rank == size - 1: rmess = self.COMM.recv(None, rank - 1, 0) else: rmess = self.COMM.recv(None, rank - 1, 0) self.COMM.bsend(rmess, rank + 1, 0) self.assertEqual(rmess, smess) finally: MPI.Detach_buffer() MPI.Free_mem(buf)
buf[0] = b'x' except TypeError as e: print e # create a memory view of mem mv = memoryview(mem) # create a memory view of mem1 mv1 = memoryview(mem1) print 'before change: mv[0] = %s, mv1[0] = %s' % (mv[0], mv1[0]) # change mv[0] mv[0] = 'x' print 'after change: mv[0] = %s, mv1[0] = %s' % (mv[0], mv1[0]) # release the memory object mem.release() print # allocate a memory of 40 bytes, return a MPI.memory object mem = MPI.Alloc_mem(10 * 4) print 'len(mem):', len(mem) print 'mem.address:', MPI.Get_address(mem) # create a numpy array from the allocated memory # NOTE: use copy = False here to avoid the copy buf = np.array(mem, dtype='B', copy=False) # cast to be int array npary = np.ndarray(buffer=buf, dtype='i', shape=(10, )) # now you can operate the memory buffer by the usual numpy array operations npary[:] = np.arange(10) print 'npary.tobytes:', npary.tobytes() # release the memory object MPI.Free_mem(mem) print 'len(mem) after free:', len(mem)
def slave(self): #{{{ #setup prerequests #messages.STATUS {{{ self.status_reqs = array(0, dtype=int) self.status_prequest = comm.Recv_init([self.status_reqs, MPI.INT], source=0, tag=messages.STATUS) self.control_reqlist += [self.status_prequest] self.control_reqhandlers += [self.status] #}}} #messages.ABORT {{{ self.abort_reqs = array(0, dtype=int) self.abort_prequest = comm.Recv_init([self.abort_reqs, MPI.INT], source=0, tag=messages.ABORT) self.control_reqlist += [self.abort_prequest] self.control_reqhandlers += [self.abort] #}}} #messages.STATE {{{ self.state_req = array([0] * 300, dtype='uint8') #XXX, calculate exact state size self.state_prequest = comm.Recv_init([self.state_req, MPI.BYTE], source=MPI.ANY_SOURCE, tag=messages.STATE) self.computation_reqlist += [self.state_prequest] self.computation_reqhandlers += [self.state_received] #}}} self.setupGoalMessageHandler() self.termination_detection.slave_init() self.reqlist = self.control_reqlist + self.computation_reqlist self.reqhandlers = self.control_reqhandlers + self.computation_reqhandlers #print self.reqlist, self.reqhandlers #MPI buffer send space MPI.Attach_buffer(MPI.Alloc_mem(1024 * 1024)) #1Mb MPI.Prequest.Startall(self.reqlist) print "Slave", rank, "awaiting your command" self.running = True while self.running: #Do control comm, if any (i, comm_todo) = MPI.Prequest.Testany(self.control_reqlist) if comm_todo: self.control_reqhandlers[i]() self.control_reqlist[i].Start() #Do computation comm, if any (i, comm_todo) = MPI.Prequest.Testany(self.computation_reqlist) if comm_todo: #print "calling ", self.computation_reqhandlers[i] self.computation_reqhandlers[i]() self.computation_reqlist[i].Start() #Do a computation try: self.mcReachability.compute() except NoMoreStatesException: #No more work... #print "Rank %d has no more work, len(pwlist) = %d" % (rank, len(self.pwlist.waiting)) self.termination_detection.noMoreWork() #... wait for something to arrive i = MPI.Prequest.Waitany(self.reqlist) #print "calling ", self.reqhandlers[i] self.reqhandlers[i]() self.reqlist[i].Start() except GoalFoundException: #goal state found: Profit! comm.Bsend([None, MPI.INT], dest=0, tag=messages.GOAL_REACHED)
""" from mpi4py import MPI import sys nprocs = (MPI.COMM_WORLD.Get_size()) myid = MPI.Comm.Get_rank(MPI.COMM_WORLD) fh = MPI.File.Open(MPI.COMM_WORLD, 'C:/Users/wilso/Programming_analytics/small.txt', MPI.MODE_RDONLY) size = MPI.File.Get_size(fh) MPI.File.Close blocksize = size / nprocs block_start = blocksize * myid buf = MPI.Alloc_mem(100) if myid == nprocs - 1: block_end = size else: block_end = block_start + blocksize - 1 print("beginning", myid, block_start) if myid != 0: fh = open('C:/Users/wilso/Programming_analytics/small.txt') fh.seek(block_start) buffer = fh.readlines(100) block_start += sys.getsizeof(buffer[0]) - 48 print("ending", myid, block_start)
def setUp(self): self.memory = MPI.Alloc_mem(10) memzero(self.memory) self.WIN = MPI.Win.Create(self.memory, 1, self.INFO, self.COMM)
def testSequence(self): n = 16 try: mem = MPI.Alloc_mem(n, MPI.INFO_NULL) except NotImplementedError: self.skipTest('mpi-alloc_mem') try: self.assertTrue(type(mem) is MPI.memory) self.assertTrue(mem.address != 0) self.assertEqual(mem.nbytes, n) self.assertFalse(mem.readonly) self.assertEqual(len(mem), n) def delitem(): del mem[n] def getitem1(): return mem[n] def getitem2(): return mem[::2] def getitem3(): return mem[None] def setitem1(): mem[n] = 0 def setitem2(): mem[::2] = 0 def setitem3(): mem[None] = 0 self.assertRaises(Exception, delitem) self.assertRaises(IndexError, getitem1) self.assertRaises(IndexError, getitem2) self.assertRaises(TypeError, getitem3) self.assertRaises(IndexError, setitem1) self.assertRaises(IndexError, setitem2) self.assertRaises(TypeError, setitem3) for i in range(n): mem[i] = i for i in range(n): self.assertEqual(mem[i], i) mem[:] = 0 for i in range(n): self.assertEqual(mem[i], 0) mem[:] = 255 for i in range(n): self.assertEqual(mem[i], 255) mem[:n // 2] = 1 mem[n // 2:] = 0 for i in range(n // 2): self.assertEqual(mem[i], 1) for i in range(n // 2, n): self.assertEqual(mem[i], 0) mem[:] = 0 mem[1:5] = b"abcd" mem[10:13] = b"xyz" self.assertEqual(mem[0], 0) for i, c in enumerate("abcd"): self.assertEqual(mem[1 + i], ord(c)) for i in range(5, 10): self.assertEqual(mem[i], 0) for i, c in enumerate("xyz"): self.assertEqual(mem[10 + i], ord(c)) for i in range(13, n): self.assertEqual(mem[i], 0) self.assertEqual(mem[1:5].tobytes(), b"abcd") self.assertEqual(mem[10:13].tobytes(), b"xyz") finally: MPI.Free_mem(mem) self.assertEqual(mem.address, 0) self.assertEqual(mem.nbytes, 0) self.assertFalse(mem.readonly)
win = MPI.Win.Allocate(0, disp_unit=4, comm=comm) # Lock_all win.Lock_all() reqs = [] for rk in [1, 2, 3]: a = np.array([rk, rk], dtype='i') # Rput req = win.Rput(a, target_rank=rk) reqs.append(req) print 'rank %d put %s to rank %d' % (rank, a, rk) # compute all Rput MPI.Request.Waitall(reqs) # Unlock_all win.Unlock_all() comm.Barrier() else: win = MPI.Win.Allocate(8, disp_unit=4, comm=comm) comm.Barrier() # convert the memory of win to numpy array buf = np.array(buffer(win.tomemory()), dtype='B', copy=False) mem = np.ndarray(buffer=buf, dtype='i', shape=(2, )) print 'rank %d get %s' % (rank, mem) # Create_dynamic win = MPI.Win.Create_dynamic(comm=comm) mem = MPI.Alloc_mem(8) # Attach and Detach win.Attach(mem) win.Detach(mem) MPI.Free_mem(mem)
class NodeType(IntEnum): MASTER = 0 FOLLOWER = 1 class Tags(IntEnum): INITIAL_EDGES = 0 PARTITION_MAP = 1 OWNERSHIPS = 2 EDGE_QUERY = 3 EDGE_RESPONSE = 4 STITCHING = 5 MERGE = 6 PICKLE_SET_OVERHEAD = 31 PICKLE_LIST_OVERHEAD = 6 PICKLE_TUPLE_OVERHEAD = 3 PICKLE_BIG_INT_OVERHEAD = 25 MAX_NODES = 200000 comm = MPI.COMM_WORLD rank = comm.Get_rank() size = comm.Get_size() buf = MPI.Alloc_mem(MAX_NODES * PICKLE_BIG_INT_OVERHEAD + PICKLE_SET_OVERHEAD * size + MPI.BSEND_OVERHEAD * size) MPI.Attach_buffer(buf)
# Generate MPI thread-safe info message if mpi_initialized and not is_mpi_thread_safe: mpi_thread_safe_info_msg = "Provided MPI implementation (%s) is not thread safe configured, " % ( mpi_vendor_str) mpi_thread_safe_info_msg = mpi_thread_safe_info_msg + "maximum thread safe level supported is: %s" % ( mpi_thread_safe_level_str) mpi_thread_safe_info_msg = mpi_thread_safe_info_msg + "\nNOTE: In most MPI implementations thread-safety " mpi_thread_safe_info_msg = mpi_thread_safe_info_msg + "can be enabled at pre-compile, " mpi_thread_safe_info_msg = mpi_thread_safe_info_msg + "by setting explicit thread-safe configuration options, " mpi_thread_safe_info_msg = mpi_thread_safe_info_msg + "\n e.g. (MPI 1.6.5) --enable-mpi-thread-multiple" # Allocate memory for buffered sends if mpi_initialized and mpi_world_size > 1 and is_mpi_thread_safe: try: mpi_buffer_size_in_mb = 100 __mpi_buffer = __mpi_factory.Alloc_mem(mpi_buffer_size_in_mb * 1024 * 1024) __mpi_factory.Attach_buffer(__mpi_buffer) mpi_buffer_allocated = True except Exception, instance: mpi_buffer_allocated = False mpi_buffer_allocation_error_msg = traceback.format_exc() # Check if MPI is effectively enabled if mpi_initialized and mpi_world_size > 1 and is_mpi_thread_safe and mpi_buffer_allocated: is_mpi_enabled = True else: is_mpi_enabled = False if not mpi_initialized: mpi_error_msg = mpi_initialization_error_msg elif mpi_world_size < 2: mpi_error_msg = "Only 1 MPI process found"