static void _shmem_broadcast(void *target,
const void *source,
size_t nbytes,
int PE_root,
int PE_start,
int logPE_stride,
int PE_size,
long *pSync)
{
int rc = OSHMEM_SUCCESS;
oshmem_group_t* group = NULL;
if ((0 <= PE_root) && (PE_root < PE_size)) {
/* Create group basing PE_start, logPE_stride and PE_size */
#if OSHMEM_GROUP_CACHE_ENABLED == 0
group = oshmem_proc_group_create(PE_start, (1 << logPE_stride), PE_size);
if (!group || (PE_root >= group->proc_count))
{
rc = OSHMEM_ERROR;
}
#else
group = find_group_in_cache(PE_start, logPE_stride, PE_size);
if (!group) {
group = oshmem_proc_group_create(PE_start,
(1 << logPE_stride),
PE_size);
if (!group || (PE_root >= group->proc_count)) {
rc = OSHMEM_ERROR;
} else {
cache_group(group, PE_start, logPE_stride, PE_size);
}
}
#endif /* OSHMEM_GROUP_CACHE_ENABLED */
/* Collective operation call */
if (rc == OSHMEM_SUCCESS) {
/* Define actual PE using relative in active set */
PE_root = oshmem_proc_pe(group->proc_array[PE_root]);
/* Call collective broadcast operation */
rc = group->g_scoll.scoll_broadcast(group,
PE_root,
target,
source,
nbytes,
pSync,
SCOLL_DEFAULT_ALG);
}
#if OSHMEM_GROUP_CACHE_ENABLED == 0
if ( rc == OSHMEM_SUCCESS )
{
oshmem_proc_group_destroy(group);
}
#endif /* OSHMEM_GROUP_CACHE_ENABLED */
}
}
/*
This algorithm is quite simple and straightforward. But because of it’s obvious simplicity and
the naive prove for correctness it is implemented quite often. The root send data to all.
Outlay:
NP-1 competing network transfers are needed to implement the counter
The memory usage is constant (1 byte) per node.
*/
static int __algorithm_central_counter(struct oshmem_group_t *group,
int PE_root,
void *target,
const void *source,
size_t nlong,
long *pSync)
{
int rc = OSHMEM_SUCCESS;
int i = 0;
SCOLL_VERBOSE(12,
"[#%d] Broadcast algorithm: Central Counter",
group->my_pe);
SCOLL_VERBOSE(15,
"[#%d] pSync[0] = %ld root = #%d",
group->my_pe, pSync[0], PE_root);
/* Check if this PE is the root */
if (PE_root == group->my_pe) {
int pe_cur = 0;
SCOLL_VERBOSE(14,
"[#%d] send data to all PE in the group",
group->my_pe);
for (i = 0; (i < group->proc_count) && (rc == OSHMEM_SUCCESS); i++) {
pe_cur = oshmem_proc_pe(group->proc_array[i]);
if (pe_cur != PE_root) {
SCOLL_VERBOSE(15,
"[#%d] send data to #%d",
group->my_pe, pe_cur);
rc = MCA_SPML_CALL(put(target, nlong, (void *)source, pe_cur));
}
}
}
/* Wait for operation completion to set needed size */
if (rc == OSHMEM_SUCCESS) {
SCOLL_VERBOSE(14, "[#%d] Wait for operation completion", group->my_pe);
rc = group->g_scoll.scoll_barrier(group,
(pSync + 1),
SCOLL_DEFAULT_ALG);
}
return rc;
}
int oshmem_proc_group_init(void)
{
int rc;
rc = oshmem_group_cache_init();
if (OSHMEM_SUCCESS != rc) {
return rc;
}
/* Setup communicator array */
OBJ_CONSTRUCT(&oshmem_group_array, opal_pointer_array_t);
rc = opal_pointer_array_init(&oshmem_group_array, 0,
ORTE_GLOBAL_ARRAY_MAX_SIZE, 1);
if (OPAL_SUCCESS != rc) {
goto err1;
}
/* Setup SHMEM_GROUP_ALL */
oshmem_group_all = oshmem_proc_group_create(0, 1, ompi_comm_size(oshmem_comm_world));
if (NULL == oshmem_group_all) {
goto err2;
}
/* Setup SHMEM_GROUP_SELF */
oshmem_group_self = oshmem_proc_group_create(oshmem_proc_pe(oshmem_proc_local()), 0, 1);
if (NULL == oshmem_group_self) {
goto err3;
}
/* Setup SHMEM_GROUP_NULL */
oshmem_group_null = NULL;
return OSHMEM_SUCCESS;
err3:
oshmem_proc_group_destroy_internal(oshmem_group_all, 1);
err2:
OBJ_DESTRUCT(&oshmem_group_array);
err1:
oshmem_group_cache_destroy();
return OSHMEM_ERROR;
}
static void _destroy_fca_comm(mca_scoll_fca_module_t *fca_module)
{
int ret;
struct oshmem_group_t *comm = fca_module->comm;
const int root_pe = oshmem_proc_pe(comm->proc_array[root_id]);
fca_comm_destroy(fca_module->fca_comm);
if (comm->my_pe == root_pe && mca_scoll_fca_component.fca_context) {
ret = fca_comm_end(mca_scoll_fca_component.fca_context,
fca_module->fca_comm_desc.comm_id);
if (ret < 0) {
FCA_ERROR("COMM_END failed: %s", fca_strerror(ret));
}
}
FCA_MODULE_VERBOSE(fca_module,
1,
"Destroyed FCA communicator, comm_id %d",
fca_module->fca_comm_desc.comm_id);
}
int oshmem_proc_group_init(void)
{
/* Setup communicator array */
OBJ_CONSTRUCT(&oshmem_group_array, opal_pointer_array_t);
if (OPAL_SUCCESS
!= opal_pointer_array_init(&oshmem_group_array,
0,
ORTE_GLOBAL_ARRAY_MAX_SIZE,
1)) {
return OSHMEM_ERROR;
}
/* Setup SHMEM_GROUP_ALL */
if (NULL
== (oshmem_group_all =
oshmem_proc_group_create(0,
1,
oshmem_num_procs()))) {
oshmem_proc_group_destroy(oshmem_group_all);
return OSHMEM_ERROR;
}
/* Setup SHMEM_GROUP_SELF */
if (NULL
== (oshmem_group_self = oshmem_proc_group_create(oshmem_proc_pe(oshmem_proc_local()),
0,
1))) {
oshmem_proc_group_destroy(oshmem_group_self);
return OSHMEM_ERROR;
}
/* Setup SHMEM_GROUP_NULL */
oshmem_group_null = NULL;
return OSHMEM_SUCCESS;
}
sshmem_mkey_t *mca_spml_yoda_register(void* addr,
size_t size,
uint64_t shmid,
int *count)
{
int i;
sshmem_mkey_t *mkeys;
struct yoda_btl *ybtl;
mca_spml_yoda_context_t* yoda_context;
SPML_VERBOSE(10, "address %p len %llu", addr, (unsigned long long)size);
*count = 0;
/* make sure everything is initialized to 0 */
mkeys = (sshmem_mkey_t *) calloc(1,
mca_spml_yoda.n_btls * sizeof(*mkeys));
if (!mkeys) {
return NULL ;
}
mca_bml.bml_register( MCA_SPML_YODA_PUT,
mca_yoda_put_callback,
NULL );
mca_bml.bml_register( MCA_SPML_YODA_GET,
mca_yoda_get_callback,
NULL );
mca_bml.bml_register( MCA_SPML_YODA_GET_RESPONSE,
mca_yoda_get_response_callback,
NULL );
/* Register proc memory in every rdma BTL. */
for (i = 0; i < mca_spml_yoda.n_btls; i++) {
ybtl = &mca_spml_yoda.btl_type_map[i];
mkeys[i].va_base = addr;
mkeys[i].u.key = MAP_SEGMENT_SHM_INVALID;
if (!ybtl->use_cnt) {
SPML_VERBOSE(10,
"%s: present but not in use. SKIP registration",
btl_type2str(ybtl->btl_type));
continue;
}
/* If we have shared memory just save its id */
if ((YODA_BTL_SM == ybtl->btl_type || YODA_BTL_VADER == ybtl->btl_type)
&& MAP_SEGMENT_SHM_INVALID != (int)shmid) {
mkeys[i].u.key = shmid;
mkeys[i].va_base = 0;
continue;
}
yoda_context = calloc(1, sizeof(*yoda_context));
mkeys[i].spml_context = yoda_context;
yoda_context->registration = NULL;
if (ybtl->btl->btl_flags & MCA_BTL_FLAGS_RDMA) {
if (NULL != ybtl->btl->btl_register_mem) {
yoda_context->registration = ybtl->btl->btl_register_mem (ybtl->btl, MCA_BTL_ENDPOINT_ANY,
addr, size, MCA_BTL_REG_FLAG_ACCESS_ANY);
if (NULL == yoda_context->registration) {
SPML_ERROR("%s: failed to register source memory: addr: %p, size: %u",
btl_type2str(ybtl->btl_type), addr, size);
/* FIXME some cleanup might be needed here
* yoda_context->btl_src_descriptor = NULL;
* *count = ???;
* free(spml_context);
*/
free(mkeys);
return NULL;
}
}
yoda_context->btl_src_descriptor = NULL;
mkeys[i].u.data = yoda_context->registration;
mkeys[i].len = yoda_context->registration ? ybtl->btl->btl_registration_handle_size : 0;
}
SPML_VERBOSE(5,
"rank %d btl %s va_base: 0x%p len: %d key %llx size %llu",
oshmem_proc_pe(oshmem_proc_local()), btl_type2str(ybtl->btl_type),
mkeys[i].va_base, mkeys[i].len, (unsigned long long)mkeys[i].u.key, (unsigned long long)size);
}
*count = mca_spml_yoda.n_btls;
return mkeys;
}
static int _internal_barrier(mca_scoll_fca_module_t *fca_module)
{
#if !__INTERNAL_BARRIER_FROM_SCOLL_BASIC
struct oshmem_group_t *group = fca_module->comm;
int rc = OSHMEM_SUCCESS;
int root_id = 0;
int PE_root = oshmem_proc_pe(group->proc_array[root_id]);
int i = 0;
if (PE_root != group->my_pe)
{
rc = MCA_SPML_CALL(send(NULL, 0, PE_root, MCA_SPML_BASE_PUT_STANDARD));
if (OSHMEM_SUCCESS != rc) {
return rc;
}
rc = MCA_SPML_CALL(recv(NULL, 0, PE_root));
if (OSHMEM_SUCCESS != rc) {
return rc;
}
}
/* The root collects and broadcasts the messages. */
else
{
int pe_cur = 0;
for (i = 0; (i < group->proc_count) && (rc == OSHMEM_SUCCESS); i++)
{
pe_cur = oshmem_proc_pe(group->proc_array[i]);
if (pe_cur != PE_root)
{
rc = MCA_SPML_CALL(recv(NULL, 0, SHMEM_ANY_SOURCE));
}
if (OSHMEM_SUCCESS != rc) {
return rc;
}
}
for (i = 0; (i < group->proc_count) && (rc == OSHMEM_SUCCESS); i++)
{
pe_cur = oshmem_proc_pe(group->proc_array[i]);
if (pe_cur != PE_root)
{
rc = MCA_SPML_CALL(send(NULL, 0, pe_cur, MCA_SPML_BASE_PUT_STANDARD));
}
if (OSHMEM_SUCCESS != rc) {
return rc;
}
}
}
return rc;
#else
long pSync = _SHMEM_SYNC_VALUE;
/*we use 4th algorithm for barrier from scoll/basic. It does not use pSync,
* so we pass to that function just regular long value in order to meet function defenition requirements*/
return fca_module->previous_barrier(fca_module->comm,
&pSync,
SCOLL_ALG_BARRIER_BASIC);
#endif
}
static int _fca_comm_new(mca_scoll_fca_module_t *fca_module)
{
struct oshmem_group_t *comm = fca_module->comm;
fca_comm_new_spec_t spec;
int info_size = 0, all_info_size = 0;
void *all_info = NULL, *my_info = NULL;
int *disps = NULL;
int i;
const int root_pe = oshmem_proc_pe(comm->proc_array[root_id]);
const int my_id = oshmem_proc_group_find_id(comm, comm->my_pe);
/* call fca_get_rank_info() on node managers only*/
if (fca_module->local_proc_idx == 0) {
my_info = fca_get_rank_info(mca_scoll_fca_component.fca_context,
&info_size);
if (!my_info) {
FCA_ERROR("fca_get_rank_info returned NULL");
return OSHMEM_ERROR;
}
} else {
info_size = 0;
}
FCA_MODULE_VERBOSE(fca_module, 1, "Info size: %d", info_size);
for (i = 0; i < comm->proc_count; i++) {
mca_scoll_fca_component.rcounts[i] = -1;
}
_internal_barrier(fca_module);
MCA_SPML_CALL(put((void *)&mca_scoll_fca_component.rcounts[my_id], (size_t)sizeof(info_size), (void *)&info_size, root_pe));
if (root_pe == comm->my_pe) {
int value = -1;
for (i = 0; i < comm->proc_count; i++) {
MCA_SPML_CALL(wait((void *)&mca_scoll_fca_component.rcounts[i], SHMEM_CMP_NE, &value, SHMEM_INT));
}
}
/* Allocate buffer for gathering rank information on rank0 */
if (root_pe == comm->my_pe) {
all_info_size = 0;
disps = calloc(comm->proc_count, sizeof *disps);
for (i = 0; i < comm->proc_count; ++i) {
disps[i] = all_info_size;
all_info_size += mca_scoll_fca_component.rcounts[i];
}
all_info = NULL;
FCA_MODULE_VERBOSE(fca_module,
1,
"Total rank_info size: %d",
all_info_size);
all_info = malloc(all_info_size);
memset(all_info, 0, all_info_size);
}
if (my_info) {
memcpy(mca_scoll_fca_component.my_info_exchangeable,
my_info,
info_size);
}
_internal_barrier(fca_module);
if (root_pe == comm->my_pe) {
for (i = 0; i < comm->proc_count; i++) {
if (mca_scoll_fca_component.rcounts[i] > 0) {
MCA_SPML_CALL(get((void *)mca_scoll_fca_component.my_info_exchangeable, mca_scoll_fca_component.rcounts[i], (void*)(((char*)all_info)+disps[i]),comm->proc_array[i]->super.proc_name.vpid));
}
}
}
/* Rank0 calls fca_comm_new() and fills fca_comm_spec filed */
if (root_pe == comm->my_pe) {
spec.rank_info = all_info;
spec.is_comm_world = comm == oshmem_group_all;
spec.rank_count = 0;
for (i = 0; i < comm->proc_count; ++i) {
FCA_MODULE_VERBOSE(fca_module,
1,
"rcounts[%d]=%d disps[%d]=%d",
i, mca_scoll_fca_component.rcounts[i], i, disps[i]);
if (mca_scoll_fca_component.rcounts[i] > 0)
++spec.rank_count;
}
FCA_MODULE_VERBOSE(fca_module,
1,
"starting fca_comm_new(), rank_count: %d",
spec.rank_count);
*mca_scoll_fca_component.ret =
fca_comm_new(mca_scoll_fca_component.fca_context,
&spec,
&fca_module->fca_comm_desc);
free(disps);
free(all_info);
}
_internal_barrier(fca_module);
if (root_pe != comm->my_pe) {
MCA_SPML_CALL(get((void *)mca_scoll_fca_component.ret,sizeof(int), (void *)mca_scoll_fca_component.ret, root_pe));
}
/* Examine comm_new return value */
_internal_barrier(fca_module);
if (*mca_scoll_fca_component.ret < 0) {
FCA_ERROR("rank %i: COMM_NEW failed: %s",
fca_module->rank, fca_strerror(*mca_scoll_fca_component.ret));
return OSHMEM_ERROR;
}
/* Release allocate rank_info on node managers */
if (fca_module->local_proc_idx == 0) {
fca_free_rank_info(my_info);
}
{
if (root_pe == comm->my_pe) {
memcpy(mca_scoll_fca_component.fca_comm_desc_exchangeable,
&fca_module->fca_comm_desc,
sizeof(fca_module->fca_comm_desc));
}
_internal_barrier(fca_module);
if (root_pe != comm->my_pe) {
MCA_SPML_CALL(get((void *)mca_scoll_fca_component.fca_comm_desc_exchangeable, sizeof(fca_module->fca_comm_desc), (void *)&fca_module->fca_comm_desc, root_pe));
}
_internal_barrier(fca_module);
}
FCA_MODULE_VERBOSE(fca_module,
1,
"Received FCA communicator spec, comm_id %d",
fca_module->fca_comm_desc.comm_id);
return OSHMEM_SUCCESS;
}
sshmem_mkey_t *mca_spml_ikrit_register(void* addr,
size_t size,
uint64_t shmid,
int *count)
{
int i;
sshmem_mkey_t *mkeys;
#if MXM_API >= MXM_VERSION(2,0)
mxm_error_t err;
mxm_mem_key_t *m_key;
#endif
*count = 0;
mkeys = (sshmem_mkey_t *) calloc(1, MXM_PTL_LAST * sizeof(*mkeys));
if (!mkeys) {
return NULL ;
}
for (i = 0; i < MXM_PTL_LAST; i++) {
mkeys[i].u.key = MAP_SEGMENT_SHM_INVALID;
switch (i) {
case MXM_PTL_SHM:
if ((int)shmid != MAP_SEGMENT_SHM_INVALID) {
mkeys[i].u.key = shmid;
mkeys[i].va_base = 0;
} else {
mkeys[i].len = 0;
mkeys[i].va_base = addr;
}
mkeys[i].spml_context = 0;
break;
#if MXM_API < MXM_VERSION(2,0)
case MXM_PTL_SELF:
mkeys[i].len = 0;
mkeys[i].spml_context = 0;
mkeys[i].va_base = addr;
break;
#endif
case MXM_PTL_RDMA:
mkeys[i].va_base = addr;
mkeys[i].spml_context = 0;
#if MXM_API < MXM_VERSION(2,0)
mkeys[i].len = 0;
#else
if (mca_spml_ikrit.ud_only) {
mkeys[i].len = 0;
break;
}
err = mxm_mem_map(mca_spml_ikrit.mxm_context, &addr, &size, 0, 0, 0);
if (MXM_OK != err) {
SPML_ERROR("Failed to register memory: %s", mxm_error_string(err));
goto error_out;
}
mkeys[i].spml_context = (void *)(unsigned long)size;
m_key = malloc(sizeof(*m_key));
if (NULL == m_key) {
SPML_ERROR("Failed to allocate m_key memory");
goto error_out;
}
mkeys[i].len = sizeof(*m_key);
mkeys[i].u.data = m_key;
err = mxm_mem_get_key(mca_spml_ikrit.mxm_context, addr, m_key);
if (MXM_OK != err) {
SPML_ERROR("Failed to get memory key: %s", mxm_error_string(err));
goto error_out;
}
#endif
break;
default:
SPML_ERROR("unsupported PTL: %d", i);
goto error_out;
}
SPML_VERBOSE(5,
"rank %d ptl %d addr %p size %llu %s",
oshmem_proc_pe(oshmem_proc_local()), i, addr, (unsigned long long)size,
mca_spml_base_mkey2str(&mkeys[i]));
}
*count = MXM_PTL_LAST;
return mkeys;
error_out:
mca_spml_ikrit_deregister(mkeys);
return NULL;
}
OSHMEM_DECLSPEC oshmem_group_t* oshmem_proc_group_create(int pe_start,
int pe_stride,
size_t pe_size)
{
int cur_pe, count_pe;
int i;
oshmem_group_t* group = NULL;
oshmem_proc_t** proc_array = NULL;
oshmem_proc_t* proc = NULL;
group = OBJ_NEW(oshmem_group_t);
if (group) {
cur_pe = 0;
count_pe = 0;
OPAL_THREAD_LOCK(&oshmem_proc_lock);
/* allocate an array */
proc_array = (oshmem_proc_t**) malloc(pe_size * sizeof(oshmem_proc_t*));
if (NULL == proc_array) {
OPAL_THREAD_UNLOCK(&oshmem_proc_lock);
return NULL ;
}
group->my_pe = OSHMEM_PROC_VPID(oshmem_proc_local());
group->is_member = 0;
/* now save only the procs that match this jobid */
for (proc = (oshmem_proc_t*) opal_list_get_first(&oshmem_proc_list);
proc != (oshmem_proc_t*) opal_list_get_end(&oshmem_proc_list);
proc = (oshmem_proc_t*) opal_list_get_next(proc)) {
if (count_pe >= (int) pe_size) {
break;
} else if ((cur_pe >= pe_start)
&& ((pe_stride == 0)
|| (((cur_pe - pe_start) % pe_stride) == 0))) {
proc_array[count_pe++] = proc;
if (oshmem_proc_pe(proc) == group->my_pe)
group->is_member = 1;
}
cur_pe++;
}
group->proc_array = proc_array;
group->proc_count = (int) count_pe;
group->ompi_comm = NULL;
/* Prepare peers list */
OBJ_CONSTRUCT(&(group->peer_list), opal_list_t);
{
orte_namelist_t *peer = NULL;
for (i = 0; i < group->proc_count; i++) {
peer = OBJ_NEW(orte_namelist_t);
peer->name.jobid = OSHMEM_PROC_JOBID(group->proc_array[i]);
peer->name.vpid = OSHMEM_PROC_VPID(group->proc_array[i]);
opal_list_append(&(group->peer_list), &peer->super);
}
}
group->id = opal_pointer_array_add(&oshmem_group_array, group);
memset(&group->g_scoll, 0, sizeof(mca_scoll_base_group_scoll_t));
if (OSHMEM_SUCCESS != mca_scoll_base_select(group)) {
opal_output(0,
"Error: No collective modules are available: group is not created, returning NULL");
oshmem_proc_group_destroy(group);
OPAL_THREAD_UNLOCK(&oshmem_proc_lock);
return NULL ;
} OPAL_THREAD_UNLOCK(&oshmem_proc_lock);
}
return group;
}
oshmem_group_t* oshmem_proc_group_create(int pe_start, int pe_stride, int pe_size)
{
int cur_pe, count_pe;
int i;
oshmem_group_t* group = NULL;
ompi_proc_t** proc_array = NULL;
ompi_proc_t* proc = NULL;
assert(oshmem_proc_local());
group = oshmem_group_cache_find(pe_start, pe_stride, pe_size);
if (NULL != group) {
return group;
}
group = OBJ_NEW(oshmem_group_t);
if (NULL == group) {
return NULL;
}
cur_pe = 0;
count_pe = 0;
OPAL_THREAD_LOCK(&oshmem_proc_lock);
/* allocate an array */
proc_array = (ompi_proc_t**) malloc(pe_size * sizeof(ompi_proc_t*));
if (NULL == proc_array) {
OBJ_RELEASE(group);
OPAL_THREAD_UNLOCK(&oshmem_proc_lock);
return NULL ;
}
group->my_pe = oshmem_proc_pe(oshmem_proc_local());
group->is_member = 0;
for (i = 0 ; i < ompi_comm_size(oshmem_comm_world) ; i++) {
proc = oshmem_proc_find(i);
if (NULL == proc) {
opal_output(0,
"Error: Can not find proc object for pe = %d", i);
free(proc_array);
OBJ_RELEASE(group);
OPAL_THREAD_UNLOCK(&oshmem_proc_lock);
return NULL;
}
if (count_pe >= (int) pe_size) {
break;
} else if ((cur_pe >= pe_start)
&& ((pe_stride == 0)
|| (((cur_pe - pe_start) % pe_stride) == 0))) {
proc_array[count_pe++] = proc;
if (oshmem_proc_pe(proc) == group->my_pe)
group->is_member = 1;
}
cur_pe++;
}
group->proc_array = proc_array;
group->proc_count = (int) count_pe;
group->ompi_comm = NULL;
/* Prepare peers list */
OBJ_CONSTRUCT(&(group->peer_list), opal_list_t);
{
orte_namelist_t *peer = NULL;
for (i = 0; i < group->proc_count; i++) {
peer = OBJ_NEW(orte_namelist_t);
peer->name.jobid = OSHMEM_PROC_JOBID(group->proc_array[i]);
peer->name.vpid = OSHMEM_PROC_VPID(group->proc_array[i]);
opal_list_append(&(group->peer_list), &peer->super);
}
}
group->id = opal_pointer_array_add(&oshmem_group_array, group);
memset(&group->g_scoll, 0, sizeof(mca_scoll_base_group_scoll_t));
if (OSHMEM_SUCCESS != mca_scoll_base_select(group)) {
opal_output(0,
"Error: No collective modules are available: group is not created, returning NULL");
oshmem_proc_group_destroy_internal(group, 0);
OPAL_THREAD_UNLOCK(&oshmem_proc_lock);
return NULL;
}
if (OSHMEM_SUCCESS != oshmem_group_cache_insert(group, pe_start,
pe_stride, pe_size)) {
oshmem_proc_group_destroy_internal(group, 1);
OPAL_THREAD_UNLOCK(&oshmem_proc_lock);
return NULL;
}
OPAL_THREAD_UNLOCK(&oshmem_proc_lock);
return group;
}
/*
The Binomial Spanning Tree algorithm.
Outlay:
The game scales with log2(NP) and uses 1 byte of memory.
*/
static int __algorithm_binomial_tree(struct oshmem_group_t *group,
int PE_root,
void *target,
const void *source,
size_t nlong,
long *pSync)
{
int rc = OSHMEM_SUCCESS;
long value = SHMEM_SYNC_INIT;
int root_id = oshmem_proc_group_find_id(group, PE_root);
int my_id = oshmem_proc_group_find_id(group, group->my_pe);
int peer_id = 0;
int peer_pe = 0;
int vrank;
int dim = opal_cube_dim(group->proc_count);
int hibit;
int mask;
int i = 0;
SCOLL_VERBOSE(12, "[#%d] Broadcast algorithm: Tree", group->my_pe);
SCOLL_VERBOSE(15,
"[#%d] pSync[0] = %ld root = #%d",
group->my_pe, pSync[0], PE_root);
vrank = (my_id + group->proc_count - root_id) % group->proc_count;
hibit = opal_hibit(vrank, dim);
SCOLL_VERBOSE(15,
"[#%d] dim = %d vrank = %d hibit = %d",
group->my_pe, dim, vrank, hibit);
dim--;
pSync[0] = SHMEM_SYNC_READY;
/* Receive data from parent in the tree. */
if (vrank > 0) {
value = SHMEM_SYNC_READY;
SCOLL_VERBOSE(14, "[#%d] wait", group->my_pe);
rc = MCA_SPML_CALL(wait((void*)pSync, SHMEM_CMP_NE, (void*)&value, SHMEM_LONG));
while ((value = pSync[0]) < 0) {
SCOLL_VERBOSE(14,
"[#%d] Broadcast size is a negative value (%li)\n",
group->my_pe, pSync[0]);
MCA_SPML_CALL(wait((void*)pSync, SHMEM_CMP_NE, (void*)&value, SHMEM_LONG));
}
if (OSHMEM_SUCCESS != rc) {
return rc;
}
nlong = (size_t) pSync[0];
}
/* Send data to the children. */
for (i = hibit + 1, mask = 1 << i; i <= dim; ++i, mask <<= 1) {
peer_id = vrank | mask;
if (peer_id < group->proc_count) {
/* Wait for the child to be ready to receive (pSync must have the initial value) */
peer_id = (peer_id + root_id) % group->proc_count;
peer_pe = oshmem_proc_pe(group->proc_array[peer_id]);
SCOLL_VERBOSE(14,
"[#%d] check remote pe is ready to receive #%d",
group->my_pe, peer_pe);
do {
rc = MCA_SPML_CALL(get((void*)pSync, sizeof(long), (void*)pSync, peer_pe));
} while ((OSHMEM_SUCCESS == rc) && (pSync[0] != SHMEM_SYNC_READY));
SCOLL_VERBOSE(14, "[#%d] send data to #%d", group->my_pe, peer_pe);
rc = MCA_SPML_CALL(put(target, nlong, (my_id == root_id ? (void *)source : target), peer_pe));
MCA_SPML_CALL(fence());
SCOLL_VERBOSE(14, "[#%d] signals to #%d", group->my_pe, peer_pe);
value = nlong;
rc = MCA_SPML_CALL(put((void*)pSync, sizeof(value), (void*)&value, peer_pe));
if (OSHMEM_SUCCESS != rc) {
break;
}
}
}
return rc;
}
