feectools 0.1.0__py3-none-any.whl

feectools/ddm/partition.py

@@ -0,0 +1,207 @@
+import numpy    as np
+import numpy.ma as ma
+
+from sympy.ntheory import factorint
+
+__all__ = ('compute_dims', 'partition_procs_per_patch')
+
+#==============================================================================
+def partition_procs_per_patch(npts, size):
+    """
+    Compute the number of processes in each patch and assign to it an ascending range of processes.
+    The processes are distributed porportionally to the patch grid size.
+
+    Parameters
+    ----------
+    npts : list
+        Number of points along each dimension for each patch.
+
+    size : int
+        Number of processes.
+
+    Returns
+    -------
+    sizes : list of int
+        Number of processes in each patch.
+
+    ranges: list of list of int
+        The assigned ascending range of processes for each patch, 
+        the range is represented by a list of ints of size 2 [k1,k2],
+        such that k1<=k2.
+
+    """
+    npts       = [np.prod(nc) for nc in npts]
+    percentage = [nc / sum(npts) for nc in npts]
+    sizes      = np.array([int(p*size) for p in percentage])
+    diff       = [p * size - s for s, p in zip(sizes, percentage)]
+    indices    = np.argsort(diff)[::-1]
+    rm         = size - sum(sizes)
+
+    sizes[indices[:rm]] +=1
+    assert sum(sizes) == size
+
+    #...
+    start  = 0
+    ranges = []
+    for s in sizes:
+        ranges.append([start, start+s-1])
+        start += s
+
+    assert start == size
+
+    ranges = np.array(ranges)
+    ranks  = [i[0] for i in ranges[indices[:rm]]]
+
+    if len(ranks) == 0:
+        if any(s==0 for s in sizes):
+            raise ValueError("Cannot compute sizes with given input values!")
+
+    k = 0
+    for i,s in enumerate(sizes):
+        if s > 0:
+            continue
+        sizes[i]  = 1
+        ranges[i] = [ranks[k], ranks[k]]
+        k         = (k+1) % size
+
+    return sizes, ranges
+
+#==============================================================================
+def compute_dims( nnodes, gridsizes, min_blocksizes=None, mpi=None, try_uniform=False, mpi_dims_mask=None ):
+    """
+    With the aim of distributing a multi-dimensional array on a Cartesian
+    topology, compute the number of processes along each dimension.
+
+    Whenever possible, the number of processes is chosen so that the array is
+    decomposed into identical blocks.
+
+    Parameters
+    ----------
+    nnodes : int
+        Number of processes in the Cartesian topology.
+
+    gridsizes : list of int
+        Number of array elements along each dimension.
+
+    min_blocksizes : list of int
+        Minimum acceptable size of a block along each dimension. 
+
+    try_uniform: bool
+        try to decompose the array uniformly.
+        
+    mpi_dims_mask: list of bool
+        True if the dimension is to be used in the domain decomposition (=default for each dimension). 
+        If dim_mask[i]=False, the domain decomposition yields blocksizes[i]=gridsizes[i] along the i-th dimension.
+
+    Returns
+    -------
+    dims : list of int
+        Number of processes along each dimension of the Cartesian topology. 
+
+    blocksizes : list of int
+        Nominal block size along each dimension.
+
+    """
+    assert nnodes > 0
+    assert all( s > 0 for s in gridsizes )
+    assert np.prod( gridsizes ) >= nnodes
+
+    if (min_blocksizes is not None):
+        assert len( min_blocksizes ) == len( gridsizes )
+        assert all( m > 0 for m in gridsizes )
+        assert all( s >= m for s,m in zip( gridsizes, min_blocksizes ) )
+
+    # Determine whether uniform decomposition is possible
+    uniform = (np.prod( gridsizes ) % nnodes == 0)
+
+    # Compute dimensions of MPI Cartesian topology with most appropriate algorithm
+    if try_uniform and uniform:
+        dims, blocksizes = compute_dims_uniform( nnodes, gridsizes )
+    else:
+        dims, blocksizes = compute_dims_general( nnodes, gridsizes, mpi_dims_mask=mpi_dims_mask )
+
+    # If a minimum block size is given, verify that condition is met
+
+    if min_blocksizes is not None:
+        too_small = any( [s < m for (s,m) in zip( blocksizes, min_blocksizes )] )
+
+        # If uniform decomposition yields blocks too small, fall back to general algorithm
+        if uniform and too_small:
+            dims, blocksizes = compute_dims_general( nnodes, gridsizes )
+            too_small = any( [s < m for (s,m) in zip( blocksizes, min_blocksizes )] )
+
+        # If general decomposition yields blocks too small, raise error
+        if too_small:
+            raise ValueError("Cannot compute dimensions with the minimum acceptable block sizes {}".format(tuple(min_blocksizes)))
+
+    return dims, blocksizes
+
+#==============================================================================
+def compute_dims_general( mpi_size, npts, mpi_dims_mask=None ):
+
+    if mpi_dims_mask is None:
+        mpi_dims_mask = [True] * len(npts)
+    else:
+        assert len(mpi_dims_mask) == len(npts), "mpi_dims_mask must have one entry for each dimension."
+        assert all(isinstance(m, bool) for m in mpi_dims_mask), "mpi_dims_mask must only contain True/False values."
+        assert any(mpi_dims_mask), "mpi_dims_mask must contain at least one True value."
+
+    nprocs = [1]*len( npts )
+    
+    shape = []
+    for n, use_dim in zip(npts, mpi_dims_mask):
+        if use_dim:
+            shape += [n]
+        else:
+            shape += [-1]
+
+    f = factorint( mpi_size, multiple=True )
+    f.sort( reverse=True )
+
+    for a in f:
+
+        i = np.argmax( shape )
+        max_shape = shape[i]
+
+        if shape.count( max_shape ) > 1:
+            i = ma.array( nprocs, mask=np.not_equal( shape, max_shape ) ).argmin()
+
+        nprocs[i]  *= a
+        shape [i] //= a
+        
+    for i, use_dim in enumerate(mpi_dims_mask):
+        if not use_dim:
+            shape[i] = npts[i]
+
+    return nprocs, shape
+
+#==============================================================================
+def compute_dims_uniform( mpi_size, npts ):
+
+    nprocs = [1]*len( npts )
+
+    mpi_factors   = factorint( int(mpi_size) )
+    npts_factors  = [factorint( int(n) ) for n in npts]
+
+    nprocs = [1 for n in npts]
+
+    for a,power in mpi_factors.items():
+
+        exponents = [f.get( a, 0 ) for f in npts_factors]
+
+        for k in range( power ):
+
+            i = np.argmax( exponents )
+            max_exp = exponents[i]
+
+            if exponents.count( max_exp ) > 1:
+                i = ma.array( nprocs, mask=np.not_equal( exponents, max_exp ) ).argmin()
+
+            nprocs   [i] *= a
+            exponents[i] -= 1
+
+            npts_factors[i][a] -= 1
+
+    shape = [np.prod( [key**val for key,val in f.items()] ) for f in npts_factors]
+
+    return nprocs, shape

feectools/ddm/petsc.py

@@ -0,0 +1,112 @@
+# coding: utf-8
+
+import numpy as np
+from itertools import product
+
+from .cart import CartDecomposition
+
+#===============================================================================
+class PetscCart:
+
+    def __init__(self, cart):
+        assert isinstance(cart, CartDecomposition)
+
+        try:
+            from petsc4py import PETSc
+        except ImportError:
+            raise ImportError('petsc4py needs to be installed in order to use the class PetscCart')
+
+        self._cart  = cart
+        self._petsc = PETSc
+
+        self._indices          = self._create_indices()
+        self._extended_indices = self._create_extended_indices()
+        self._ao               = self._create_Ao()
+        self._l2g_mapping      = self._create_LGMap()
+
+        # Compute local shape of local arrays in topology (without ghost regions)
+        self._local_shape = tuple( e-s+1 for s,e in zip( cart._starts, cart._ends ) )
+
+        # Compute local size of local arrays in topology (without ghost regions)
+        self._local_size  = np.prod(self._local_shape)
+ 
+
+    @property
+    def cart( self ):
+        return self._cart
+
+    @property
+    def petsc( self ):
+        return self._petsc
+
+    @property
+    def indices( self ):
+        return self._indices
+
+    @property
+    def extended_indices( self ):
+        return self._extended_indices
+
+    @property
+    def ao( self ):
+        return self._ao
+
+    @property
+    def local_size( self ):
+        return self._local_size
+
+    @property
+    def local_shape( self ):
+        return self._local_shape
+
+    @property
+    def l2g_mapping( self ):
+        return self._l2g_mapping
+        
+    def _create_indices( self ):
+        """ Create the global indices without the ghost regions.
+        """
+        cart    = self.cart
+        indices = product(*cart._grids)
+        npts    = cart.npts
+        array   = [np.ravel_multi_index(i, npts) for i in indices]
+        return array
+
+    def _create_extended_indices( self ):
+        """ Create the global indices with the ghost regions.
+        """
+        cart    = self.cart
+        indices = product(*cart._extended_grids)
+        npts    = cart.npts
+        mode    = tuple('wrap' if P else 'clip' for P in cart.periods)
+        array   = [np.ravel_multi_index(i, npts, mode=mode) for i in indices]
+        return array
+
+    def _create_Ao( self ):
+        """ Create the mapping between the global ordering and the natural ordering.
+        """
+        cart    = self.cart
+        indices = self.indices
+        return self.petsc.AO().createBasic(indices, comm=cart.comm)
+
+    def _create_LGMap( self ):
+        """ Create local to global mapping.
+        """
+        cart    = self.cart
+        indices = self.extended_indices
+        ao      = self.ao
+        return self.petsc.LGMap().create(ao.app2petsc(indices), comm=cart.comm)
+
+    def create_g2n(self, gvec, natural):
+        """ This method creates a natural ordering vector from a global ordering vector.
+        """
+        cart     = self.cart
+        indices  = self.indices
+        size     = self.local_size
+        start,_  = natural.getOwnershipRange()
+
+        from_is = self.petsc.IS().createStride(size, start, 1, comm=cart.comm)
+        to_is   = self.petsc.IS().createGeneral(indices, comm=cart.comm)
+
+        return self.petsc.Scatter().create(gvec, from_is, natural, to_is)
+

