9d4a26f47d
Notes:
- This commit also eliminates the need for an available components list in use
in several frameworks. None of the code in question was making use of the
priority field of the priority component list item so these extra lists were
removed.
- Cleaned up selection code in several frameworks to sort lists using opal_list_sort.
- Cleans up the ompi/orte-info functions. Expose the functions that construct the
list of params so they can be used elsewhere.
patches for mtl/portals4 from brian
missed a few output variables in openib
This commit was SVN r28241.
582 строки
18 KiB
C
582 строки
18 KiB
C
/*
|
|
* Copyright (c) 2009-2012 Oak Ridge National Laboratory. All rights reserved.
|
|
* Copyright (c) 2009-2012 Mellanox Technologies. All rights reserved.
|
|
* Copyright (c) 2012 Los Alamos National Security, LLC.
|
|
* All rights reserved.
|
|
* $COPYRIGHT$
|
|
*
|
|
* Additional copyrights may follow
|
|
*
|
|
* $HEADER$
|
|
*/
|
|
|
|
/**
|
|
* @file
|
|
*
|
|
*/
|
|
|
|
#include "ompi_config.h"
|
|
#include "ompi/constants.h"
|
|
#include "ompi/communicator/communicator.h"
|
|
#include "ompi/mca/bcol/bcol.h"
|
|
#include "ompi/mca/bcol/base/base.h"
|
|
#include "ompi/patterns/net/netpatterns.h"
|
|
|
|
#include "opal/util/show_help.h"
|
|
#include "opal/align.h"
|
|
|
|
#include "bcol_basesmuma.h"
|
|
#include "bcol_basesmuma_utils.h"
|
|
|
|
|
|
|
|
|
|
|
|
static void
|
|
mca_bcol_basesmuma_module_construct(mca_bcol_basesmuma_module_t *module)
|
|
{
|
|
module->super.bcol_component = (mca_bcol_base_component_t *) &mca_bcol_basesmuma_component;
|
|
module->super.list_n_connected = NULL;
|
|
module->super.hier_scather_offset = 0;
|
|
|
|
}
|
|
|
|
static void
|
|
mca_bcol_basesmuma_module_destruct(mca_bcol_basesmuma_module_t *sm_module)
|
|
{
|
|
/* local variables */
|
|
int i;
|
|
mca_bcol_basesmuma_component_t *cs = &mca_bcol_basesmuma_component;
|
|
|
|
/*
|
|
* release allocated resrouces
|
|
*/
|
|
|
|
/* ...but not until you're sure you have no outstanding collectives */
|
|
while(0 != opal_list_get_size(&(cs->nb_admin_barriers))) {
|
|
opal_progress();
|
|
}
|
|
|
|
|
|
|
|
|
|
/* collective topology data */
|
|
if( sm_module->fanout_read_tree) {
|
|
for(i=0 ; i < sm_module->super.size_of_subgroup ; i++ ) {
|
|
if(0 < sm_module->fanout_read_tree[i].n_children ) {
|
|
free(sm_module->fanout_read_tree[i].children_ranks);
|
|
sm_module->fanout_read_tree[i].children_ranks=NULL;
|
|
}
|
|
}
|
|
free(sm_module->fanout_read_tree);
|
|
sm_module->fanout_read_tree=NULL;
|
|
}
|
|
|
|
/* gvm Leak FIX Reduction_tree[].children_ranks has
|
|
* to be removed. I don't how to get the size (which is
|
|
* size of subgroup) of array reduction_tree
|
|
*/
|
|
if( sm_module->reduction_tree) {
|
|
for(i=0 ; i < sm_module->super.size_of_subgroup ; i++ ) {
|
|
if(0 < sm_module->reduction_tree[i].n_children ) {
|
|
free(sm_module->reduction_tree[i].children_ranks);
|
|
sm_module->reduction_tree[i].children_ranks=NULL;
|
|
}
|
|
}
|
|
free(sm_module->reduction_tree);
|
|
sm_module->reduction_tree=NULL;
|
|
}
|
|
|
|
/* gvm Leak FIX */
|
|
if (sm_module->fanout_node.children_ranks){
|
|
free(sm_module->fanout_node.children_ranks);
|
|
sm_module->fanout_node.children_ranks = NULL;
|
|
}
|
|
|
|
if (sm_module->fanin_node.children_ranks){
|
|
free(sm_module->fanin_node.children_ranks);
|
|
sm_module->fanin_node.children_ranks = NULL;
|
|
}
|
|
|
|
/* colls_no_user_data resrouces */
|
|
if(sm_module->colls_no_user_data.ctl_buffs_mgmt){
|
|
free(sm_module->colls_no_user_data.ctl_buffs_mgmt);
|
|
sm_module->colls_no_user_data.ctl_buffs_mgmt=NULL;
|
|
}
|
|
if(sm_module->colls_no_user_data.ctl_buffs){
|
|
free(sm_module->colls_no_user_data.ctl_buffs);
|
|
sm_module->colls_no_user_data.ctl_buffs=NULL;
|
|
}
|
|
|
|
/* colls_with_user_data resrouces */
|
|
|
|
if(sm_module->colls_with_user_data.ctl_buffs_mgmt){
|
|
free(sm_module->colls_with_user_data.ctl_buffs_mgmt);
|
|
sm_module->colls_with_user_data.ctl_buffs_mgmt=NULL;
|
|
}
|
|
if(sm_module->colls_with_user_data.ctl_buffs){
|
|
free(sm_module->colls_with_user_data.ctl_buffs);
|
|
sm_module->colls_with_user_data.ctl_buffs=NULL;
|
|
}
|
|
|
|
if(sm_module->shared_memory_scratch_space) {
|
|
free(sm_module->shared_memory_scratch_space);
|
|
sm_module->shared_memory_scratch_space=NULL;
|
|
}
|
|
|
|
#if 1
|
|
if(sm_module->scatter_kary_tree) {
|
|
for(i=0 ; i < sm_module->super.size_of_subgroup ; i++ ) {
|
|
if(0 < sm_module->scatter_kary_tree[i].n_children) {
|
|
free(sm_module->scatter_kary_tree[i].children_ranks);
|
|
sm_module->scatter_kary_tree[i].children_ranks=NULL;
|
|
}
|
|
}
|
|
free(sm_module->scatter_kary_tree);
|
|
}
|
|
#endif
|
|
|
|
if(NULL != sm_module->super.list_n_connected ){
|
|
free(sm_module->super.list_n_connected);
|
|
sm_module->super.list_n_connected = NULL;
|
|
}
|
|
|
|
/* free the k-nomial allgather tree here */
|
|
|
|
|
|
|
|
/* done */
|
|
}
|
|
|
|
static void bcol_basesmuma_set_small_msg_thresholds(struct mca_bcol_base_module_t *super)
|
|
{
|
|
mca_bcol_basesmuma_module_t *basesmuma_module =
|
|
(mca_bcol_basesmuma_module_t *) super;
|
|
|
|
size_t basesmuma_offset = bcol_basesmuma_data_offset_calc(basesmuma_module);
|
|
|
|
/* Set the Allreduce threshold, for Basesmuma it equals to ML buffer size - data offset */
|
|
super->small_message_thresholds[BCOL_ALLREDUCE] =
|
|
basesmuma_module->ml_mem.ml_mem_desc->size_buffer - basesmuma_offset;
|
|
|
|
/* Set the Bcast threshold, for Basesmuma it equals to ML buffer size - data offset */
|
|
super->small_message_thresholds[BCOL_BCAST] =
|
|
basesmuma_module->ml_mem.ml_mem_desc->size_buffer - basesmuma_offset;
|
|
|
|
/* Set the Gather threshold, for Basesmuma it equals to ML buffer size - data offset */
|
|
super->small_message_thresholds[BCOL_GATHER] =
|
|
(basesmuma_module->ml_mem.ml_mem_desc->size_buffer - basesmuma_offset) /
|
|
ompi_comm_size(basesmuma_module->super.sbgp_partner_module->group_comm);
|
|
|
|
/* Set the ALLgather threshold, for Basesmuma it equals to ML buffer size - data offset */
|
|
super->small_message_thresholds[BCOL_ALLGATHER] =
|
|
(basesmuma_module->ml_mem.ml_mem_desc->size_buffer - basesmuma_offset) /
|
|
ompi_comm_size(basesmuma_module->super.sbgp_partner_module->group_comm);
|
|
|
|
/* Set the Reduce threshold, for Basesmuma it equals to ML buffer size - data offset */
|
|
super->small_message_thresholds[BCOL_REDUCE] =
|
|
basesmuma_module->ml_mem.ml_mem_desc->size_buffer - basesmuma_offset;
|
|
|
|
/* Set the Scatter threshold, for Basesmuma it equals to ML buffer size - data offset */
|
|
super->small_message_thresholds[BCOL_SCATTER] =
|
|
basesmuma_module->ml_mem.ml_mem_desc->size_buffer - basesmuma_offset;
|
|
}
|
|
|
|
|
|
static void load_func_with_choices(mca_bcol_base_module_t *super)
|
|
{
|
|
int fnc;
|
|
|
|
/* Loading memory management and collective functions */
|
|
|
|
for (fnc=0; fnc < BCOL_NUM_OF_FUNCTIONS; fnc++) {
|
|
super->bcol_function_init_table[fnc] = NULL;
|
|
}
|
|
|
|
super->bcol_function_init_table[BCOL_FANIN] = bcol_basesmuma_fanin_init;
|
|
super->bcol_function_init_table[BCOL_FANOUT] = bcol_basesmuma_fanout_init;
|
|
super->bcol_function_init_table[BCOL_BARRIER] = bcol_basesmuma_barrier_init;
|
|
|
|
super->bcol_function_init_table[BCOL_BCAST] = bcol_basesmuma_bcast_init;
|
|
super->bcol_function_init_table[BCOL_ALLREDUCE] = NULL;
|
|
super->bcol_function_init_table[BCOL_REDUCE] = NULL;
|
|
super->bcol_function_init_table[BCOL_GATHER] = NULL;
|
|
super->bcol_function_init_table[BCOL_ALLGATHER] = NULL;
|
|
super->bcol_function_init_table[BCOL_SYNC] = bcol_basesmuma_memsync_init;
|
|
/* memory management */
|
|
super->bcol_memory_init = bcol_basesmuma_bank_init_opti;
|
|
|
|
super->k_nomial_tree = bcol_basesmuma_setup_knomial_tree;
|
|
|
|
/* Set thresholds */
|
|
super->set_small_msg_thresholds = bcol_basesmuma_set_small_msg_thresholds;
|
|
|
|
}
|
|
|
|
static int load_recursive_knomial_info(mca_bcol_basesmuma_module_t
|
|
*sm_module)
|
|
{
|
|
int rc = OMPI_SUCCESS;
|
|
rc = netpatterns_setup_recursive_knomial_tree_node(
|
|
sm_module->super.sbgp_partner_module->group_size,
|
|
sm_module->super.sbgp_partner_module->my_index,
|
|
mca_bcol_basesmuma_component.k_nomial_radix,
|
|
&sm_module->knomial_exchange_tree);
|
|
return rc;
|
|
}
|
|
|
|
|
|
int bcol_basesmuma_setup_knomial_tree(mca_bcol_base_module_t *super)
|
|
{
|
|
mca_bcol_basesmuma_module_t *sm_module = (mca_bcol_basesmuma_module_t *) super;
|
|
|
|
return netpatterns_setup_recursive_knomial_allgather_tree_node(
|
|
sm_module->super.sbgp_partner_module->group_size,
|
|
sm_module->super.sbgp_partner_module->my_index,
|
|
mca_bcol_basesmuma_component.k_nomial_radix,
|
|
super->list_n_connected,
|
|
&sm_module->knomial_allgather_tree);
|
|
}
|
|
|
|
|
|
|
|
|
|
/* query to see if the module is available for use on the given
|
|
* communicator, and if so, what it's priority is. This is where
|
|
* the backing shared-memory file is created.
|
|
*/
|
|
mca_bcol_base_module_t **
|
|
mca_bcol_basesmuma_comm_query(mca_sbgp_base_module_t *module, int *num_modules)
|
|
{
|
|
/* local variables */
|
|
mca_bcol_base_module_t **sm_modules = NULL;
|
|
mca_bcol_basesmuma_module_t *sm_module;
|
|
bcol_basesmuma_registration_data_t *sm_reg_data;
|
|
int ret, my_rank, name_length;
|
|
char *name;
|
|
int i;
|
|
|
|
int bcast_radix;
|
|
|
|
mca_bcol_basesmuma_component_t *cs = &mca_bcol_basesmuma_component;
|
|
/*mca_base_component_list_item_t *hdl_cli = NULL;*/
|
|
/*int hdl_num;*/
|
|
|
|
/* at this point I think there is only a sinle shared
|
|
memory bcol that we need to be concerned with */
|
|
|
|
/* No group, no modules */
|
|
if (OPAL_UNLIKELY(NULL == module)) {
|
|
return NULL;
|
|
}
|
|
|
|
/* allocate and initialize an sm_bcol module */
|
|
sm_module = OBJ_NEW(mca_bcol_basesmuma_module_t);
|
|
|
|
/* set the subgroup */
|
|
sm_module->super.sbgp_partner_module=module;
|
|
|
|
(*num_modules)=1;
|
|
cs->super.n_net_contexts = *num_modules;
|
|
sm_modules = (mca_bcol_base_module_t **) malloc((cs->super.n_net_contexts)*
|
|
sizeof(mca_bcol_base_module_t *));
|
|
|
|
if( !sm_modules ) {
|
|
fprintf(stderr,"In base_bcol_masesmuma_setup_library_buffers failed to allocate memory for sm_modules\n");
|
|
fflush(stderr);
|
|
return NULL;
|
|
}
|
|
|
|
sm_module->reduction_tree = NULL;
|
|
sm_module->fanout_read_tree = NULL;
|
|
|
|
ret=netpatterns_setup_recursive_doubling_tree_node(
|
|
module->group_size,module->my_index,
|
|
&(sm_module->recursive_doubling_tree));
|
|
if(OMPI_SUCCESS != ret) {
|
|
fprintf(stderr,"Error setting up recursive_doubling_tree \n");
|
|
fflush(stderr);
|
|
return NULL;
|
|
}
|
|
|
|
/* setup the fanin tree - this is used only as part of a hierarchical
|
|
* barrier, so will set this up with rank 0 as the root */
|
|
my_rank=module->my_index;
|
|
ret=netpatterns_setup_narray_tree(cs->radix_fanin,
|
|
my_rank,module->group_size,&(sm_module->fanin_node));
|
|
if(OMPI_SUCCESS != ret) {
|
|
fprintf(stderr,"Error setting up fanin tree \n");
|
|
fflush(stderr);
|
|
return NULL;
|
|
}
|
|
|
|
/* setup the fanout tree - this is used only as part of a hierarchical
|
|
* barrier, so will set this up with rank 0 as the root */
|
|
ret=netpatterns_setup_narray_tree(cs->radix_fanout,
|
|
my_rank,module->group_size,&(sm_module->fanout_node));
|
|
if(OMPI_SUCCESS != ret) {
|
|
fprintf(stderr,"Error setting up fanout tree \n");
|
|
fflush(stderr);
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* Setup the broadcast tree - this is used only as part of a hierarchical
|
|
* bcast, so will set this up with rank 0 as the root.
|
|
*/
|
|
|
|
/* set the radix of the bcast tree */
|
|
bcast_radix = cs->radix_read_tree;
|
|
|
|
/* initialize fan-out read tree */
|
|
sm_module->fanout_read_tree=(netpatterns_tree_node_t*) malloc(
|
|
sizeof(netpatterns_tree_node_t)*module->group_size);
|
|
if( NULL == sm_module->fanout_read_tree ) {
|
|
goto Error;
|
|
}
|
|
|
|
for(i = 0; i < module->group_size; i++){
|
|
ret = netpatterns_setup_narray_tree(bcast_radix,
|
|
i, module->group_size, &(sm_module->fanout_read_tree[i]));
|
|
if(OMPI_SUCCESS != ret) {
|
|
goto Error;
|
|
}
|
|
}
|
|
|
|
ret = load_recursive_knomial_info(sm_module);
|
|
if (OMPI_SUCCESS != ret) {
|
|
BASESMUMA_VERBOSE(10, ("Failed to load recursive knomial tree"));
|
|
goto Error;
|
|
}
|
|
|
|
/* Allocate offsets array for lmsg reduce */
|
|
/*
|
|
ret = alloc_lmsg_reduce_offsets_array(sm_module);
|
|
if (OMPI_SUCCESS != ret) {
|
|
BASESMUMA_VERBOSE(10, ("Failed to allocate reduce offsets array"));
|
|
goto Error;
|
|
}
|
|
*/
|
|
|
|
/* initialize reduction tree */
|
|
sm_module->reduction_tree=(netpatterns_tree_node_t *) malloc(
|
|
sizeof(netpatterns_tree_node_t )*module->group_size);
|
|
if( NULL == sm_module->reduction_tree ) {
|
|
goto Error;
|
|
}
|
|
|
|
ret=netpatterns_setup_multinomial_tree(
|
|
cs->order_reduction_tree,module->group_size,
|
|
sm_module->reduction_tree);
|
|
if( MPI_SUCCESS != ret ) {
|
|
goto Error;
|
|
}
|
|
|
|
/* get largest power of k for given group size */
|
|
sm_module->pow_k_levels = pow_sm_k(cs->k_nomial_radix,
|
|
sm_module->super.sbgp_partner_module->group_size,
|
|
&(sm_module->pow_k));
|
|
|
|
/* get largest power of 2 for a given group size
|
|
* used in scatter allgather
|
|
*/
|
|
sm_module->pow_2_levels = pow_sm_k(2,
|
|
sm_module->super.sbgp_partner_module->group_size,
|
|
&(sm_module->pow_2));
|
|
|
|
/*
|
|
* setup scatter data
|
|
*/
|
|
sm_module->scatter_kary_radix=cs->scatter_kary_radix;
|
|
sm_module->scatter_kary_tree=NULL;
|
|
ret=netpatterns_setup_narray_tree_contigous_ranks(
|
|
sm_module->scatter_kary_radix,
|
|
sm_module->super.sbgp_partner_module->group_size,
|
|
&(sm_module->scatter_kary_tree));
|
|
if(OMPI_SUCCESS != ret) {
|
|
fprintf(stderr,"In base_bcol_masesmuma_setup_library_buffers and scatter k-ary tree setup failed \n");
|
|
fflush(stderr);
|
|
return NULL;
|
|
}
|
|
|
|
/* setup the module shared memory management */
|
|
ret=base_bcol_basesmuma_setup_library_buffers(sm_module, cs);
|
|
|
|
if(OMPI_SUCCESS != ret) {
|
|
fprintf(stderr,"In base_bcol_masesmuma_setup_library_buffers and mpool was not successfully setup!\n");
|
|
fflush(stderr);
|
|
return NULL;
|
|
}
|
|
|
|
/* setup the collectives and memory management */
|
|
|
|
/* check to see whether or not the mpool has been inited */
|
|
/* allocate some space for the network contexts */
|
|
if(!cs->mpool_inited) {
|
|
/* if it's empty, then fill it for first time */
|
|
cs->super.network_contexts = (bcol_base_network_context_t **)
|
|
malloc((cs->super.n_net_contexts)*
|
|
sizeof(bcol_base_network_context_t *));
|
|
/* you need to do some basic setup - define the file name,
|
|
* set data seg alignment and size of cntl structure in sm
|
|
* file.
|
|
*/
|
|
/* give the payload sm file a name */
|
|
name_length=asprintf(&name,
|
|
"%s"OPAL_PATH_SEP"0%s%0d",
|
|
ompi_process_info.job_session_dir,
|
|
cs->payload_base_fname,
|
|
(int)getpid());
|
|
if( 0 > name_length ) {
|
|
fprintf(stderr,"Failed to assign the shared memory payload file a name\n");
|
|
fflush(stderr);
|
|
return NULL;
|
|
}
|
|
/* make sure name is not too long */
|
|
if ( OPAL_PATH_MAX < (name_length-1) ) {
|
|
fprintf(stderr,"Shared memory file name is too long!\n");
|
|
fflush(stderr);
|
|
return NULL;
|
|
}
|
|
/* set the name and alignment characteristics */
|
|
sm_reg_data = (bcol_basesmuma_registration_data_t *) malloc(
|
|
sizeof(bcol_basesmuma_registration_data_t));
|
|
sm_reg_data->file_name = name;
|
|
|
|
sm_reg_data->data_seg_alignment = getpagesize();
|
|
sm_reg_data->size_ctl_structure = 0;
|
|
cs->super.network_contexts[0] = (bcol_base_network_context_t *)
|
|
malloc(sizeof(bcol_base_network_context_t));
|
|
cs->super.network_contexts[0]->context_data =
|
|
(void *) sm_reg_data;
|
|
cs->super.network_contexts[0]->
|
|
register_memory_fn = mca_bcol_basesmuma_register_sm;
|
|
cs->super.network_contexts[0]->
|
|
deregister_memory_fn = mca_bcol_basesmuma_deregister_sm;
|
|
sm_module->super.network_context = cs->super.network_contexts[0];
|
|
} else {
|
|
|
|
sm_module->super.network_context = cs->super.network_contexts[0];
|
|
}
|
|
|
|
/* Set the header size */
|
|
sm_module->super.header_size = sizeof(mca_bcol_basesmuma_header_t);
|
|
|
|
|
|
|
|
/* collective setup */
|
|
load_func_with_choices(&(sm_module->super));
|
|
|
|
/*
|
|
* This initializes all collective algorithms
|
|
*/
|
|
|
|
ret = mca_bcol_base_bcol_fns_table_init(&(sm_module->super));
|
|
|
|
if (OMPI_SUCCESS != ret) {
|
|
|
|
goto Error;
|
|
}
|
|
|
|
sm_module->super.supported_mode = 0;
|
|
|
|
if (module->use_hdl) {
|
|
sm_module->super.supported_mode = MCA_BCOL_BASE_ZERO_COPY;
|
|
}
|
|
|
|
/* Initializes portals library required for basesmuma large message */
|
|
#ifdef __PORTALS_AVAIL__
|
|
/* Enable zero copy mode */
|
|
sm_module->super.supported_mode = MCA_BCOL_BASE_ZERO_COPY;
|
|
|
|
ret = mca_bcol_basesmuma_portals_init(cs);
|
|
if (OMPI_SUCCESS != ret) {
|
|
return NULL;
|
|
}
|
|
|
|
sm_module->sg_state.phase = INIT;
|
|
|
|
ret = PtlEQAlloc(((mca_bcol_basesmuma_portal_proc_info_t*)
|
|
cs->portals_info)->ni_h, MAX_PORTAL_EVENTS_IN_Q,
|
|
PTL_EQ_HANDLER_NONE, &sm_module->sg_state.read_eq);
|
|
|
|
if (ret != PTL_OK) {
|
|
BASESMUMA_VERBOSE(10,( "PtlEQAlloc() failed: %d",ret));
|
|
return NULL;
|
|
}
|
|
|
|
#endif
|
|
/* blocking recursive double barrier test */
|
|
/*
|
|
{
|
|
fprintf(stderr,"BBB About to hit the barrier test\n");
|
|
fflush(stderr);
|
|
int rc;
|
|
bcol_function_args_t bogus;
|
|
rc = bcol_basesmuma_rd_barrier_init(&(sm_module->super));
|
|
rc = bcol_basesmuma_recursive_double_barrier(
|
|
&bogus, &(sm_module->super));
|
|
}
|
|
*/
|
|
|
|
/* in this case we only expect a single network context.
|
|
in the future we should loop around this */
|
|
sm_modules[0] = &(sm_module->super);
|
|
|
|
#if 0
|
|
/* debug */
|
|
/* test resource recycling */
|
|
test_sm_module=sm_module;
|
|
/* debug */
|
|
fprintf(stderr," ZZZZ sn %lld \n",sm_module->squence_number_offset);
|
|
fflush(stderr);
|
|
/* end debug */
|
|
test_resrouce_recycle();
|
|
|
|
/* end debug */
|
|
#endif
|
|
|
|
return sm_modules;
|
|
|
|
Error:
|
|
|
|
/* cleanup */
|
|
if( sm_module->reduction_tree ) {
|
|
free(sm_module->reduction_tree);
|
|
sm_module->reduction_tree=NULL;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
|
|
#if 0
|
|
/*
|
|
* Init module on the communicator
|
|
*/
|
|
static int
|
|
basesmuma_module_enable(mca_bcol_base_module_t *module,
|
|
struct ompi_communicator_t *comm)
|
|
{
|
|
/* local variables */
|
|
char output_buffer[2*MPI_MAX_OBJECT_NAME];
|
|
|
|
memset(&output_buffer[0],0,sizeof(output_buffer));
|
|
snprintf(output_buffer,sizeof(output_buffer),"%s (cid %d)", comm->c_name,
|
|
comm->c_contextid);
|
|
opal_output_verbose(10, ompi_bcol_base_framework.framework_output,
|
|
"bcol:basesmuma:enable: new communicator: %s", output_buffer);
|
|
|
|
/* All done */
|
|
return OMPI_SUCCESS;
|
|
}
|
|
#endif
|
|
|
|
OBJ_CLASS_INSTANCE(mca_bcol_basesmuma_module_t,
|
|
mca_bcol_base_module_t,
|
|
mca_bcol_basesmuma_module_construct,
|
|
mca_bcol_basesmuma_module_destruct);
|
|
|
|
|