C++ opal_output_open函数代码示例

/**
 * Function for finding and opening either all MCA components, or the one
 * that was specifically requested via a MCA parameter.
 */
int mca_oob_base_open(void)
{
    /* Sanity check.  This may be able to be removed when the rml/oob
       interface is re-worked (the current infrastructure may invoke
       this function twice: once as a standalone, and once via the rml
       oob component). */
    if (orte_oob_base_already_opened) {
        return ORTE_SUCCESS;
    }

    /* register parameters */
    mca_oob_base_output = opal_output_open(NULL);
    
    /* Open up all available components */
    OBJ_CONSTRUCT(&mca_oob_base_components, opal_list_t);
    OBJ_CONSTRUCT(&mca_oob_base_modules, opal_list_t);
    
    if (ORTE_SUCCESS != 
        mca_base_components_open("oob", mca_oob_base_output,
                                 mca_oob_base_static_components, 
                                 &mca_oob_base_components, true)) {
        return ORTE_ERROR;
    }
    
    /* All done */
    orte_oob_base_already_opened = true;
    
    return ORTE_SUCCESS;
}

/**
 * Function for finding and opening either all MCA components,
 * or the one that was specifically requested via a MCA parameter.
 */
int ompi_crcp_base_open(void)
{
    char *str_value = NULL;

    ompi_crcp_base_output = opal_output_open(NULL);

    /* 
     * Which CRCP component to open
     *  - NULL or "" = auto-select
     *  - "none" = Empty component
     *  - ow. select that specific component
     * Note: Set the default to NULL here so ompi_info will work correctly,
     *       The 'real' default is set in base_select.c
     */
    mca_base_param_reg_string_name("crcp", NULL,
                                   "Which CRCP component to use (empty = auto-select)",
                                   false, false,
                                   NULL, &str_value);
    if( NULL != str_value ) {
        free(str_value);
    }

    /* Open up all available components */
    if (OPAL_SUCCESS !=
        mca_base_components_open("crcp", 
                                 ompi_crcp_base_output, 
                                 mca_crcp_base_static_components,
                                 &ompi_crcp_base_components_available,
                                 true)) {
        return OMPI_ERROR;
    }
    
    return OMPI_SUCCESS;
}

static int crs_blcr_open(void)
{
    /* If there is a custom verbose level for this component than use it
     * otherwise take our parents level and output channel
     */
    if ( 0 != mca_crs_blcr_component.super.verbose) {
        mca_crs_blcr_component.super.output_handle = opal_output_open(NULL);
        opal_output_set_verbosity(mca_crs_blcr_component.super.output_handle,
                                  mca_crs_blcr_component.super.verbose);
    } else {
        mca_crs_blcr_component.super.output_handle = opal_crs_base_framework.framework_output;
    }

    /*
     * Debug output
     */
    opal_output_verbose(10, mca_crs_blcr_component.super.output_handle,
                        "crs:blcr: open()");
    opal_output_verbose(20, mca_crs_blcr_component.super.output_handle,
                        "crs:blcr: open: priority = %d",
                        mca_crs_blcr_component.super.priority);
    opal_output_verbose(20, mca_crs_blcr_component.super.output_handle,
                        "crs:blcr: open: verbosity = %d",
                        mca_crs_blcr_component.super.verbose);
    opal_output_verbose(10, mca_crs_blcr_component.super.output_handle,
                        "crs:blcr: open: dev_null = %s",
                        (opal_crs_blcr_dev_null == true ? "True" : "False"));

    return OPAL_SUCCESS;
}

