/* -*- Mode: C; c-basic-offset:4 ; -*- */ /* * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana * University Research and Technology * Corporation. All rights reserved. * Copyright (c) 2004-2009 The University of Tennessee and The University * of Tennessee Research Foundation. All rights * reserved. * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart, * University of Stuttgart. All rights reserved. * Copyright (c) 2004-2005 The Regents of the University of California. * All rights reserved. * Copyright (c) 2007 Lawrence Livermore National Security, LLC. All * rights reserved. * Copyright (c) 2008 Sun Microsystems, Inc. All rights reserved. * Copyright (c) 2008-2015 Cisco Systems, Inc. All rights reserved. * Copyright (c) 2020 Research Organization for Information Science * and Technology (RIST). All rights reserved. * $COPYRIGHT$ * * Additional copyrights may follow * * $HEADER$ */ #include "ompi_config.h" #include #include #include #include "mpi.h" #include "ompi/constants.h" #include "opal/util/output.h" #include "opal/class/opal_list.h" #include "opal/class/opal_object.h" #include "ompi/mca/mca.h" #include "opal/mca/base/base.h" #include "ompi/op/op.h" #include "ompi/mca/op/op.h" #include "ompi/mca/op/base/base.h" #include "ompi/mca/op/base/functions.h" /* * Local types */ typedef struct avail_op_t { opal_list_item_t super; int ao_priority; ompi_op_base_module_1_0_0_t *ao_module; } avail_op_t; /* * Local functions */ static opal_list_t *check_components(opal_list_t *components, ompi_op_t *op); static int check_one_component(ompi_op_t *op, const mca_base_component_t *component, ompi_op_base_module_1_0_0_t **module); static int query(const mca_base_component_t *component, ompi_op_t *op, int *priority, ompi_op_base_module_1_0_0_t **module); static int query_1_0_0(const ompi_op_base_component_1_0_0_t *op_component, ompi_op_t *op, int *priority, ompi_op_base_module_1_0_0_t **module); /* * Stuff for the OBJ interface */ static OBJ_CLASS_INSTANCE(avail_op_t, opal_list_item_t, NULL, NULL); /* * This function is called at the initialization time of every * *intrinsic* MPI_Op (it is *not* used for user-defined MPI_Ops!). * It is used to select which op component(s) will be active for a * given MPI_Op. * * This selection logic is not for the weak. */ int ompi_op_base_op_select(ompi_op_t *op) { int i, ret; opal_list_t *selectable; opal_list_item_t *item; ompi_op_base_module_t *module; /* Announce */ opal_output_verbose(10, ompi_op_base_framework.framework_output, "op:base:op_select: new op: %s", op->o_name); /* Make a module for all the base functions so that other modules can RETAIN it (vs. having NULL for the base function modules, and forcing all other modules to check for NULL before calling RETAIN). */ module = OBJ_NEW(ompi_op_base_module_t); /* Initialize all functions to point to the corresponding base functions. Set the corresponding module pointers to NULL, indicating that these are base functions with no corresponding module. */ memset(&op->o_func, 0, sizeof(op->o_func)); memset(&op->o_3buff_intrinsic, 0, sizeof(op->o_3buff_intrinsic)); for (i = 0; i < OMPI_OP_BASE_TYPE_MAX; ++i) { op->o_func.intrinsic.fns[i] = ompi_op_base_functions[op->o_f_to_c_index][i]; op->o_func.intrinsic.modules[i] = module; OBJ_RETAIN(module); op->o_3buff_intrinsic.fns[i] = ompi_op_base_3buff_functions[op->o_f_to_c_index][i]; op->o_3buff_intrinsic.modules[i] = module; OBJ_RETAIN(module); } /* Offset the initial OBJ_NEW */ OBJ_RELEASE(module); /* Check for any components that want to run. It's not an error if there are none; we'll just use all the base functions in this case. */ opal_output_verbose(10, ompi_op_base_framework.framework_output, "op:base:op_select: Checking all available components"); selectable = check_components(&ompi_op_base_framework.framework_components, op); /* Do the selection loop. The selectable list is in priority order; lowest priority first. */ for (item = opal_list_remove_first(selectable); NULL != item; item = opal_list_remove_first(selectable)) { avail_op_t *avail = (avail_op_t*) item; /* Enable the module */ if (NULL != avail->ao_module->opm_enable) { ret = avail->ao_module->opm_enable(avail->ao_module, op); if (OMPI_SUCCESS != ret) { /* If the module fails to enable, just release it and move on */ OBJ_RELEASE(avail->ao_module); OBJ_RELEASE(avail); continue; } } /* Copy over the non-NULL pointers */ for (i = 0; i < OMPI_OP_BASE_TYPE_MAX; ++i) { /* 2-buffer variants */ if (NULL != avail->ao_module->opm_fns[i]) { OBJ_RELEASE(op->o_func.intrinsic.modules[i]); op->o_func.intrinsic.fns[i] = avail->ao_module->opm_fns[i]; op->o_func.intrinsic.modules[i] = avail->ao_module; OBJ_RETAIN(avail->ao_module); } /* 3-buffer variants */ if (NULL != avail->ao_module->opm_3buff_fns[i]) { OBJ_RELEASE(op->o_func.intrinsic.modules[i]); op->o_3buff_intrinsic.fns[i] = avail->ao_module->opm_3buff_fns[i]; op->o_3buff_intrinsic.modules[i] = avail->ao_module; OBJ_RETAIN(avail->ao_module); } } /* release the original module reference and the list item */ OBJ_RELEASE(avail->ao_module); OBJ_RELEASE(avail); } /* Done with the list from the check_components() call so release it. */ OBJ_RELEASE(selectable); /* Sanity check: for intrinsic MPI_Ops, we should have exactly the same pointers non-NULL as the corresponding initial table row in ompi_op_base_functions / ompi_op_base_3buff_functions. The values may be different, of course, but the pattern of NULL/non-NULL should be exactly the same. */ for (i = 0; i < OMPI_OP_BASE_TYPE_MAX; ++i) { if ((NULL == ompi_op_base_functions[op->o_f_to_c_index][i] && NULL != op->o_func.intrinsic.fns[i]) || (NULL != ompi_op_base_functions[op->o_f_to_c_index][i] && NULL == op->o_func.intrinsic.fns[i])) { /* Oops -- we found a mismatch. This shouldn't happen; so go release everything and return an error (yes, re-use the "i" index because we're going to return without completing the outer loop). */ for (i = 0; i < OMPI_OP_BASE_TYPE_MAX; ++i) { OBJ_RELEASE(op->o_func.intrinsic.modules[i]); op->o_func.intrinsic.modules[i] = NULL; op->o_func.intrinsic.fns[i] = NULL; } return OMPI_ERR_NOT_FOUND; } } return OMPI_SUCCESS; } static int avail_op_compare(opal_list_item_t **itema, opal_list_item_t **itemb) { avail_op_t *availa = (avail_op_t *) *itema; avail_op_t *availb = (avail_op_t *) *itemb; if (availa->ao_priority > availb->ao_priority) { return 1; } else if (availa->ao_priority < availb->ao_priority) { return -1; } else { return 0; } } /* * For each module in the list, check and see if it wants to run, and * do the resulting priority comparison. Make a list of modules to be * only those who returned that they want to run, and put them in * priority order (lowest to highest). */ static opal_list_t *check_components(opal_list_t *components, ompi_op_t *op) { int priority; mca_base_component_list_item_t *cli; const mca_base_component_t *component; ompi_op_base_module_1_0_0_t *module; opal_list_t *selectable; avail_op_t *avail; /* Make a list of the components that query successfully */ selectable = OBJ_NEW(opal_list_t); /* Scan through the list of components. This nested loop is O(N^2), but we should never have too many components and/or names, so this *hopefully* shouldn't matter... */ OPAL_LIST_FOREACH(cli, components, mca_base_component_list_item_t) { component = cli->cli_component; priority = check_one_component(op, component, &module); if (priority >= 0) { /* We have a component that indicated that it wants to run by giving us a module */ avail = OBJ_NEW(avail_op_t); avail->ao_priority = priority; avail->ao_module = module; opal_list_append(selectable, (opal_list_item_t*)avail); } } opal_list_sort(selectable, avail_op_compare); /* All done (even if the list is empty; that's ok) */ return selectable; } /* * Check a single component */ static int check_one_component(ompi_op_t *op, const mca_base_component_t *component, ompi_op_base_module_1_0_0_t **module) { int err; int priority = -1; err = query(component, op, &priority, module); if (OMPI_SUCCESS == err) { priority = (priority < 100) ? priority : 100; opal_output_verbose(10, ompi_op_base_framework.framework_output, "op:base:op_select: component available: %s, priority: %d", component->mca_component_name, priority); } else { priority = -1; opal_output_verbose(10, ompi_op_base_framework.framework_output, "op:base:op_select: component not available: %s", component->mca_component_name); } return priority; } /************************************************************************** * Query functions **************************************************************************/ /* * Take any version of a op module, query it, and return the right * module struct */ static int query(const mca_base_component_t *component, ompi_op_t *op, int *priority, ompi_op_base_module_1_0_0_t **module) { *module = NULL; if (1 == component->mca_type_major_version && 0 == component->mca_type_minor_version && 0 == component->mca_type_release_version) { const ompi_op_base_component_1_0_0_t *op100 = (ompi_op_base_component_1_0_0_t *) component; return query_1_0_0(op100, op, priority, module); } /* Unknown op API version -- return error */ return OMPI_ERROR; } static int query_1_0_0(const ompi_op_base_component_1_0_0_t *component, ompi_op_t *op, int *priority, ompi_op_base_module_1_0_0_t **module) { ompi_op_base_module_1_0_0_t *ret; /* There's currently no need for conversion */ ret = component->opc_op_query(op, priority); if (NULL != ret) { *module = ret; return OMPI_SUCCESS; } return OMPI_ERROR; }