gpr_base_open.c

MPI stands for the Message Passing Interface. Written by the MPI Forum (a large committee comprising

                OBJ_RELEASE(data[i]);
            }
        }
        OBJ_RELEASE(msg->data);
    }

}

/* define instance of opal_class_t */
OBJ_CLASS_INSTANCE(
            orte_gpr_notify_message_t,            /* type name */
            opal_object_t,                             /* parent "class" name */
            orte_gpr_notify_message_construct,    /* constructor */
            orte_gpr_notify_message_destructor);  /* destructor */


/*
 * Global variables
 */
int orte_gpr_base_output = -1;
size_t orte_gpr_array_max_size, orte_gpr_array_block_size;
orte_gpr_base_module_t orte_gpr;
bool orte_gpr_base_selected = false;
opal_list_t orte_gpr_base_components_available;
mca_gpr_base_component_t orte_gpr_base_selected_component;
opal_mutex_t orte_gpr_mutex;


/**
 * Function for finding and opening either all MCA components, or the one
 * that was specifically requested via a MCA parameter.
 */
int orte_gpr_base_open(void)
{
    int param, value, rc, id;
    orte_data_type_t tmp;
    opal_output_stream_t kill_prefix;

    OPAL_TRACE(5);

    /* Debugging / verbose output */
    /** setup the structure to kill the blasted prefix that opal_output
     * now defaults to including so the output can be legible again!
     */
    OBJ_CONSTRUCT(&kill_prefix, opal_output_stream_t);
    kill_prefix.lds_want_stderr = true;
    kill_prefix.lds_prefix = NULL;
    
    param = mca_base_param_reg_int_name("gpr", "base_verbose",
                                        "Verbosity level for the gpr framework",
                                        false, false, 0, &value);
    if (value != 0) {
        kill_prefix.lds_verbose_level = value;
    }
    orte_gpr_base_output = opal_output_open(&kill_prefix);
    OBJ_DESTRUCT(&kill_prefix);

    id = mca_base_param_register_int("gpr", "base", "maxsize", NULL,
                                     ORTE_GPR_ARRAY_MAX_SIZE);
    mca_base_param_lookup_int(id, &param);
    orte_gpr_array_max_size = (size_t)param;

    id = mca_base_param_register_int("gpr", "base", "blocksize", NULL,
                                     ORTE_GPR_ARRAY_BLOCK_SIZE);
    mca_base_param_lookup_int(id, &param);
    orte_gpr_array_block_size = (size_t)param;

    /* register the base data types with the DPS */
    tmp = ORTE_GPR_CMD;
    if (ORTE_SUCCESS != (rc = orte_dss.register_type(orte_gpr_base_pack_cmd,
                                          orte_gpr_base_unpack_cmd,
                                          (orte_dss_copy_fn_t)orte_gpr_base_copy_cmd,
                                          (orte_dss_compare_fn_t)orte_gpr_base_compare_cmd,
                                          (orte_dss_size_fn_t)orte_gpr_base_std_size,
                                          (orte_dss_print_fn_t)orte_gpr_base_std_print,
                                          (orte_dss_release_fn_t)orte_gpr_base_std_release,
                                          ORTE_DSS_UNSTRUCTURED,
                                          "ORTE_GPR_CMD", &tmp))) {
        ORTE_ERROR_LOG(rc);
        return rc;
    }

    tmp = ORTE_GPR_SUBSCRIPTION_ID;
    if (ORTE_SUCCESS != (rc = orte_dss.register_type(orte_gpr_base_pack_subscription_id,
                                          orte_gpr_base_unpack_subscription_id,
                                          (orte_dss_copy_fn_t)orte_gpr_base_copy_subscription_id,
                                          (orte_dss_compare_fn_t)orte_gpr_base_compare_subscription_id,
                                          (orte_dss_size_fn_t)orte_gpr_base_std_size,
                                          (orte_dss_print_fn_t)orte_gpr_base_std_print,
                                          (orte_dss_release_fn_t)orte_gpr_base_std_release,
                                          ORTE_DSS_UNSTRUCTURED,
                                          "ORTE_GPR_SUBSCRIPTION_ID", &tmp))) {
        ORTE_ERROR_LOG(rc);
        return rc;
    }

    tmp = ORTE_GPR_TRIGGER_ID;
    if (ORTE_SUCCESS != (rc = orte_dss.register_type(orte_gpr_base_pack_trigger_id,
                                          orte_gpr_base_unpack_trigger_id,
                                          (orte_dss_copy_fn_t)orte_gpr_base_copy_trigger_id,
                                          (orte_dss_compare_fn_t)orte_gpr_base_compare_trigger_id,
                                          (orte_dss_size_fn_t)orte_gpr_base_std_size,
                                          (orte_dss_print_fn_t)orte_gpr_base_std_print,
                                          (orte_dss_release_fn_t)orte_gpr_base_std_release,
                                          ORTE_DSS_UNSTRUCTURED,
                                          "ORTE_GPR_TRIGGER_ID", &tmp))) {
        ORTE_ERROR_LOG(rc);
        return rc;
    }

    tmp = ORTE_GPR_NOTIFY_ACTION;
    if (ORTE_SUCCESS != (rc = orte_dss.register_type(orte_gpr_base_pack_notify_action,
                                          orte_gpr_base_unpack_notify_action,
                                          (orte_dss_copy_fn_t)orte_gpr_base_copy_notify_action,
                                          (orte_dss_compare_fn_t)orte_gpr_base_compare_notify_action,
                                          (orte_dss_size_fn_t)orte_gpr_base_std_size,
                                          (orte_dss_print_fn_t)orte_gpr_base_std_print,
                                          (orte_dss_release_fn_t)orte_gpr_base_std_release,
                                          ORTE_DSS_UNSTRUCTURED,
                                          "ORTE_GPR_NOTIFY_ACTION", &tmp))) {
        ORTE_ERROR_LOG(rc);
        return rc;
    }

    tmp = ORTE_GPR_TRIGGER_ACTION;
    if (ORTE_SUCCESS != (rc = orte_dss.register_type(orte_gpr_base_pack_trigger_action,
                                          orte_gpr_base_unpack_trigger_action,
                                          (orte_dss_copy_fn_t)orte_gpr_base_copy_trigger_action,
                                          (orte_dss_compare_fn_t)orte_gpr_base_compare_trigger_action,
                                          (orte_dss_size_fn_t)orte_gpr_base_std_size,
                                          (orte_dss_print_fn_t)orte_gpr_base_std_print,
                                          (orte_dss_release_fn_t)orte_gpr_base_std_release,
                                          ORTE_DSS_UNSTRUCTURED,
                                          "ORTE_GPR_TRIGGER_ACTION", &tmp))) {
        ORTE_ERROR_LOG(rc);
        return rc;
    }

    tmp = ORTE_GPR_NOTIFY_MSG_TYPE;
    if (ORTE_SUCCESS != (rc = orte_dss.register_type(orte_gpr_base_pack_notify_msg_type,
                                          orte_gpr_base_unpack_notify_msg_type,
                                          (orte_dss_copy_fn_t)orte_gpr_base_copy_notify_msg_type,
                                          (orte_dss_compare_fn_t)orte_gpr_base_compare_notify_msg_type,
                                          (orte_dss_size_fn_t)orte_gpr_base_std_size,
                                          (orte_dss_print_fn_t)orte_gpr_base_std_print,
                                          (orte_dss_release_fn_t)orte_gpr_base_std_release,
                                          ORTE_DSS_UNSTRUCTURED,
                                          "ORTE_GPR_NOTIFY_MSG_TYPE", &tmp))) {
        ORTE_ERROR_LOG(rc);
        return rc;
    }

    tmp = ORTE_GPR_ADDR_MODE;
    if (ORTE_SUCCESS != (rc = orte_dss.register_type(orte_gpr_base_pack_addr_mode,
                                          orte_gpr_base_unpack_addr_mode,
                                          (orte_dss_copy_fn_t)orte_gpr_base_copy_addr_mode,
                                          (orte_dss_compare_fn_t)orte_gpr_base_compare_addr_mode,
                                          (orte_dss_size_fn_t)orte_gpr_base_std_size,
                                          (orte_dss_print_fn_t)orte_gpr_base_std_print,
                                          (orte_dss_release_fn_t)orte_gpr_base_std_release,
                                          ORTE_DSS_UNSTRUCTURED,
                                          "ORTE_GPR_ADDR_MODE", &tmp))) {
        ORTE_ERROR_LOG(rc);
        return rc;
    }

    tmp = ORTE_GPR_KEYVAL;
    if (ORTE_SUCCESS != (rc = orte_dss.register_type(orte_gpr_base_pack_keyval,
                                          orte_gpr_base_unpack_keyval,
                                          (orte_dss_copy_fn_t)orte_gpr_base_copy_keyval,
                                          (orte_dss_compare_fn_t)orte_gpr_base_compare_keyval,
                                          (orte_dss_size_fn_t)orte_gpr_base_size_keyval,
                                          (orte_dss_print_fn_t)orte_gpr_base_print_keyval,
                                          (orte_dss_release_fn_t)orte_gpr_base_std_obj_release,
                                          ORTE_DSS_STRUCTURED,
                                          "ORTE_GPR_KEYVAL", &tmp))) {
        ORTE_ERROR_LOG(rc);
        return rc;
    }

    tmp = ORTE_GPR_VALUE;
    if (ORTE_SUCCESS != (rc = orte_dss.register_type(orte_gpr_base_pack_value,
                                          orte_gpr_base_unpack_value,
                                          (orte_dss_copy_fn_t)orte_gpr_base_copy_gpr_value,
                                          (orte_dss_compare_fn_t)orte_gpr_base_compare_gpr_value,
                                          (orte_dss_size_fn_t)orte_gpr_base_size_gpr_value,
                                          (orte_dss_print_fn_t)orte_gpr_base_print_gpr_value,
                                          (orte_dss_release_fn_t)orte_gpr_base_std_obj_release,
                                          ORTE_DSS_STRUCTURED,
                                          "ORTE_GPR_VALUE", &tmp))) {
        ORTE_ERROR_LOG(rc);
        return rc;
    }

    tmp = ORTE_GPR_SUBSCRIPTION;
    if (ORTE_SUCCESS != (rc = orte_dss.register_type(orte_gpr_base_pack_subscription,
                                          orte_gpr_base_unpack_subscription,
                                          (orte_dss_copy_fn_t)orte_gpr_base_copy_subscription,
                                          (orte_dss_compare_fn_t)orte_gpr_base_compare_subscription,
                                          (orte_dss_size_fn_t)orte_gpr_base_size_subscription,
                                          (orte_dss_print_fn_t)orte_gpr_base_print_subscription,
                                          (orte_dss_release_fn_t)orte_gpr_base_std_obj_release,
                                          ORTE_DSS_STRUCTURED,
                                          "ORTE_GPR_SUBSCRIPTION", &tmp))) {
        ORTE_ERROR_LOG(rc);
        return rc;
    }

    tmp = ORTE_GPR_TRIGGER;
    if (ORTE_SUCCESS != (rc = orte_dss.register_type(orte_gpr_base_pack_trigger,
                                          orte_gpr_base_unpack_trigger,
                                          (orte_dss_copy_fn_t)orte_gpr_base_copy_trigger,
                                          (orte_dss_compare_fn_t)orte_gpr_base_compare_trigger,
                                          (orte_dss_size_fn_t)orte_gpr_base_size_trigger,
                                          (orte_dss_print_fn_t)orte_gpr_base_print_trigger,
                                          (orte_dss_release_fn_t)orte_gpr_base_std_obj_release,
                                          ORTE_DSS_STRUCTURED,
                                          "ORTE_GPR_TRIGGER", &tmp))) {
        ORTE_ERROR_LOG(rc);
        return rc;
    }

    tmp = ORTE_GPR_NOTIFY_DATA;
    if (ORTE_SUCCESS != (rc = orte_dss.register_type(orte_gpr_base_pack_notify_data,
                                          orte_gpr_base_unpack_notify_data,
                                          (orte_dss_copy_fn_t)orte_gpr_base_copy_notify_data,
                                          (orte_dss_compare_fn_t)orte_gpr_base_compare_notify_data,
                                          (orte_dss_size_fn_t)orte_gpr_base_size_notify_data,
                                          (orte_dss_print_fn_t)orte_gpr_base_print_notify_data,
                                          (orte_dss_release_fn_t)orte_gpr_base_std_obj_release,
                                          ORTE_DSS_STRUCTURED,
                                          "ORTE_GPR_NOTIFY_DATA", &tmp))) {
        ORTE_ERROR_LOG(rc);
        return rc;
    }

    tmp = ORTE_GPR_NOTIFY_MSG;
    if (ORTE_SUCCESS != (rc = orte_dss.register_type(orte_gpr_base_pack_notify_msg,
                                          orte_gpr_base_unpack_notify_msg,
                                          (orte_dss_copy_fn_t)orte_gpr_base_copy_notify_msg,
                                          (orte_dss_compare_fn_t)orte_gpr_base_compare_notify_msg,
                                          (orte_dss_size_fn_t)orte_gpr_base_size_notify_msg,
                                          (orte_dss_print_fn_t)orte_gpr_base_print_notify_msg,
                                          (orte_dss_release_fn_t)orte_gpr_base_std_obj_release,
                                          ORTE_DSS_STRUCTURED,
                                          "ORTE_GPR_NOTIFY_MSG", &tmp))) {
        ORTE_ERROR_LOG(rc);
        return rc;
    }

    /* Open up all available components */
    if (ORTE_SUCCESS !=
        mca_base_components_open("gpr",
                                 orte_gpr_base_output,
                                 mca_gpr_base_static_components,
                                 &orte_gpr_base_components_available, true)) {
        return ORTE_ERROR;
    }

    /* All done */

    return ORTE_SUCCESS;
}