int orcm_cfgi_base_open(void)
{
    /* Debugging / verbose output.  Always have stream open, with
     verbose set by the mca open system... */
    orcm_cfgi_base.output = opal_output_open(NULL);
    
    /* init the globals */
    OBJ_CONSTRUCT(&orcm_cfgi_base.ctl, orte_thread_ctl_t);
    orcm_cfgi_base.num_active_apps = 0;
    orcm_cfgi_base.daemons = NULL;
    OBJ_CONSTRUCT(&orcm_cfgi_components_available, opal_list_t);
    OBJ_CONSTRUCT(&orcm_cfgi_selected_modules, opal_list_t);
    OBJ_CONSTRUCT(&orcm_cfgi_base.installed_apps, opal_pointer_array_t);
    opal_pointer_array_init(&orcm_cfgi_base.installed_apps, 16, INT_MAX, 16);
    OBJ_CONSTRUCT(&orcm_cfgi_base.confgd_apps, opal_pointer_array_t);
    opal_pointer_array_init(&orcm_cfgi_base.confgd_apps, 16, INT_MAX, 16);
    orcm_cfgi_base.launch_pipe[0] = -1;
    orcm_cfgi_base.launch_pipe[1] = -1;

    /* Open up all available components */
    if (ORCM_SUCCESS != 
        mca_base_components_open("orcm_cfgi", orcm_cfgi_base.output, NULL,
                                 &orcm_cfgi_components_available, true)) {
            return ORCM_ERROR;
        }
    
    /* All done */
    return ORCM_SUCCESS;
}

/*
 * CR Init
 */
int ompi_cr_init(void) 
{
    int val;

    /*
     * Register some MCA parameters
     */
    mca_base_param_reg_int_name("ompi_cr", "verbose",
                                "Verbose output for the OMPI Checkpoint/Restart functionality",
                                false, false,
                                0,
                                &val);
    if(0 != val) {
        ompi_cr_output = opal_output_open(NULL);
        opal_output_set_verbosity(ompi_cr_output, val);
    } else {
        ompi_cr_output = opal_cr_output;
    }

    /* Typically this is not needed. Individual BTLs will set this as needed */
    ompi_cr_continue_like_restart = false;

    opal_output_verbose(10, ompi_cr_output,
                        "ompi_cr: init: ompi_cr_init()");
    
    /* Register the OMPI interlevel coordination callback */
    opal_cr_reg_coord_callback(ompi_cr_coord, &prev_coord_callback);
    
    return OMPI_SUCCESS;
}

/**
 * This function gets called once to check if the program is running in a cuda
 * environment. 
 */
static void opal_cuda_support_init(void)
{
    int id;
    CUresult res;
    CUcontext cuContext;

    if (initialized) {
        return;
    }

    /* Set different levels of verbosity in the cuda related code. */
    id = mca_base_param_reg_int_name("opal", "cuda_verbose", 
                                     "Set level of opal cuda verbosity",
                                     false, false, 0, &opal_cuda_verbose);
    opal_cuda_output = opal_output_open(NULL);
    opal_output_set_verbosity(opal_cuda_output, opal_cuda_verbose);

    /* Check to see if this process is running in a CUDA context.  If so,
     * all is good.  Currently, just print out a message in verbose mode
     * to help with debugging. */
    res = cuCtxGetCurrent(&cuContext);
    if (CUDA_SUCCESS != res) {
        opal_output_verbose(10, opal_cuda_output,
                            "CUDA: cuCtxGetCurrent failed, CUDA device pointers will not work");
    } else {
        opal_output_verbose(10, opal_cuda_output,
                            "CUDA: cuCtxGetCurrent succeeded, CUDA device pointers will work");
    }

    initialized = true;
}

int
orte_rml_base_open(void)
{
    int ret;

    /* Initialize globals */
    OBJ_CONSTRUCT(&orte_rml_base_components, opal_list_t);
    OBJ_CONSTRUCT(&orte_rml_base_subscriptions, opal_list_t);


    /* 
     * Which RML Wrapper component to use, if any
     *  - NULL or "" = No wrapper
     *  - ow. select that specific wrapper component
     */
    mca_base_param_reg_string_name("rml", "wrapper",
                                   "Use a Wrapper component around the selected RML component",
                                   false, false,
                                   NULL, NULL);
    
    /* register parameters */
    orte_rml_base_output = opal_output_open(NULL);
    
    /* Open up all available components */
    ret = mca_base_components_open("rml",
                                   orte_rml_base_output,
                                   mca_rml_base_static_components, 
                                   &orte_rml_base_components,
                                   true);
    component_open_called = true;

    return ret;
}

/**
  * component open/close/init function
  */
static int rgpusm_open(void)
{
    mca_mpool_rgpusm_component.output = opal_output_open(NULL);
    opal_output_set_verbosity(mca_mpool_rgpusm_component.output, ompi_mpool_rgpusm_verbose);

    return OMPI_SUCCESS;
}

/* init the progress engine - called from orte_init */
int
opal_progress_init(void)
{
#if OPAL_ENABLE_DEBUG
    int param, value;
#endif

    /* reentrant issues */
#if OPAL_HAVE_THREAD_SUPPORT
    opal_atomic_init(&progress_lock, OPAL_ATOMIC_UNLOCKED);
#endif  /* OPAL_HAVE_THREAD_SUPPORT */

    /* set the event tick rate */
    opal_progress_set_event_poll_rate(10000);

#if OPAL_ENABLE_DEBUG
    param = mca_base_param_find("opal", NULL, "progress_debug");
    mca_base_param_lookup_int(param, &value);
    if (value) {
        debug_output = opal_output_open(NULL);
    }
#endif

    OPAL_OUTPUT((debug_output, "progress: initialized event flag to: %x",
                 opal_progress_event_flag));                 
    OPAL_OUTPUT((debug_output, "progress: initialized yield_when_idle to: %s",
                 call_yield == 0 ? "false" : "true"));
    OPAL_OUTPUT((debug_output, "progress: initialized num users to: %d",
                 num_event_users));
    OPAL_OUTPUT((debug_output, "progress: initialized poll rate to: %ld",
                 (long) event_progress_delta));

    return OPAL_SUCCESS;
}

/*
 * Function for finding and opening either all MCA components, or the one
 * that was specifically requested via a MCA parameter.
 */
int opal_carto_base_open(void)
{
    int value;

    /* Debugging / verbose output */

    mca_base_param_reg_int_name("carto", "base_verbose", 
                                "Verbosity level of the carto framework",
                                false, false,
                                0, &value);
    if (0 != value) {
        opal_carto_base_output = opal_output_open(NULL);
    } else {
        opal_carto_base_output = -1;
    }

    opal_carto_base_components_opened_valid = false;

    /* Open up all available components */

    if (OPAL_SUCCESS !=
        mca_base_components_open("carto", opal_carto_base_output,
                                 mca_carto_base_static_components,
                                 &opal_carto_base_components_opened, 
                                 true)) {
        return OPAL_ERROR;
    }
    opal_carto_base_components_opened_valid = true;

    /* All done */

    return OPAL_SUCCESS;
}

static int orcm_osub_init(int argc, char *argv[]) 
{
    int ret;

    /*
     * Make sure to init util before parse_args
     * to ensure installdirs is setup properly
     * before calling mca_base_open();
     */
    if( ORTE_SUCCESS != (ret = opal_init_util(&argc, &argv)) ) {
        return ret;
    }

    /*
     * Parse Command Line Arguments
     */
    if (ORTE_SUCCESS != (ret = parse_args(argc, argv))) {
        return ret;
    }

    /*
     * Setup OPAL Output handle from the verbose argument
     */
    if( orcm_osub_globals.verbose ) {
        orcm_osub_globals.output = opal_output_open(NULL);
        opal_output_set_verbosity(orcm_osub_globals.output, 10);
    } else {
        orcm_osub_globals.output = 0; /* Default=STDERR */
    }

    ret = orcm_init(ORCM_TOOL);

    return ret;
}

int mca_pml_crcpw_component_open(void)
{
    opal_output_verbose( 10, mca_pml_crcpw_component.output_handle,
                         "pml:crcpw: component_open: Open");

    mca_pml_crcpw_component.output_handle = opal_output_open(NULL);
    if ( 0 != mca_pml_crcpw_component.verbose) {
        opal_output_set_verbosity(mca_pml_crcpw_component.output_handle,
                                  mca_pml_crcpw_component.verbose);
    }
    
    /*
     * Debug Output
     */
    opal_output_verbose(10, mca_pml_crcpw_component.output_handle,
                        "pml:crcpw: open()");
    opal_output_verbose(20, mca_pml_crcpw_component.output_handle,
                        "pml:crcpw: open: priority   = %d", 
                        mca_pml_crcpw_component.priority);
    opal_output_verbose(20, mca_pml_crcpw_component.output_handle,
                        "pml:crcpw: open: verbosity  = %d", 
                        mca_pml_crcpw_component.verbose);

    return OMPI_SUCCESS;
}

void shmem_init(void)
{
    int err = OSHMEM_SUCCESS;
    int provided;
    int required = SHMEM_THREAD_SINGLE;

    if (oshmem_shmem_initialized) {
        /*
         * SPEC: If start_pes() is called multiple times, subsequent calls have no effect.
         */
        return;
    }

    shmem_api_logger_output = opal_output_open(NULL);
    opal_output_set_verbosity(shmem_api_logger_output,
                              oshmem_shmem_api_verbose);

    err = oshmem_shmem_init(0, NULL, required, &provided);
    if (OSHMEM_SUCCESS != err) {
        /* since spec does not propagete error to user we can only abort */
        SHMEM_API_ERROR("SHMEM failed to initialize - aborting");
        oshmem_shmem_abort(-1);
    }

    OPAL_CR_INIT_LIBRARY();
}

static int compress_gzip_open(void)
{
    /* If there is a custom verbose level for this component than use it
     * otherwise take our parents level and output channel
     */
    if ( 0 != mca_compress_gzip_component.super.verbose) {
        mca_compress_gzip_component.super.output_handle = opal_output_open(NULL);
        opal_output_set_verbosity(mca_compress_gzip_component.super.output_handle,
                                  mca_compress_gzip_component.super.verbose);
    } else {
        mca_compress_gzip_component.super.output_handle = opal_compress_base_framework.framework_output;
    }

    /*
     * Debug output
     */
    opal_output_verbose(10, mca_compress_gzip_component.super.output_handle,
                        "compress:gzip: open()");
    opal_output_verbose(20, mca_compress_gzip_component.super.output_handle,
                        "compress:gzip: open: priority = %d",
                        mca_compress_gzip_component.super.priority);
    opal_output_verbose(20, mca_compress_gzip_component.super.output_handle,
                        "compress:gzip: open: verbosity = %d",
                        mca_compress_gzip_component.super.verbose);
    return OPAL_SUCCESS;
}

/**
 * Function for finding and opening either all MCA components,
 * or the one that was specifically requested via a MCA parameter.
 */
int orte_filem_base_open(void)
{
    char *str_value = NULL;

    orte_filem_base_output = opal_output_open(NULL);

    /* 
     * Which FileM component to open
     *  - NULL or "" = auto-select
     *  - "none" = Empty component
     *  - ow. select that specific component
     */
    mca_base_param_reg_string_name("filem", NULL,
                                   "Which Filem component to use (empty = auto-select)",
                                   false, false,
                                   NULL, &str_value);
    if( NULL != str_value ) {
        free(str_value);
    }

    /* Open up all available components */
    if (OPAL_SUCCESS !=
        mca_base_components_open("filem", 
                                 orte_filem_base_output, 
                                 mca_filem_base_static_components,
                                 &orte_filem_base_components_available,
                                 true)) {
        return ORTE_ERROR;
    }
    
    return ORTE_SUCCESS;
}