openmpi/ompi/mca/bcol/basesmuma/bcol_basesmuma_module.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;

    /* NTH: this is not set anywhere on the trunk as of 08/13/13 */
#if 0
    if (module->use_hdl) {
        sm_module->super.supported_mode = MCA_BCOL_BASE_ZERO_COPY;
    }
#endif

	/* 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);