exchange.h File Reference

#include "partmanager.h"
#include "slotsmanager.h"
#include "drift.h"

Include dependency graph for exchange.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Typedefs
typedef int(*	ExchangeLayoutFunc) (int p, const void *userdata)

Functions
int	domain_exchange (ExchangeLayoutFunc, const void *layout_userdata, int do_gc, struct DriftData *drift, struct part_manager_type *pman, struct slots_manager_type *sman, int maxiter, MPI_Comm Comm)
void	domain_test_id_uniqueness (struct part_manager_type *pman)

Typedef Documentation

ExchangeLayoutFunc

typedef int(* ExchangeLayoutFunc) (int p, const void *userdata)

Definition at line 8 of file exchange.h.

Function Documentation

domain_exchange()

int domain_exchange	(	ExchangeLayoutFunc	layoutfunc,
		const void *	layout_userdata,
		int	do_gc,
		struct DriftData *	drift,
		struct part_manager_type *	pman,
		struct slots_manager_type *	sman,
		int	maxiter,
		MPI_Comm	Comm
	)

Definition at line 103 of file exchange.c.

                                                                                                                                                                                                                     {
    int failure = 0;
 
    /* register the MPI types used in communication if not yet. */
    if (MPI_TYPE_PLAN_ENTRY == 0) {
        MPI_Type_contiguous(sizeof(ExchangePlanEntry), MPI_BYTE, &MPI_TYPE_PLAN_ENTRY);
        MPI_Type_commit(&MPI_TYPE_PLAN_ENTRY);
    }
 
    /*Structure for building a list of particles that will be exchanged*/
    ExchangePlan plan = domain_init_exchangeplan(Comm);
 
    walltime_measure("/Domain/exchange/init");
 
    int iter = 0;
 
    do {
        if(iter >= maxiter) {
            failure = 1;
            break;
        }
        domain_build_exchange_list(layoutfunc, layout_userdata, &plan, (iter > 0 ? NULL : drift), pman, sman, Comm);
 
        /*Exit early if nothing to do*/
        if(!MPIU_Any(plan.nexchange > 0, Comm))
        {
            myfree(plan.ExchangeList);
            walltime_measure("/Domain/exchange/togo");
            break;
        }
 
        /* determine for each rank how many particles have to be shifted to other ranks */
        plan.last = domain_find_iter_space(&plan, pman, sman);
        domain_build_plan(iter, layoutfunc, layout_userdata, &plan, pman, Comm);
        walltime_measure("/Domain/exchange/togo");
 
 
        /* Do a GC if we are asked to or if this isn't the last iteration.
         * The gc decision is made collective in domain_exchange_once,
         * and a gc will also be done if we have no space for particles.*/
        int really_do_gc = do_gc || (plan.last < plan.nexchange);
 
        failure = domain_exchange_once(&plan, really_do_gc, pman, sman, Comm);
 
        myfree(plan.ExchangeList);
 
        if(failure)
            break;
        iter++;
    }
    while(MPIU_Any(plan.last < plan.nexchange, Comm));
#ifdef DEBUG
    /* This does not apply for the FOF code, where the exchange list is pre-assigned
     * and we only get one iteration. */
    if(!failure && maxiter > 1) {
        ExchangePlan plan9 = domain_init_exchangeplan(Comm);
        /* Do not drift again*/
        domain_build_exchange_list(layoutfunc, layout_userdata, &plan9, NULL, pman, sman, Comm);
        if(plan9.nexchange > 0)
            endrun(5, "Still have %ld particles in exchange list\n", plan9.nexchange);
        myfree(plan9.ExchangeList);
        domain_free_exchangeplan(&plan9);
    }
#endif
    domain_free_exchangeplan(&plan);
 
    return failure;
}

References domain_build_exchange_list(), domain_build_plan(), domain_exchange_once(), domain_find_iter_space(), domain_free_exchangeplan(), domain_init_exchangeplan(), endrun(), ExchangePlan::ExchangeList, ExchangePlan::last, MPI_TYPE_PLAN_ENTRY, MPIU_Any(), myfree, ExchangePlan::nexchange, and walltime_measure.