feectools/ddm/tests/test_cart_1d.py

@@ -0,0 +1,138 @@
+# Contents of test_cart_1d.py
+
+import numpy as np
+
+from feectools.ddm.blocking_data_exchanger    import BlockingCartDataExchanger
+from feectools.ddm.nonblocking_data_exchanger import NonBlockingCartDataExchanger
+
+#===============================================================================
+# TEST CartDecomposition and CartDataExchanger in 1D
+#===============================================================================
+def run_cart_1d( data_exchanger_type, verbose=False ):
+
+    import numpy as np
+    from feectools.ddm.mpi import mpi as MPI
+    from feectools.ddm.cart import DomainDecomposition, CartDecomposition
+
+    #---------------------------------------------------------------------------
+    # INPUT PARAMETERS
+    #---------------------------------------------------------------------------
+
+    # Number of cells
+    nc1 = 135
+
+    # Padding ('thickness' of ghost region)
+    p1 = 3
+
+    # Periodicity
+    period1 = True
+
+    # Number of Points
+    n1 = nc1 + p1*(1-period1)
+    #---------------------------------------------------------------------------
+    # DOMAIN DECOMPOSITION
+    #---------------------------------------------------------------------------
+
+    # Parallel info
+    comm = MPI.COMM_WORLD
+    size = comm.Get_size()
+    rank = comm.Get_rank()
+
+    domain_decomposition = DomainDecomposition(ncells=[nc1], periods=[period1], comm=comm)
+
+    es = domain_decomposition.global_element_starts[0]
+    ee = domain_decomposition.global_element_ends  [0]
+
+    global_ends        = [ee]
+    global_ends[0][-1] = n1-1
+    global_starts      = [np.array([0] + (global_ends[0][:-1]+1).tolist())]
+
+    # Decomposition of Cartesian domain
+    cart = CartDecomposition(
+            domain_decomposition = domain_decomposition,
+            npts          = [n1],
+            global_starts = global_starts,
+            global_ends   = global_ends,
+            pads          = [p1],
+            shifts        = [1],
+    )
+
+    # Local 1D array (extended domain)
+    u = np.zeros( cart.shape, dtype=int )
+
+    # Global indices of first and last elements of array
+    s1, = cart.starts
+    e1, = cart.ends
+
+    # Create object in charge of exchanging data between subdomains
+    synchronizer = data_exchanger_type( cart, u.dtype )
+
+    # Print some info
+    if verbose:
+
+        if rank == 0:
+            print( "" )
+
+        for k in range(size):
+            if k == rank:
+                print( "RANK = {}".format( rank ) )
+                print( "---------" )
+                print( ". s1:e1 = {:2d}:{:2d}".format( s1,e1 ) )
+                print( "", flush=True )
+            comm.Barrier()
+
+    #---------------------------------------------------------------------------
+    # TEST
+    #---------------------------------------------------------------------------
+
+    # Fill in true domain with u[i1_loc]=i1_glob
+    u[p1:-p1] = [i1 for i1 in range(s1,e1+1)]
+
+    request = synchronizer.prepare_communications(u)
+
+    # Update ghost regions
+    synchronizer.start_update_ghost_regions(  u, request )
+    synchronizer.end_update_ghost_regions(  u, request )
+
+    #---------------------------------------------------------------------------
+    # CHECK RESULTS
+    #---------------------------------------------------------------------------
+    # Verify that ghost cells contain correct data (note periodic domain!)
+    success = all( u[:] == [i1%n1 for i1 in range(s1-p1,e1+p1+1)] )
+
+    # MASTER only: collect information from all processes
+    success_global = comm.reduce( success, op=MPI.LAND, root=0 )
+
+    return locals()
+
+#===============================================================================
+# RUN TEST WITH PYTEST
+#===============================================================================
+import pytest
+
+@pytest.mark.parametrize( 'data_exchanger_type', [BlockingCartDataExchanger, NonBlockingCartDataExchanger] )
+@pytest.mark.parallel
+def test_cart_1d( data_exchanger_type ):
+
+    namespace = run_cart_1d( data_exchanger_type )
+
+    assert namespace['success']
+
+#===============================================================================
+# RUN TEST MANUALLY
+#===============================================================================
+if __name__=='__main__':
+
+    locals().update( run_cart_1d( BlockingCartDataExchanger, verbose=True ) )
+
+    # Print error messages (if any) in orderly fashion
+    for k in range(size):
+        if k == rank and not success:
+            print( "Rank {}: wrong ghost cell data!".format( rank ), flush=True )
+        comm.Barrier()
+
+    if rank == 0:
+        if success_global:
+            print( "PASSED", end='\n\n', flush=True )
+        else:
+            print( "FAILED", end='\n\n', flush=True )

feectools/ddm/tests/test_cart_2d.py

@@ -0,0 +1,164 @@
+# File test_cart_2d.py
+
+from feectools.ddm.blocking_data_exchanger    import BlockingCartDataExchanger
+from feectools.ddm.nonblocking_data_exchanger import NonBlockingCartDataExchanger
+
+#===============================================================================
+# TEST CartDecomposition and CartDataExchanger in 2D
+#===============================================================================
+def run_cart_2d( data_exchanger_type, verbose=False , nprocs=None, reverse_axis=None):
+
+    import numpy as np
+    from feectools.ddm.mpi import mpi as MPI  
+    from feectools.ddm.cart import DomainDecomposition, CartDecomposition
+
+    #---------------------------------------------------------------------------
+    # INPUT PARAMETERS
+    #---------------------------------------------------------------------------
+
+    # Number of cells
+    nc1 = 135
+    nc2 = 77
+
+    # Padding ('thickness' of ghost region)
+    p1 = 3
+    p2 = 2
+
+    # Periodicity
+    period1 = True
+    period2 = False
+
+    # Number of Points
+    n1 = nc1 + p1*(1-period1)
+    n2 = nc2 + p2*(1-period2)
+    #---------------------------------------------------------------------------
+    # DOMAIN DECOMPOSITION
+    #---------------------------------------------------------------------------
+
+    # Parallel info
+    comm = MPI.COMM_WORLD
+    size = comm.Get_size()
+    rank = comm.Get_rank()
+
+    domain_decomposition = DomainDecomposition(ncells=[nc1,nc2], periods=[period1,period2], comm=comm)
+    
+    npts          = [n1,n2]
+    global_starts = [None]*2
+    global_ends   = [None]*2
+    for axis in range(2):
+        es = domain_decomposition.global_element_starts[axis]
+        ee = domain_decomposition.global_element_ends  [axis]
+
+        global_ends  [axis]     = (ee+1)-1
+        global_ends  [axis][-1] = npts[axis]-1
+        global_starts[axis]     = np.array([0] + (global_ends[axis][:-1]+1).tolist())
+
+    # Decomposition of Cartesian domain
+    cart = CartDecomposition(
+            domain_decomposition      = domain_decomposition,
+            npts          = [n1,n2],
+            global_starts = global_starts,
+            global_ends   = global_ends,
+            pads          = [p1,p2],
+            shifts        = [1,1],
+    )
+
+    # Local 2D array with 2D vector data (extended domain)
+    shape = list( cart.shape ) + [2]
+    u = np.zeros( shape, dtype=int )
+
+    # Global indices of first and last elements of array
+    s1,s2 = cart.starts
+    e1,e2 = cart.ends
+
+    # Create object in charge of exchanging data between subdomains
+    synchronizer = data_exchanger_type( cart, u.dtype, coeff_shape=[2] )
+
+    # Print some info
+    if rank == 0:
+        print( "" )
+
+    for k in range(size):
+        if k == rank:
+            print( "Proc. # {}".format( rank ) )
+            print( "---------" )
+            print( ". s1:e1 = {:2d}:{:2d}".format( s1,e1 ) )
+            print( ". s2:e2 = {:2d}:{:2d}".format( s2,e2 ) )
+            print( "", flush=True )
+        comm.Barrier()
+
+    #---------------------------------------------------------------------------
+    # TEST
+    #---------------------------------------------------------------------------
+
+    # Fill in true domain with u[i1_loc,i2_loc,:]=[i1_glob,i2_glob]
+    u[p1:-p1,p2:-p2,:] = [[(i1,i2) for i2 in range(s2,e2+1)] for i1 in range(s1,e1+1)]
+
+
+    request = synchronizer.prepare_communications(u)
+
+    # Update ghost regions
+    synchronizer.start_update_ghost_regions(  u, request )
+    synchronizer.end_update_ghost_regions( u, request )
+
+    #---------------------------------------------------------------------------
+    # CHECK RESULTS
+    #---------------------------------------------------------------------------
+
+    # Verify that ghost cells contain correct data (note periodic domain!)
+    val = lambda i1,i2: (i1%n1,i2) if 0<=i2<n2 else (0,0)
+    uex = [[val(i1,i2) for i2 in range(s2-p2,e2+p2+1)] for i1 in range(s1-p1,e1+p1+1)]
+
+    success = (u == uex).all()
+
+    # MASTER only: collect information from all processes
+    success_global = comm.reduce( success, op=MPI.LAND, root=0 )
+
+    return locals()
+
+#===============================================================================
+# RUN TEST WITH PYTEST
+#===============================================================================
+import pytest
+
+@pytest.mark.parametrize( 'data_exchanger_type', [BlockingCartDataExchanger, NonBlockingCartDataExchanger] )
+@pytest.mark.parallel
+def test_cart_2d(data_exchanger_type):
+
+    namespace = run_cart_2d(data_exchanger_type)
+
+    assert namespace['success']
+
+@pytest.mark.parallel
+def test_cart_2d_reverse_axis_0():
+
+    namespace = run_cart_2d(BlockingCartDataExchanger, reverse_axis=0)
+
+    assert namespace['success']
+
+@pytest.mark.parallel
+def test_cart_2d_reverse_axis_1():
+
+    namespace = run_cart_2d(BlockingCartDataExchanger, reverse_axis=1)
+
+    assert namespace['success']
+
+#===============================================================================
+# RUN TEST MANUALLY
+#===============================================================================
+if __name__=='__main__':
+
+    locals().update( run_cart_2d( BlockingCartDataExchanger, verbose=True ) )
+
+    # Print error messages (if any) in orderly fashion
+    for k in range(size):
+        if k == rank and not success:
+            print( "Rank {}: wrong ghost cell data!".format( rank ), flush=True )
+        comm.Barrier()
+
+    if rank == 0:
+        if success_global:
+            print( "PASSED", end='\n\n', flush=True )
+        else:
+            print( "FAILED", end='\n\n', flush=True )
+