Example #1
0
    def size(self):
        """
        size = comm.size()

        Returns the size of the communicator
        """
        return core.comm_size( self.id )
Example #2
0
def gather( array, root, comm ):
    """
    """
    myid = core.comm_rank(comm)
    nprocs = core.comm_size(comm)
    if( myid==root ):
        print nm.size(array)
        datatype = getMpiType(array)
        size = nm.size(array)
        shape = nm.shape(array)
        rank = nm.rank(array)
    else:
        datatype = 0
        size = 0
        shape = 0
        rank = 0
    datatype = core.bcast( datatype, 1, core.MPI_INT, root, comm )
    rank = core.bcast( rank, 1, core.MPI_INT, root, comm )
    shape = core.bcast( shape, rank, core.MPI_INT, root, comm )
    size = core.bcast( size, 1, core.MPI_INT, root, comm )
    data = core.gather( array, size, datatype,
                        size, datatype,
                        root, comm )
    if(myid == root):
        print shape
        
        shape[0] = shape[0] * nprocs
        
        print shape
        array = nm.asarray(data)
        print nm.size(array)
        array.shape = shape
        return array
    else:
        return None
Example #3
0
def gatherv(  message, root = 0,comm=core.MPI_COMM_WORLD ):
    rank = core.comm_rank( comm )
    size = core.comm_size( comm )
    #raise NotImplementedError
    s = pickle.dumps(message)
    
    recvlengths = core.gather(len(s),1,core.MPI_INT,
                              1, core.MPI_INT,
                              root, comm)
    #if(rank==root):
    #    print "recvlengths:",recvlengths
        
    displacements = [0]
    displ = 0
    for rl in recvlengths[:-1]:
        displacements.append( displ+rl )
        displ += rl
        
    #if(rank==root):
    #    print "displacements:",displacements
        
    data = core.gatherv(s, len(s), core.MPI_CHAR,
                        recvlengths, displacements, core.MPI_CHAR,
                        root, comm)
    if rank==root:
        data = data.tostring()
        #    print data
        #    print "length of data:",len(data)
        i,n=0,0
        #    print recvlengths
        realdata = []
        
        for length in recvlengths:
            n += length
            #        print "i,n=%d,%d"%(i,n)
            #        print data[i:n]
            realdata.append(pickle.loads(data[i:n]))
            i += length       
    else:
        realdata = None
    return realdata
Example #4
0
def scatterv(buffer, root=0, comm=core.MPI_COMM_WORLD):
    """
    Input Parameters
      sendbuf: address of send buffer (choice, significant only at root)
      sendcounts: integer array (of length group size) specifying the number of elements to send to each processor
      displs: integer array (of length group size). Entry i specifies the displacement (relative to sendbuf from which to take the outgoing data to process i
      sendtype: data type of send buffer elements (handle)
      recvcount: number of elements in receive buffer (integer)
      recvtype: data type of receive buffer elements (handle)
      root: rank of sending process (integer)
      comm: communicator (handle)

    Output Parameter
      recvbuf: address of receive buffer (choice)
    """
    size = core.comm_size( comm )
    rank = core.comm_rank( comm )

    length = len(buffer)
    sendbuffer = []
    displacements = []
    sendcounts = []
    charbuffer = ""
    if( rank == root ):
        for b in buffer:
            sendbuffer.append( pickle.dumps( b ) )
        if( length % size == 0 ):
            for x in xrange( size ):
                start = x * size
                end = start + size
                elements = sendbuffer[start:end]
                es = pickle.dumps(elements)
                s = 0
                d = 0
                s = len(es)
                sendcounts.append(s)
                displacements.append(d)
                d += s
                charbuffer += es
        else:
            remainder = length % size
            for x in xrange( size ):
                if( x == 0 ):
                    start = 0
                    end = size + remainder
                else:
                    start = remainder + (x * size)
                    end = start + size
            elements = sendbuffer[start:end]
            es = pickle.dumps(elements)
            s = 0
            d = 0
            s = len(es)
            sendcounts.append(s)
            displacements.append(d)
            d+=s
            charbuffer+=es
        # SEND:
    recvbuffer = core.scatterv( charbuffer, sendcounts, displacements, core.MPI_CHAR,
                   sendcounts[rank], core.MPI_CHAR, root, comm )

    data = pickle.loads(recvbuffer)
    return data
Example #5
0
 def __init__(self, id):
     communicator.Communicator.__init__(self, int(id))
     self.size = core.comm_size(self.id)
     self.rank = core.comm_rank(self.id)
Example #6
0
 def comm_size(self):
     return core.comm_size(self.id)