Referenced by domain_decompose_full(), domain_maintain(), fof_try_particle_exchange(), test_exchange(), test_exchange_uneven(), test_exchange_with_garbage(), and test_exchange_zero_slots().

Here is the call graph for this function:

Here is the caller graph for this function:

domain_test_id_uniqueness()

void domain_test_id_uniqueness

(

struct part_manager_type *

pman

)

Definition at line 570 of file exchange.c.

{
    int64_t i;
    MyIDType *ids;
    int NTask, ThisTask;
    MPI_Comm_size(MPI_COMM_WORLD, &NTask);
    MPI_Comm_rank(MPI_COMM_WORLD, &ThisTask);
 
    message(0, "Testing ID uniqueness...\n");
 
    ids = (MyIDType *) mymalloc("ids", pman->NumPart * sizeof(MyIDType));
 
    #pragma omp parallel for
    for(i = 0; i < pman->NumPart; i++) {
        ids[i] = pman->Base[i].ID;
        if(pman->Base[i].IsGarbage)
            ids[i] = (MyIDType) -1;
    }
 
    mpsort_mpi(ids, pman->NumPart, sizeof(MyIDType), mp_order_by_id, 8, NULL, MPI_COMM_WORLD);
 
    /*Remove garbage from the end*/
    int64_t nids = pman->NumPart;
    while(nids > 0 && (ids[nids-1] == (MyIDType)-1)) {
        nids--;
    }
 
    #pragma omp parallel for
    for(i = 1; i < nids; i++) {
        if(ids[i] <= ids[i - 1])
        {
            endrun(12, "non-unique (or non-ordered) ID=%013ld found on task=%d (i=%d NumPart=%ld)\n",
                    ids[i], ThisTask, i, nids);
        }
    }
 
    MyIDType * prev = ta_malloc("prev", MyIDType, 1);
    memset(prev, 0, sizeof(MyIDType));
    const int TAG = 0xdead;
 
    if(NTask > 1) {
        if(ThisTask == 0) {
            MyIDType * ptr = prev;
            if(nids > 0) {
                ptr = ids;
            }
            MPI_Send(ptr, sizeof(MyIDType), MPI_BYTE, ThisTask + 1, TAG, MPI_COMM_WORLD);
        }
        else if(ThisTask == NTask - 1) {
            MPI_Recv(prev, sizeof(MyIDType), MPI_BYTE,
                    ThisTask - 1, TAG, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
        }
        else if(nids == 0) {
            /* simply pass through whatever we get */
            MPI_Recv(prev, sizeof(MyIDType), MPI_BYTE, ThisTask - 1, TAG, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
            MPI_Send(prev, sizeof(MyIDType), MPI_BYTE, ThisTask + 1, TAG, MPI_COMM_WORLD);
        }
        else
        {
            MPI_Sendrecv(
                    ids+(nids - 1), sizeof(MyIDType), MPI_BYTE,
                    ThisTask + 1, TAG,
                    prev, sizeof(MyIDType), MPI_BYTE,
                    ThisTask - 1, TAG, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
        }
    }
 
    if(ThisTask > 1) {
        if(nids > 0) {
            if(ids[0] <= *prev && ids[0])
                endrun(13, "non-unique ID=%ld found on task=%d\n", ids[0], ThisTask);
        }
    }
 
    myfree(prev);
    myfree(ids);
}

References part_manager_type::Base, endrun(), particle_data::ID, particle_data::IsGarbage, message(), mp_order_by_id(), mpsort_mpi, myfree, mymalloc, NTask, part_manager_type::NumPart, ta_malloc, and ThisTask.

Referenced by domain_decompose_full(), domain_exchange_once(), init(), test_exchange(), test_exchange_uneven(), test_exchange_with_garbage(), and test_exchange_zero_slots().

Here is the call graph for this function:

Here is the caller graph for this function: