int main(int argc, char **argv) { /* local variables */ opal_list_t list, x; size_t indx,i,list_size, tmp_size_1, tmp_size_2,size_elements; int error_cnt; test_data_t *elements, *ele; opal_list_item_t *item; opal_init(); test_init("opal_list_t"); /* initialize list */ OBJ_CONSTRUCT(&list, opal_list_t); OBJ_CONSTRUCT(&x, opal_list_t); /* check length of list */ list_size=opal_list_get_size(&list); if( 0 == list_size ) { test_success(); } else { test_failure(" opal_list_get_size"); } /* check for empty */ if (opal_list_is_empty(&list)) { test_success(); } else { test_failure(" opal_list_is_empty(empty list)"); } /* create test elements */ size_elements=4; elements=(test_data_t *)malloc(sizeof(test_data_t)*size_elements); assert(elements); for(i=0 ; i < size_elements ; i++) { OBJ_CONSTRUCT(elements + i, test_data_t); (elements+i)->data=i; } /* populate list */ for(i=0 ; i < size_elements ; i++) { opal_list_append(&list,(opal_list_item_t *)(elements+i)); } list_size=opal_list_get_size(&list); if( list_size == size_elements ) { test_success(); } else { test_failure(" populating list"); } /* checking for empty on non-empty list */ if (!opal_list_is_empty(&list)) { test_success(); } else { test_failure(" opal_list_is_empty(non-empty list)"); } /* check that list is ordered as expected */ i=0; error_cnt=0; for(ele = (test_data_t *) opal_list_get_first(&list); ele != (test_data_t *) opal_list_get_end(&list); ele = (test_data_t *) ((opal_list_item_t *)ele)->opal_list_next) { if( ele->data != i ) error_cnt++; i++; } if( 0 == error_cnt ) { test_success(); } else { test_failure(" error in list order "); } /* check opal_list_get_first */ ele = (test_data_t *)NULL; ele = (test_data_t *) opal_list_get_first(&list); assert(ele); if( 0 == ele->data ) { test_success(); } else { test_failure(" error in opal_list_get_first"); } i=0; for(ele = (test_data_t *) opal_list_get_first(&list); ele != (test_data_t *) opal_list_get_end(&list); ele = (test_data_t *) ((opal_list_item_t *)ele)->opal_list_next) { i++; } if( size_elements == i ) { test_success(); } else { test_failure(" error in opal_list_get_first - list size changed "); } /* check opal_list_get_last */ ele = (test_data_t *)NULL; ele = (test_data_t *) opal_list_get_last(&list); assert(ele); if( (size_elements-1) == ele->data ) { test_success(); } else { test_failure(" error in opal_list_get_last"); } i=0; for(ele = (test_data_t *) opal_list_get_first(&list); ele != (test_data_t *) opal_list_get_end(&list); ele = (test_data_t *) ((opal_list_item_t *)ele)->opal_list_next) { i++; } if( size_elements == i ) { test_success(); } else { test_failure(" error in opal_list_get_first - list size changed "); } /* check opal_list_remove_first */ ele = (test_data_t *)NULL; ele = (test_data_t *) opal_list_remove_first(&list); assert(ele); if( 0 == ele->data ) { test_success(); } else { test_failure(" error in opal_list_remove_first"); } i=0; for(ele = (test_data_t *) opal_list_get_first(&list); ele != (test_data_t *) opal_list_get_end(&list); ele = (test_data_t *) ((opal_list_item_t *)ele)->opal_list_next) { i++; } if( (size_elements-1) == i ) { test_success(); } else { test_failure(" error in opal_list_remove_first - list size changed "); } /* test opal_list_prepend */ opal_list_prepend(&list,(opal_list_item_t *)elements); ele = (test_data_t *)NULL; ele = (test_data_t *) opal_list_get_first(&list); assert(ele); if( 0 == ele->data ) { test_success(); } else { test_failure(" error in opal_list_prepend"); } i=0; for(ele = (test_data_t *) opal_list_get_first(&list); ele != (test_data_t *) opal_list_get_end(&list); ele = (test_data_t *) ((opal_list_item_t *)ele)->opal_list_next) { i++; } if( size_elements == i ) { test_success(); } else { test_failure(" error in opal_list_prepend - list size changed "); } /* check opal_list_remove_last */ ele = (test_data_t *)NULL; ele = (test_data_t *) opal_list_remove_last(&list); assert(ele); if( (size_elements-1) == ele->data ) { test_success(); } else { test_failure(" error in opal_list_remove_last"); } i=0; for(ele = (test_data_t *) opal_list_get_first(&list); ele != (test_data_t *) opal_list_get_end(&list); ele = (test_data_t *) ((opal_list_item_t *)ele)->opal_list_next) { i++; } if( (size_elements-1) == i ) { test_success(); } else { test_failure(" error in opal_list_remove_last - list size changed "); } /* test opal_list_append */ opal_list_append(&list,(opal_list_item_t *)(elements+size_elements-1)); ele = (test_data_t *)NULL; ele = (test_data_t *) opal_list_get_last(&list); assert(ele); if( (size_elements-1) == ele->data ) { test_success(); } else { test_failure(" error in opal_list_append"); } i=0; for(ele = (test_data_t *) opal_list_get_first(&list); ele != (test_data_t *) opal_list_get_end(&list); ele = (test_data_t *) ((opal_list_item_t *)ele)->opal_list_next) { i++; } if( size_elements == i ) { test_success(); } else { test_failure(" error in opal_list_append - list size changed "); } /* remove element from list */ indx=size_elements/2; if( 0 == indx ) indx=1; assert(2 <= size_elements); ele = (test_data_t *)NULL; ele = (test_data_t *) opal_list_remove_item(&list,(opal_list_item_t *)(elements+indx)); assert(ele); if( (indx-1) == ele->data ) { test_success(); } else { test_failure(" error in opal_list_remove - previous"); } ele=(test_data_t *)(((opal_list_item_t *)ele)->opal_list_next); if( (indx+1) == ele->data ) { test_success(); } else { test_failure(" error in opal_list_remove - next"); } i=0; for(ele = (test_data_t *) opal_list_get_first(&list); ele != (test_data_t *) opal_list_get_end(&list); ele = (test_data_t *) ((opal_list_item_t *)ele)->opal_list_next) { i++; } if( (size_elements-1) == i ) { test_success(); } else { test_failure(" error in opal_list_remove - list size changed incorrectly"); } /* test the insert function */ i=opal_list_insert(&list,(opal_list_item_t *)(elements+indx),indx); if( 1 == i ) { test_success(); } else { test_failure(" error in opal_list_remove_item \n"); } i=0; for(ele = (test_data_t *) opal_list_get_first(&list); ele != (test_data_t *) opal_list_get_end(&list); ele = (test_data_t *) ((opal_list_item_t *)ele)->opal_list_next) { i++; } if( size_elements == i ) { test_success(); } else { test_failure(" error in opal_list_insert - incorrect list length"); } i=0; error_cnt=0; for(ele = (test_data_t *) opal_list_get_first(&list); ele != (test_data_t *) opal_list_get_end(&list); ele = (test_data_t *) ((opal_list_item_t *)ele)->opal_list_next) { if( ele->data != i ) error_cnt++; i++; } if( 0 == error_cnt ) { test_success(); } else { test_failure(" error in list order - opal_list_remove_item "); } /* test the splice and join functions */ list_size = opal_list_get_size(&list); for (i = 0, item = opal_list_get_first(&list) ; i < list_size / 2 ; ++i, item = opal_list_get_next(item)) { } opal_list_splice(&x, opal_list_get_end(&x), &list, item, opal_list_get_end(&list)); tmp_size_1 = opal_list_get_size(&list); tmp_size_2 = opal_list_get_size(&x); if (tmp_size_1 != i) { test_failure(" error in splice (size of list)"); } else if (tmp_size_2 != list_size - tmp_size_1) { test_failure(" error in splice (size of x)"); } else { test_success(); } opal_list_join(&list, opal_list_get_end(&list), &x); tmp_size_1 = opal_list_get_size(&list); tmp_size_2 = opal_list_get_size(&x); if (tmp_size_1 != list_size) { test_failure(" error in join (size of list)"); } else if (tmp_size_2 != 0) { test_failure(" error in join (size of x)"); } else { test_success(); } if (NULL != elements) free(elements); opal_finalize(); return test_finalize(); }
int mca_io_base_delete(char *filename, struct ompi_info_t *info) { int err, num_names; char *names, **name_array; opal_list_t *selectable; opal_list_item_t *item; avail_io_t *avail, selected; /* Announce */ opal_output_verbose(10, mca_io_base_output, "io:base:delete: deleting file: %s", filename); /* See if a set of component was requested by the MCA parameter. Don't check for error. */ names = NULL; mca_base_param_lookup_string(mca_io_base_param, &names); /* Compute the intersection of all of my available components with the components from all the other processes in this file */ /* JMS CONTINUE HERE */ /* See if there were any listed in the MCA parameter; parse them and check them all */ err = OMPI_ERROR; if (NULL != names && 0 < strlen(names)) { name_array = opal_argv_split(names, ','); num_names = opal_argv_count(name_array); opal_output_verbose(10, mca_io_base_output, "io:base:delete: Checking specific modules: %s", names); selectable = check_components(&mca_io_base_components_available, filename, info, name_array, num_names); opal_argv_free(name_array); } /* Nope -- a specific [set of] component[s] was not requested. Go check them all. */ else { opal_output_verbose(10, mca_io_base_output, "io:base:delete: Checking all available modules"); selectable = check_components(&mca_io_base_components_available, filename, info, NULL, 0); } /* Upon return from the above, the modules list will contain the list of modules that returned (priority >= 0). If we have no io modules available, it's an error */ if (NULL == selectable) { /* There's no modules available. Doh! */ /* show_help */ return OMPI_ERROR; } /* Do some kind of collective operation to find a module that everyone has available */ #if 1 /* For the moment, just take the top module off the list */ /* MSC actually take the buttom */ item = opal_list_remove_last(selectable); avail = (avail_io_t *) item; selected = *avail; OBJ_RELEASE(avail); #else /* JMS CONTINUE HERE */ #endif /* Everything left in the selectable list is therefore unwanted, and we call their unquery() method (because they all had query() invoked, but will never have init() invoked in this scope). */ for (item = opal_list_remove_first(selectable); item != NULL; item = opal_list_remove_first(selectable)) { avail = (avail_io_t *) item; unquery(avail, filename, info); OBJ_RELEASE(item); } OBJ_RELEASE(selectable); /* Finally -- delete the file with the selected component */ if (OMPI_SUCCESS != (err = delete_file(&selected, filename, info))) { return err; } /* Announce the winner */ opal_output_verbose(10, mca_io_base_output, "io:base:delete: Selected io component %s", selected.ai_component.v2_0_0.io_version.mca_component_name); return OMPI_SUCCESS; }
/* * Receive prepost: * return values: * 0 - no prepost was done * -1 - fatal error during prepost * other value - number preposted elements */ static int mca_bcol_iboffload_frag_reg_qp_prepost( mca_bcol_iboffload_endpoint_t *endpoint, int qp_index, int num_to_prepost) { ompi_free_list_item_t *item; mca_bcol_iboffload_frag_t *frag; struct ibv_recv_wr *recv_wr, *recv_bad; int i, ret, num_preposted = 0, start_wr_index; mca_bcol_iboffload_component_t *cm = &mca_bcol_iboffload_component; mca_bcol_iboffload_device_t *device = endpoint->iboffload_module->device; opal_list_t *preposted = &(endpoint->qps[qp_index].preposted_frags); mca_bcol_iboffload_recv_wr_manager *recv_wrs = &cm->recv_wrs; IBOFFLOAD_VERBOSE(10, ("Recv prepost call: endpoint %p, to prepost %d", (void *) endpoint, num_to_prepost)); if (OPAL_UNLIKELY(0 == num_to_prepost)) { IBOFFLOAD_VERBOSE(10, ("num_to_prepost = 0, return immediate")); return OMPI_SUCCESS; } /* make sure that we do not overrun number of rd_wqe */ if (num_to_prepost > endpoint->qps[qp_index].rd_wqe) { IBOFFLOAD_VERBOSE(10, ("Reset num_to_prepost = %d, to rd_wqe = %d", num_to_prepost, endpoint->qps[qp_index].rd_wqe)); num_to_prepost = endpoint->qps[qp_index].rd_wqe; } OPAL_THREAD_LOCK(&recv_wrs->lock); /* calculate start index in array * of pre-allocated work requests */ start_wr_index = cm->qp_infos[qp_index].rd_num - num_to_prepost; recv_wr = &recv_wrs->recv_work_requests[qp_index][start_wr_index]; IBOFFLOAD_VERBOSE(10, ("Endpoint %p, qp_index - %d, to_porepost %d, " "start index of WRs - %d, rd_wqe - %d", (void *) endpoint, qp_index, num_to_prepost, start_wr_index, endpoint->qps[qp_index].rd_wqe)); while (num_preposted < num_to_prepost) { /* put the item on list of preposted */ OMPI_FREE_LIST_GET_MT(&device->frags_free[qp_index], item); if (OPAL_UNLIKELY(NULL == item)) { break; } frag = (mca_bcol_iboffload_frag_t *) item; opal_list_append(preposted, (opal_list_item_t *) item); recv_wr[num_preposted].sg_list = &frag->sg_entry; /* TODO Pasha - fix it later */ /* Vasily: Is it right place to take a size value ???? */ frag->sg_entry.length = cm->qp_infos[qp_index].size; ++num_preposted; } if (OPAL_LIKELY(num_preposted > 0)) { /* Set the tail */ recv_wr[num_preposted - 1].next = NULL; /* post the list of recvs */ ret = ibv_post_recv(endpoint->qps[qp_index].qp->lcl_qp, recv_wr, &recv_bad); if (OPAL_UNLIKELY(0 != ret)) { IBOFFLOAD_ERROR(("ibv_post_recv failed (%s), error: %s [%d], " "qp_index - %d.\n", ibv_get_device_name(device->dev.ib_dev), strerror(errno), ret, qp_index)); /* Return allocated frags */ for (i = 0; i < num_preposted; i++) { OMPI_FREE_LIST_RETURN_MT(&device->frags_free[qp_index], (ompi_free_list_item_t *) opal_list_remove_last(preposted)); } return OMPI_ERROR; } /* recover last recv_wr if needed */ if (OPAL_UNLIKELY(num_to_prepost != num_preposted)) { recv_wr[num_preposted - 1].next = &recv_wr[num_preposted]; } /* decresing numbers of free recv wqe */ endpoint->qps[qp_index].rd_wqe -= num_preposted; } OPAL_THREAD_UNLOCK(&recv_wrs->lock); IBOFFLOAD_VERBOSE(10, ("Endpoint %p, to_porepost %d, num preposted - %d", (void *) endpoint, num_to_prepost, num_preposted)); return OMPI_SUCCESS; }
/* * This function is called at the initialization time of every * file. It is used to select which io component will be * active for a given file. */ int mca_io_base_file_select(ompi_file_t *file, mca_base_component_t *preferred) { int err; char *str; opal_list_t *selectable; opal_list_item_t *item; avail_io_t *avail, selected; /* Announce */ opal_output_verbose(10, ompi_io_base_framework.framework_output, "io:base:file_select: new file: %s", file->f_filename); /* Initialize all the relevant pointers, since they're used as sentinel values */ file->f_io_version = MCA_IO_BASE_V_NONE; file->f_io_selected_data = NULL; /* Compute the intersection of all of my available components with the components from all the other processes in this file */ /* JMS CONTINUE HERE */ /* See if a preferred component was provided. If so, try to select it. If we don't succeed, fall through and do a normal selection. */ err = OMPI_ERROR; if (NULL != preferred) { str = &(preferred->mca_component_name[0]); opal_output_verbose(10, ompi_io_base_framework.framework_output, "io:base:file_select: Checking preferred module: %s", str); selectable = check_components(&ompi_io_base_framework.framework_components, file, &str, 1); /* If we didn't get a preferred module, then call again without a preferred module. This makes the logic below dramatically simpler. */ if (NULL == selectable) { return mca_io_base_file_select(file, NULL); } /* We only fall through here if we were able to select one of the preferred modules */ } /* Nope -- a specific [set of] component[s] was not requested. Go check them all. */ else { opal_output_verbose(10, ompi_io_base_framework.framework_output, "io:base:file_select: Checking all available modules"); selectable = check_components(&ompi_io_base_framework.framework_components, file, NULL, 0); } /* Upon return from the above, the modules list will contain the list of modules that returned (priority >= 0). If we have no io modules available, it's an error */ if (NULL == selectable) { /* There's no modules available. Doh! */ /* show_help */ return OMPI_ERROR; } /* Do some kind of collective operation to find a module that everyone has available */ #if 1 /* For the moment, just take the top module off the list */ /* MSC actually take the buttom */ item = opal_list_remove_last(selectable); avail = (avail_io_t *) item; selected = *avail; OBJ_RELEASE(avail); #else /* JMS CONTINUE HERE */ #endif /* Everything left in the selectable list is therefore unwanted, and we call their unquery() method (because they all had query() invoked, but will never have init() invoked in this scope). */ for (item = opal_list_remove_first(selectable); item != NULL; item = opal_list_remove_first(selectable)) { avail = (avail_io_t *) item; unquery(avail, file); OBJ_RELEASE(item); } OBJ_RELEASE(selectable); /* Save the pointers of the selected module on the ompi_file_t */ file->f_io_version = selected.ai_version; file->f_io_selected_component = selected.ai_component; file->f_io_selected_module = selected.ai_module; file->f_io_selected_data = selected.ai_module_data; if (!strcmp (selected.ai_component.v2_0_0.io_version.mca_component_name, "ompio")) { int ret; opal_mutex_lock(&ompi_mpi_ompio_bootstrap_mutex); if (OMPI_SUCCESS != (ret = mca_base_framework_open(&ompi_fs_base_framework, 0))) { opal_mutex_unlock(&ompi_mpi_ompio_bootstrap_mutex); return err; } if (OMPI_SUCCESS != (ret = mca_base_framework_open(&ompi_fcoll_base_framework, 0))) { opal_mutex_unlock(&ompi_mpi_ompio_bootstrap_mutex); return err; } if (OMPI_SUCCESS != (ret = mca_base_framework_open(&ompi_fbtl_base_framework, 0))) { opal_mutex_unlock(&ompi_mpi_ompio_bootstrap_mutex); return err; } if (OMPI_SUCCESS != (ret = mca_base_framework_open(&ompi_sharedfp_base_framework, 0))) { opal_mutex_unlock(&ompi_mpi_ompio_bootstrap_mutex); return err; } opal_mutex_unlock(&ompi_mpi_ompio_bootstrap_mutex); if (OMPI_SUCCESS != (ret = mca_fs_base_find_available(OPAL_ENABLE_PROGRESS_THREADS, 1))) { return err; } if (OMPI_SUCCESS != (ret = mca_fcoll_base_find_available(OPAL_ENABLE_PROGRESS_THREADS, 1))) { return err; } if (OMPI_SUCCESS != (ret = mca_fbtl_base_find_available(OPAL_ENABLE_PROGRESS_THREADS, 1))) { return err; } if (OMPI_SUCCESS != (ret = mca_sharedfp_base_find_available(OPAL_ENABLE_PROGRESS_THREADS, 1))) { return err; } } /* Finally -- intialize the selected module. */ if (OMPI_SUCCESS != (err = module_init(file))) { return err; } /* Announce the winner */ opal_output_verbose(10, ompi_io_base_framework.framework_output, "io:base:file_select: Selected io module %s", selected.ai_component.v2_0_0.io_version.mca_component_name); return OMPI_SUCCESS; }
/* * this function initializes the internal scratch buffers and control * structures that will be used by the module. It also intitializes * the payload buffer management structures. */ int base_bcol_basesmuma_setup_library_buffers( mca_bcol_basesmuma_module_t *sm_bcol_module, mca_bcol_basesmuma_component_t *cs) { int ret=OMPI_SUCCESS,i; int n_ctl_structs; size_t ctl_segement_size,total_memory; int max_elements; unsigned char *data_ptr; /* */ /* setup the control struct memory */ if(!cs->sm_ctl_structs) { ret = mca_bcol_basesmuma_allocate_sm_ctl_memory(cs); if(OMPI_SUCCESS != ret) { opal_output (ompi_bcol_base_framework.framework_output, "In bcol_comm_query mca_bcol_basesmuma_allocate_sm_ctl_memory failed\n"); return ret; } /* * put the memory onto the free list - we have worried about * alignment in the mpool allocation, and assume that the * ctl structures have the approriate size to mantain alignment */ /* figure out segment size */ n_ctl_structs=cs->basesmuma_num_mem_banks* cs->basesmuma_num_regions_per_bank; /* add memory for the control structure used for recycling the banks */ n_ctl_structs+=cs->basesmuma_num_mem_banks; ctl_segement_size=n_ctl_structs* sizeof(mca_bcol_basesmuma_ctl_struct_t); total_memory=cs->sm_ctl_structs->map_size - ( (char *)(cs->sm_ctl_structs->data_addr)- (char *)(cs->sm_ctl_structs->map_addr)); total_memory-=cs->my_scratch_shared_memory_size; max_elements=total_memory/ctl_segement_size; /* populate the free list */ data_ptr=cs->sm_ctl_structs->data_addr; for( i=0 ; i < max_elements ; i++ ) { list_data_t *item = OBJ_NEW(list_data_t); if( !item ) { return OMPI_ERR_OUT_OF_RESOURCE; } item->data=(void *)data_ptr; opal_list_append(&(cs->ctl_structures),(opal_list_item_t *)item); data_ptr+=ctl_segement_size; } /* set the scratch memory pointer and offset */ cs->my_scratch_shared_memory=(char *)data_ptr; cs->scratch_offset_from_base_ctl_file=(size_t) ((char *)data_ptr-(char *)cs->sm_ctl_structs->map_addr); /* At this stage the memory is mapped and ready to use by the local rank. * However, the memory of other processes has not yet been mmaped into the * memory of this process. */ } /* intialize no_userdata_ctl */ sm_bcol_module->no_userdata_ctl=(list_data_t *) opal_list_remove_last(&(cs->ctl_structures)); if (!sm_bcol_module->no_userdata_ctl) { return OMPI_ERR_OUT_OF_RESOURCE; } /* intialize userdata_ctl */ sm_bcol_module->userdata_ctl = (list_data_t *) opal_list_remove_last(&(cs->ctl_structures)); if (!sm_bcol_module->userdata_ctl) { return OMPI_ERR_OUT_OF_RESOURCE; } ret = base_bcol_basesmuma_setup_ctl (sm_bcol_module, cs); if (OMPI_SUCCESS != ret) { return ret; } ret = base_bcol_basesmuma_setup_ctl_struct (sm_bcol_module, cs, &(sm_bcol_module->colls_no_user_data)); if( OMPI_SUCCESS != ret ) { return ret; } ret = base_bcol_basesmuma_setup_ctl_struct (sm_bcol_module, cs, &(sm_bcol_module->colls_with_user_data)); if( OMPI_SUCCESS != ret ) { return ret; } /* used for blocking recursive doubling barrier */ sm_bcol_module->index_blocking_barrier_memory_bank=0; /* gather the offsets of the control structs relative to the base * of the shared memory file, and fill in the table with the * address of all the control structues. */ ret = base_bcol_basesmuma_exchange_ctl_params(sm_bcol_module, cs, &(sm_bcol_module->colls_no_user_data),sm_bcol_module->no_userdata_ctl); if( OMPI_SUCCESS != ret ) { return ret; } ret = base_bcol_basesmuma_exchange_ctl_params(sm_bcol_module, cs, &(sm_bcol_module->colls_with_user_data),sm_bcol_module->userdata_ctl); if( OMPI_SUCCESS != ret ) { return ret; } return OMPI_SUCCESS; }
int mca_io_base_delete(const char *filename, struct opal_info_t *info) { int err; opal_list_t *selectable; opal_list_item_t *item; avail_io_t *avail, selected; /* Announce */ opal_output_verbose(10, ompi_io_base_framework.framework_output, "io:base:delete: deleting file: %s", filename); /* See if a set of component was requested by the MCA parameter. Don't check for error. */ /* Compute the intersection of all of my available components with the components from all the other processes in this file */ /* JMS CONTINUE HERE */ /* See if there were any listed in the MCA parameter; parse them and check them all */ err = OMPI_ERROR; opal_output_verbose(10, ompi_io_base_framework.framework_output, "io:base:delete: Checking all available modules"); selectable = check_components(&ompi_io_base_framework.framework_components, filename, info, NULL, 0); /* Upon return from the above, the modules list will contain the list of modules that returned (priority >= 0). If we have no io modules available, it's an error */ if (NULL == selectable) { /* There's no modules available. Doh! */ /* show_help */ return OMPI_ERROR; } /* Do some kind of collective operation to find a module that everyone has available */ #if 1 /* For the moment, just take the top module off the list */ /* MSC actually take the buttom */ item = opal_list_remove_last(selectable); avail = (avail_io_t *) item; selected = *avail; OBJ_RELEASE(avail); #else /* JMS CONTINUE HERE */ #endif /* Everything left in the selectable list is therefore unwanted, and we call their unquery() method (because they all had query() invoked, but will never have init() invoked in this scope). */ for (item = opal_list_remove_first(selectable); item != NULL; item = opal_list_remove_first(selectable)) { avail = (avail_io_t *) item; unquery(avail, filename, info); OBJ_RELEASE(item); } OBJ_RELEASE(selectable); if (!strcmp (selected.ai_component.v2_0_0.io_version.mca_component_name, "ompio")) { int ret; opal_mutex_lock(&ompi_mpi_ompio_bootstrap_mutex); if (OMPI_SUCCESS != (ret = mca_base_framework_open(&ompi_fs_base_framework, 0))) { opal_mutex_unlock(&ompi_mpi_ompio_bootstrap_mutex); return err; } opal_mutex_unlock(&ompi_mpi_ompio_bootstrap_mutex); if (OMPI_SUCCESS != (ret = mca_fs_base_find_available(OPAL_ENABLE_PROGRESS_THREADS, 1))) { return err; } } /* Finally -- delete the file with the selected component */ if (OMPI_SUCCESS != (err = delete_file(&selected, filename, info))) { return err; } /* Announce the winner */ opal_output_verbose(10, ompi_io_base_framework.framework_output, "io:base:delete: Selected io component %s", selected.ai_component.v2_0_0.io_version.mca_component_name); return OMPI_SUCCESS; }