static int mca_pml_monitoring_component_close(void)
{
if( NULL != mca_pml_monitoring_current_filename ) {
free(mca_pml_monitoring_current_filename);
mca_pml_monitoring_current_filename = NULL;
}
if( !mca_pml_monitoring_enabled )
return OMPI_SUCCESS;
/**
* If this component is already active, then we are currently monitoring the execution
* and this close if the one from MPI_Finalize. Do the clean up and release the extra
* reference on ourselves.
*/
if( mca_pml_monitoring_active ) { /* Already active, turn off */
pml_selected_component.pmlm_version.mca_close_component();
memset(&pml_selected_component, 0, sizeof(mca_pml_base_component_t));
memset(&pml_selected_module, 0, sizeof(mca_pml_base_module_t));
mca_base_component_repository_release((mca_base_component_t*)&mca_pml_monitoring_component);
mca_pml_monitoring_active = 0;
return OMPI_SUCCESS;
}
/**
* We are supposed to monitor the execution. Save the winner PML component and
* module, and swap it with ourselves. Increase our refcount so that we are
* not dlclose.
*/
if( OPAL_SUCCESS != mca_base_component_repository_retain_component(mca_pml_monitoring_component.pmlm_version.mca_type_name,
mca_pml_monitoring_component.pmlm_version.mca_component_name) ) {
return OMPI_ERROR;
}
/* Save a copy of the selected PML */
pml_selected_component = mca_pml_base_selected_component;
pml_selected_module = mca_pml;
/* Install our interception layer */
mca_pml_base_selected_component = mca_pml_monitoring_component;
mca_pml = mca_pml_monitoring;
/* Restore some of the original valued: progress, flags, tags and context id */
mca_pml.pml_progress = pml_selected_module.pml_progress;
mca_pml.pml_max_contextid = pml_selected_module.pml_max_contextid;
mca_pml.pml_max_tag = pml_selected_module.pml_max_tag;
mca_pml.pml_flags = pml_selected_module.pml_flags;
mca_pml_monitoring_active = 1;
return OMPI_SUCCESS;
}
void mca_base_component_unload (const mca_base_component_t *component, int output_id)
{
int ret;
/* Unload */
opal_output_verbose (MCA_BASE_VERBOSE_COMPONENT, output_id,
"mca: base: close: unloading component %s",
component->mca_component_name);
ret = mca_base_var_group_find (component->mca_project_name, component->mca_type_name,
component->mca_component_name);
if (0 <= ret) {
mca_base_var_group_deregister (ret);
}
mca_base_component_repository_release (component);
}
int mca_topo_base_find_available(bool enable_progress_threads,
bool enable_mpi_threads)
{
opal_list_item_t *item, *next;
mca_base_component_list_item_t *cli;
/* The list of components which we should check is already present
in ompi_topo_base_framework.framework_components, which was established in
mca_topo_base_open */
item = opal_list_get_first(&ompi_topo_base_framework.framework_components);
while (item != opal_list_get_end(&ompi_topo_base_framework.framework_components)) {
next = opal_list_get_next(item);
cli = (mca_base_component_list_item_t*)item;
/* Now for this entry, we have to determine the thread level. Call
a subroutine to do the job for us */
if (OMPI_SUCCESS != init_query(cli->cli_component, cli,
enable_progress_threads,
enable_mpi_threads)) {
/* The component does not want to run, so close it. Its close()
has already been invoked. Close it out of the DSO repository
(if it is there in the repository) */
mca_base_component_repository_release(cli->cli_component);
opal_list_remove_item(&ompi_topo_base_framework.framework_components, item);
OBJ_RELEASE(item);
}
item = next;
}
/* There should at least be one topo component available */
if (0 == opal_list_get_size(&ompi_topo_base_framework.framework_components)) {
opal_output_verbose (10, ompi_topo_base_framework.framework_output,
"topo:find_available: no topo components available!");
return OMPI_ERROR;
}
/* All done */
return OMPI_SUCCESS;
}
int
orte_ess_base_close(void)
{
opal_list_item_t *item;
mca_base_component_list_item_t *cli;
/* unload all remaining components */
while (NULL != (item = opal_list_remove_first(&orte_ess_base_components_available))) {
orte_ess_base_component_t* component;
cli = (mca_base_component_list_item_t *) item;
component = (orte_ess_base_component_t *) cli->cli_component;
opal_output_verbose(10, 0,
"orte_ess_base_close: module %s unloaded",
component->base_version.mca_component_name);
mca_base_component_repository_release((mca_base_component_t *) component);
OBJ_RELEASE(item);
}
OBJ_DESTRUCT(&orte_ess_base_components_available);
return ORTE_SUCCESS;
}
/**
* Function for weeding out btl components that don't want to run.
*
* Call the init function on all available components to find out if
* they want to run. Select all components that don't fail. Failing
* components will be closed and unloaded. The selected modules will
* be returned to the caller in a opal_list_t.
*/
int mca_btl_base_select(bool enable_progress_threads,
bool enable_mpi_threads)
{
int i, num_btls;
opal_list_item_t *item;
mca_base_component_list_item_t *cli;
mca_btl_base_component_t *component;
mca_btl_base_module_t **modules;
mca_btl_base_selected_module_t *sm;
char** include = opal_argv_split(mca_btl_base_include, ',');
char** exclude = opal_argv_split(mca_btl_base_exclude, ',');
/* Traverse the list of opened modules; call their init
functions. */
item = opal_list_get_first(&mca_btl_base_components_opened);
while(item != opal_list_get_end(&mca_btl_base_components_opened)) {
opal_list_item_t *next = opal_list_get_next(item);
cli = (mca_base_component_list_item_t *) item;
component = (mca_btl_base_component_t *) cli->cli_component;
/* if there is an include list - item must be in the list to be included */
if ( NULL != include ) {
char** argv = include;
bool found = false;
while(argv && *argv) {
if(strcmp(component->btl_version.mca_component_name,*argv) == 0) {
found = true;
break;
}
argv++;
}
if(found == false) {
item = next;
continue;
}
/* otherwise - check the exclude list to see if this item has been specifically excluded */
} else if ( NULL != exclude ) {
char** argv = exclude;
bool found = false;
while(argv && *argv) {
if(strcmp(component->btl_version.mca_component_name,*argv) == 0) {
found = true;
break;
}
argv++;
}
if(found == true) {
item = next;
continue;
}
}
opal_output_verbose(10, mca_btl_base_output,
"select: initializing %s component %s",
component->btl_version.mca_type_name,
component->btl_version.mca_component_name);
if (NULL == component->btl_init) {
opal_output_verbose(10, mca_btl_base_output,
"select: no init function; ignoring component %s",
component->btl_version.mca_component_name);
} else {
modules = component->btl_init(&num_btls, enable_progress_threads,
enable_mpi_threads);
/* If the component didn't initialize, remove it from the opened
list and remove it from the component repository */
if (NULL == modules) {
opal_output_verbose(10, mca_btl_base_output,
"select: init of component %s returned failure",
component->btl_version.mca_component_name);
opal_output_verbose(10, mca_btl_base_output,
"select: module %s unloaded",
component->btl_version.mca_component_name);
mca_base_component_repository_release((mca_base_component_t *) component);
opal_list_remove_item(&mca_btl_base_components_opened, item);
}
/* Otherwise, it initialized properly. Save it. */
else {
opal_output_verbose(10, mca_btl_base_output,
"select: init of component %s returned success",
component->btl_version.mca_component_name);
for (i = 0; i < num_btls; ++i) {
sm = OBJ_NEW(mca_btl_base_selected_module_t);
if (NULL == sm) {
return OMPI_ERR_OUT_OF_RESOURCE;
}
sm->btl_component = component;
sm->btl_module = modules[i];
opal_list_append(&mca_btl_base_modules_initialized,
(opal_list_item_t*) sm);
}
free(modules);
}
}
item = next;
}
/* Finished querying all components. Check for the bozo case. */
if (0 == opal_list_get_size(&mca_btl_base_modules_initialized)) {
orte_show_help("help-mca-base.txt", "find-available:none-found", true,
"btl");
orte_errmgr.abort(1, NULL);
}
return OMPI_SUCCESS;
}
int
orte_rml_base_select(void)
{
opal_list_item_t *item;
int selected_priority = -1;
orte_rml_component_t *selected_component = NULL;
orte_rml_module_t *selected_module = NULL;
int wrapper_priority = -1;
orte_rml_component_t *wrapper_component = NULL;
orte_rml_module_t *wrapper_module = NULL;
char *rml_wrapper = NULL;
mca_base_param_reg_string_name("rml", "wrapper",
"Use a Wrapper component around the selected RML component",
false, false,
NULL, &rml_wrapper);
for (item = opal_list_get_first(&orte_rml_base_components);
item != opal_list_get_end(&orte_rml_base_components) ;
item = opal_list_get_next(item)) {
mca_base_component_list_item_t *cli;
orte_rml_component_t* component;
cli = (mca_base_component_list_item_t *) item;
component = (orte_rml_component_t *) cli->cli_component;
opal_output_verbose(10, orte_rml_base_output,
"orte_rml_base_select: initializing %s component %s",
component->rml_version.mca_type_name,
component->rml_version.mca_component_name);
if (NULL == component->rml_init) {
opal_output_verbose(10, orte_rml_base_output,
"orte_rml_base_select: no init function; ignoring component");
} else {
int priority = 0;
orte_rml_module_t* module = component->rml_init(&priority);
if (NULL == module) {
opal_output_verbose(10, orte_rml_base_output,
"orte_rml_base_select: init returned failure");
continue;
}
if(NULL != rml_wrapper &&
/* If this is a wrapper component then save it for later */
RML_SELECT_WRAPPER_PRIORITY >= priority) {
if( 0 == strncmp(component->rml_version.mca_component_name,
rml_wrapper,
strlen(rml_wrapper) ) ) {
wrapper_priority = priority;
wrapper_component = component;
wrapper_module = module;
}
} else if (priority > selected_priority) {
/* Otherwise this is a normal module and subject to normal selection */
if (NULL != selected_module && NULL != selected_module->finalize) {
selected_module->finalize();
}
selected_priority = priority;
selected_component = component;
selected_module = module;
}
}
}
/*
* Unload all components that were not selected
*/
item = opal_list_get_first(&orte_rml_base_components);
while (item != opal_list_get_end(&orte_rml_base_components)) {
opal_list_item_t* next = opal_list_get_next(item);
orte_rml_component_t* component;
mca_base_component_list_item_t *cli;
cli = (mca_base_component_list_item_t *) item;
component = (orte_rml_component_t *) cli->cli_component;
/* Keep it if it is the wrapper component */
if (NULL != wrapper_component &&
component == wrapper_component) {
item = next;
continue;
}
/* Not the selected component */
if (component != selected_component) {
opal_output_verbose(10, orte_rml_base_output,
"orte_rml_base_select: module %s unloaded",
component->rml_version.mca_component_name);
mca_base_component_repository_release((mca_base_component_t *) component);
opal_list_remove_item(&orte_rml_base_components, item);
OBJ_RELEASE(item);
}
item = next;
}
/* setup reference to selected module */
if (NULL != selected_module) {
orte_rml = *selected_module;
orte_rml_component = selected_component;
}
/* If a wrapper component was requested then
* Make sure it can switch out the selected module
*/
if( NULL != wrapper_component) {
wrapper_component->rml_init(NULL);
}
if( NULL != rml_wrapper ) {
free(rml_wrapper);
}
if (NULL == selected_component) return ORTE_ERROR;
return ORTE_SUCCESS;
}
/*
* Scan down the list of successfully opened components and query each of
* them (the opened list will be one or more components. If the user
* requested a specific component, it will be the only component in the
* opened list). Create and populate the available list of all
* components who indicate that they want to be considered for selection.
* Close all components who do not want to be considered for selection,
* and destroy the opened list.
*
* Also find the basic component while we're doing all of this, and save
* it in a global variable so that we can find it easily later (e.g.,
* during scope selection).
*/
int mca_coll_base_find_available(bool enable_progress_threads,
bool enable_mpi_threads)
{
bool found = false;
mca_base_component_priority_list_item_t *entry;
opal_list_item_t *p;
const mca_base_component_t *component;
/* Initialize the list */
OBJ_CONSTRUCT(&mca_coll_base_components_available, opal_list_t);
mca_coll_base_components_available_valid = true;
/* The list of components that we should check has already been
established in mca_coll_base_open. */
for (found = false,
p = opal_list_remove_first(&mca_coll_base_components_opened);
p != NULL;
p = opal_list_remove_first(&mca_coll_base_components_opened)) {
component = ((mca_base_component_list_item_t *) p)->cli_component;
/* Call a subroutine to do the work, because the component may
represent different versions of the coll MCA. */
entry = OBJ_NEW(mca_base_component_priority_list_item_t);
entry->super.cli_component = component;
entry->cpli_priority = 0;
if (OMPI_SUCCESS == init_query(component, entry,
enable_progress_threads,
enable_mpi_threads)) {
opal_list_append(&mca_coll_base_components_available,
(opal_list_item_t *) entry);
found = true;
} else {
/* If the component doesn't want to run, then close it. It's
already had its close() method invoked; now close it out of
the DSO repository (if it's there). */
mca_base_component_repository_release(component);
OBJ_RELEASE(entry);
}
/* Free the entry from the "opened" list */
OBJ_RELEASE(p);
}
/* The opened list is now no longer useful and we can free it */
OBJ_DESTRUCT(&mca_coll_base_components_opened);
mca_coll_base_components_opened_valid = false;
/* If we have no collective components available, it's an error.
Thanks for playing! */
if (!found) {
/* Need to free all items in the list */
OBJ_DESTRUCT(&mca_coll_base_components_available);
mca_coll_base_components_available_valid = false;
opal_output_verbose(10, mca_coll_base_output,
"coll:find_available: no coll components available!");
orte_show_help("help-mca-base", "find-available:none-found", true,
"coll");
return OMPI_ERROR;
}
/* All done */
return OMPI_SUCCESS;
}
/**
* Function for finding and opening either all MCA components, or the
* one that was specifically requested via a MCA parameter.
*/
int mca_base_components_open(const char *type_name, int output_id,
const mca_base_component_t **static_components,
opal_list_t *components_available,
bool open_dso_components)
{
int ret, param;
opal_list_item_t *item;
opal_list_t components_found;
char **requested_component_names;
int param_verbose = -1;
int param_type = -1;
int verbose_level;
char *str;
bool include_mode;
#if (OPAL_ENABLE_FT == 1) && (OPAL_ENABLE_FT_CR == 1)
opal_list_item_t *next;
uint32_t open_only_flags = MCA_BASE_METADATA_PARAM_NONE;
const mca_base_component_t *component;
#endif
/* Register MCA parameters */
/* Check to see if it exists first */
if( 0 > (param_type = mca_base_param_find(type_name, NULL, NULL) ) ) {
asprintf(&str, "Default selection set of components for the %s framework (<none>"
" means use all components that can be found)", type_name);
param_type =
mca_base_param_reg_string_name(type_name, NULL, str,
false, false, NULL, NULL);
free(str);
}
param = mca_base_param_find("mca", NULL, "component_show_load_errors");
mca_base_param_lookup_int(param, &ret);
show_errors = OPAL_INT_TO_BOOL(ret);
/* Setup verbosity for this MCA type */
asprintf(&str, "Verbosity level for the %s framework (0 = no verbosity)", type_name);
param_verbose =
mca_base_param_reg_int_name(type_name, "base_verbose",
str, false, false, 0, NULL);
free(str);
mca_base_param_lookup_int(param_verbose, &verbose_level);
if (output_id != 0) {
opal_output_set_verbosity(output_id, verbose_level);
}
opal_output_verbose(10, output_id,
"mca: base: components_open: Looking for %s components",
type_name);
ret = parse_requested(param_type, &include_mode, &requested_component_names);
if( OPAL_SUCCESS != ret ) {
return ret;
}
/* Find and load requested components */
if (OPAL_SUCCESS != (ret =
mca_base_component_find(NULL, type_name, static_components,
requested_component_names, include_mode,
&components_found, open_dso_components)) ) {
return ret;
}
#if (OPAL_ENABLE_FT == 1) && (OPAL_ENABLE_FT_CR == 1)
{
int param_id = -1;
int param_val = 0;
/*
* Extract supported mca parameters for selection contraints
* Supported Options:
* - mca_base_component_distill_checkpoint_ready = Checkpoint Ready
*/
param_id = mca_base_param_reg_int_name("mca", "base_component_distill_checkpoint_ready",
"Distill only those components that are Checkpoint Ready",
false, false,
0, ¶m_val);
if( 0 != param_val ) { /* Select Checkpoint Ready */
open_only_flags |= MCA_BASE_METADATA_PARAM_CHECKPOINT;
}
}
#endif /* (OPAL_ENABLE_FT == 1) && (OPAL_ENABLE_FT_CR == 1) */
/*
* Pre-process the list with parameter constraints
* e.g., If requested to select only CR enabled components
* then only make available those components.
*
* JJH Note: Currently checkpoint/restart is the only user of this
* functionality. If other component constraint options are
* added, then this logic can be used for all contraint
* options.
*/
#if (OPAL_ENABLE_FT == 1) && (OPAL_ENABLE_FT_CR == 1)
if( !(MCA_BASE_METADATA_PARAM_NONE & open_only_flags) ) {
if( MCA_BASE_METADATA_PARAM_CHECKPOINT & open_only_flags) {
opal_output_verbose(10, output_id,
"mca: base: components_open: "
"including only %s components that are checkpoint enabled", type_name);
}
/*
* Check all the components to make sure they adhere to the user
* expressed requirements.
*/
for(item = opal_list_get_first(&components_found);
item != opal_list_get_end(&components_found);
item = next ) {
mca_base_open_only_dummy_component_t *dummy;
mca_base_component_list_item_t *cli = (mca_base_component_list_item_t *) item;
dummy = (mca_base_open_only_dummy_component_t*) cli->cli_component;
component = cli->cli_component;
next = opal_list_get_next(item);
/*
* If the user asked for a checkpoint enabled run
* then only load checkpoint enabled components.
*/
if( MCA_BASE_METADATA_PARAM_CHECKPOINT & open_only_flags) {
if( MCA_BASE_METADATA_PARAM_CHECKPOINT & dummy->data.param_field) {
opal_output_verbose(10, output_id,
"mca: base: components_open: "
"(%s) Component %s is Checkpointable",
type_name,
dummy->version.mca_component_name);
}
else {
opal_output_verbose(10, output_id,
"mca: base: components_open: "
"(%s) Component %s is *NOT* Checkpointable - Disabled",
type_name,
dummy->version.mca_component_name);
opal_list_remove_item(&components_found, item);
/* Make sure to release the component since we are not
* opening it */
mca_base_component_repository_release(component);
}
}
}
}
#endif /* (OPAL_ENABLE_FT == 1) && (OPAL_ENABLE_FT_CR == 1) */
/* Open all remaining components */
ret = open_components(type_name, output_id,
&components_found, components_available);
/* Free resources */
for (item = opal_list_remove_first(&components_found); NULL != item;
item = opal_list_remove_first(&components_found)) {
OBJ_RELEASE(item);
}
OBJ_DESTRUCT(&components_found);
if (NULL != requested_component_names) {
opal_argv_free(requested_component_names);
}
/* All done */
return ret;
}
/*
* Traverse the entire list of found components (a list of
* mca_base_component_t instances). If the requested_component_names
* array is empty, or the name of each component in the list of found
* components is in the requested_components_array, try to open it.
* If it opens, add it to the components_available list.
*/
static int open_components(const char *type_name, int output_id,
opal_list_t *src, opal_list_t *dest)
{
int ret;
opal_list_item_t *item;
const mca_base_component_t *component;
mca_base_component_list_item_t *cli;
bool called_open;
bool opened, registered;
/* Announce */
opal_output_verbose(10, output_id,
"mca: base: components_open: opening %s components",
type_name);
/* Traverse the list of found components */
OBJ_CONSTRUCT(dest, opal_list_t);
for (item = opal_list_get_first(src);
opal_list_get_end(src) != item;
item = opal_list_get_next(item)) {
cli = (mca_base_component_list_item_t *) item;
component = cli->cli_component;
registered = opened = called_open = false;
opal_output_verbose(10, output_id,
"mca: base: components_open: found loaded component %s",
component->mca_component_name);
/* Call the component's MCA parameter registration function */
if (NULL == component->mca_register_component_params) {
registered = true;
opal_output_verbose(10, output_id,
"mca: base: components_open: "
"component %s has no register function",
component->mca_component_name);
} else {
ret = component->mca_register_component_params();
if (MCA_SUCCESS == ret) {
registered = true;
opal_output_verbose(10, output_id,
"mca: base: components_open: "
"component %s register function successful",
component->mca_component_name);
} else if (OPAL_ERR_NOT_AVAILABLE != ret) {
/* If the component returns OPAL_ERR_NOT_AVAILABLE,
it's a cue to "silently ignore me" -- it's not a
failure, it's just a way for the component to say
"nope!".
Otherwise, however, display an error. We may end
up displaying this twice, but it may go to separate
streams. So better to be redundant than to not
display the error in the stream where it was
expected. */
if (show_errors) {
opal_output(0, "mca: base: components_open: "
"component %s / %s register function failed",
component->mca_type_name,
component->mca_component_name);
}
opal_output_verbose(10, output_id,
"mca: base: components_open: "
"component %s register function failed",
component->mca_component_name);
}
}
if (NULL == component->mca_open_component) {
opened = true;
opal_output_verbose(10, output_id,
"mca: base: components_open: "
"component %s has no open function",
component->mca_component_name);
} else {
called_open = true;
ret = component->mca_open_component();
if (MCA_SUCCESS == ret) {
opened = true;
opal_output_verbose(10, output_id,
"mca: base: components_open: "
"component %s open function successful",
component->mca_component_name);
} else if (OPAL_ERR_NOT_AVAILABLE != ret) {
/* If the component returns OPAL_ERR_NOT_AVAILABLE,
it's a cue to "silently ignore me" -- it's not a
failure, it's just a way for the component to say
"nope!".
Otherwise, however, display an error. We may end
up displaying this twice, but it may go to separate
streams. So better to be redundant than to not
display the error in the stream where it was
expected. */
if (show_errors) {
opal_output(0, "mca: base: components_open: "
"component %s / %s open function failed",
component->mca_type_name,
component->mca_component_name);
}
opal_output_verbose(10, output_id,
"mca: base: components_open: "
"component %s open function failed",
component->mca_component_name);
}
}
/* If it didn't open, close it out and get rid of it */
if (!opened) {
char *name;
if (called_open) {
if (NULL != component->mca_close_component) {
component->mca_close_component();
}
opal_output_verbose(10, output_id,
"mca: base: components_open: component %s closed",
component->mca_component_name);
called_open = false;
}
name = strdup(component->mca_component_name);
mca_base_component_repository_release(component);
opal_output_verbose(10, output_id,
"mca: base: components_open: component %s unloaded",
name);
free(name);
}
/* If it did open, register its "priority" MCA parameter (if
it doesn't already have one) and save it in the
opened_components list */
else {
if (OPAL_ERROR == mca_base_param_find(type_name,
component->mca_component_name,
"priority")) {
mca_base_param_register_int(type_name,
component->mca_component_name,
"priority", NULL, 0);
}
cli = OBJ_NEW(mca_base_component_list_item_t);
if (NULL == cli) {
return OPAL_ERR_OUT_OF_RESOURCE;
}
cli->cli_component = component;
opal_list_append(dest, (opal_list_item_t *) cli);
}
}
/* All done */
return OPAL_SUCCESS;
}
/**
* Call the init function on all available components to find out if
* they want to run. Select the single component with the highest
* priority.
*/
int orte_rml_base_select(void)
{
opal_list_item_t *item;
mca_base_component_list_item_t *cli;
int selected_priority = -1;
orte_rml_component_t *selected_component = NULL;
orte_rml_module_t *selected_module = NULL;
/* Traverse the list of opened modules; call their init functions. */
for(item = opal_list_get_first(&orte_rml_base.rml_components);
item != opal_list_get_end(&orte_rml_base.rml_components);
item = opal_list_get_next(item)) {
orte_rml_component_t* component;
cli = (mca_base_component_list_item_t *) item;
component = (orte_rml_component_t *) cli->cli_component;
opal_output_verbose(10, orte_rml_base.rml_output,
"orte_rml_base_select: initializing %s component %s",
component->rml_version.mca_type_name,
component->rml_version.mca_component_name);
if (NULL == component->rml_init) {
opal_output_verbose(10, orte_rml_base.rml_output,
"orte_rml_base_select: no init function; ignoring component");
} else {
int priority;
orte_rml_module_t* module = component->rml_init(&priority);
/* If the component didn't initialize, remove it from the opened
list and remove it from the component repository */
if (NULL == module) {
opal_output_verbose(10, orte_rml_base.rml_output,
"orte_rml_base_select: init returned failure");
continue;
}
if(priority > selected_priority) {
selected_priority = priority;
selected_component = component;
selected_module = module;
}
}
}
/* unload all components that were not selected */
item = opal_list_get_first(&orte_rml_base.rml_components);
while(item != opal_list_get_end(&orte_rml_base.rml_components)) {
opal_list_item_t* next = opal_list_get_next(item);
orte_rml_component_t* component;
cli = (mca_base_component_list_item_t *) item;
component = (orte_rml_component_t *) cli->cli_component;
if(component != selected_component) {
opal_output_verbose(10, orte_rml_base.rml_output,
"orte_rml_base_select: module %s unloaded",
component->rml_version.mca_component_name);
mca_base_component_repository_release((mca_base_component_t *) component);
opal_list_remove_item(&orte_rml_base.rml_components, item);
OBJ_RELEASE(item);
}
item = next;
}
/* setup reference to selected module */
if(NULL != selected_module) {
orte_rml = *selected_module;
}
return (NULL != selected_module) ? ORTE_SUCCESS : ORTE_ERR_NOT_FOUND;
}
/*
* Scan down the list of successfully opened components and query each of
* them (the opened list will be one or more components. If the user
* requested a specific component, it will be the only component in the
* opened list). Create and populate the available list of all
* components who indicate that they want to be considered for selection.
* Close all components who do not want to be considered for selection,
* and destroy the opened list.
*
* It is *not* an error if there are no io components available.
* Appropriate run-time MPI exceptions will be invoked during
* MPI_FILE_OPEN and MPI_FILE_DELETE.
*/
int mca_io_base_find_available(bool enable_progress_threads,
bool enable_mpi_threads)
{
int err;
mca_base_component_priority_list_item_t *entry;
opal_list_item_t *p;
const mca_base_component_t *component;
/* Initialize the list */
OBJ_CONSTRUCT(&mca_io_base_components_available, opal_list_t);
mca_io_base_components_available_valid = true;
/* The list of components that we should check has already been
established in mca_io_base_open. */
for (p = opal_list_remove_first(&mca_io_base_components_opened);
p != NULL;
p = opal_list_remove_first(&mca_io_base_components_opened)) {
component = ((mca_base_component_list_item_t *) p)->cli_component;
/* Call a subroutine to do the work, because the component may
represent different versions of the io MCA. */
entry = OBJ_NEW(mca_base_component_priority_list_item_t);
entry->super.cli_component = component;
entry->cpli_priority = 0;
if (OMPI_SUCCESS == init_query(component, entry,
enable_progress_threads,
enable_mpi_threads)) {
/* Save the results in the list. The priority isn't
relevant, because selection is decided at
communicator-constructor time. But we save the thread
arguments (set in the init_query() function) so that
the initial selection algorithm can negotiate the
overall thread level for this process. */
opal_list_append(&mca_io_base_components_available,
(opal_list_item_t *) entry);
} else {
/* If the component doesn't want to run, then close it.
It's already had its close() method invoked; now close
it out of the DSO repository (if it's there). */
mca_base_component_repository_release(component);
OBJ_RELEASE(entry);
}
/* Free the entry from the "opened" list */
OBJ_RELEASE(p);
}
/* The opened list is now no longer useful and we can free it */
OBJ_DESTRUCT(&mca_io_base_components_opened);
mca_io_base_components_opened_valid = false;
/* Setup the freelist */
if (OMPI_SUCCESS != (err = mca_io_base_request_create_freelist())) {
return err;
}
/* All done */
return OMPI_SUCCESS;
}
int mca_topo_base_find_available(bool enable_progress_threads,
bool enable_mpi_threads)
{
bool found = false;
mca_base_component_priority_list_item_t *entry;
opal_list_item_t *p;
/* Initialize the list */
OBJ_CONSTRUCT(&mca_topo_base_components_available, opal_list_t);
mca_topo_base_components_available_valid = true;
/* The list of components which we should check is already present
in mca_topo_base_components_opened, which was established in
mca_topo_base_open */
for (found = false,
p = opal_list_remove_first (&mca_topo_base_components_opened);
NULL != p;
p = opal_list_remove_first (&mca_topo_base_components_opened)) {
entry = OBJ_NEW(mca_base_component_priority_list_item_t);
entry->super.cli_component =
((mca_base_component_list_item_t *)p)->cli_component;
/* Now for this entry, we have to determine the thread level. Call
a subroutine to do the job for us */
if (OMPI_SUCCESS == init_query(entry->super.cli_component, entry,
enable_progress_threads,
enable_mpi_threads)) {
/* Save the results in the list. The priority is not relvant at
this point in time. But we save the thread arguments so that
the initial selection algorithm can negotiate overall thread
level for this process */
entry->cpli_priority = 0;
opal_list_append (&mca_topo_base_components_available,
(opal_list_item_t *) entry);
found = true;
} else {
/* The component does not want to run, so close it. Its close()
has already been invoked. Close it out of the DSO repository
(if it is there in the repository) */
mca_base_component_repository_release(entry->super.cli_component);
OBJ_RELEASE(entry);
}
/* Free entry from the "opened" list */
OBJ_RELEASE(p);
}
/* The opened list is no longer necessary, so we can free it */
OBJ_DESTRUCT (&mca_topo_base_components_opened);
mca_topo_base_components_opened_valid = false;
/* There should atleast be one topo component which was available */
if (false == found) {
/* Need to free all items in the list */
OBJ_DESTRUCT(&mca_topo_base_components_available);
mca_topo_base_components_available_valid = false;
opal_output_verbose (10, mca_topo_base_output,
"topo:find_available: no topo components available!");
return OMPI_ERROR;
}
/* All done */
return OMPI_SUCCESS;
}
