gpr_base_open.c

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

/*
 * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
 *                         University Research and Technology
 *                         Corporation.  All rights reserved.
 * Copyright (c) 2004-2006 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$
 *
 * Additional copyrights may follow
 *
 * $HEADER$
 */

#include "orte_config.h"

#include "orte/orte_constants.h"

#include "opal/util/output.h"
#include "opal/util/trace.h"

#include "orte/dss/dss.h"
#include "orte/mca/errmgr/errmgr.h"

#include "orte/mca/gpr/base/base.h"



/*
 * The following file was created by configure.  It contains extern
 * statements and the definition of an array of pointers to each
 * component's public mca_base_module_t struct.
 */

#include "orte/mca/gpr/base/static-components.h"

/* JMS: This is only INT_MAX until bug 1345 is fixed, because this
   value is used to set an MAC parameter, which can [currently] only
   take an int. */
#define ORTE_GPR_ARRAY_MAX_SIZE INT_MAX
#define ORTE_GPR_ARRAY_BLOCK_SIZE 512



/*
 * globals
 */

/** KEYVAL **/
/* constructor - used to initialize state of keyval instance */
static void orte_gpr_keyval_construct(orte_gpr_keyval_t* keyval)
{
    keyval->key = NULL;
    keyval->value = NULL;
}

/* destructor - used to free any resources held by instance */
static void orte_gpr_keyval_destructor(orte_gpr_keyval_t* keyval)
{

    if (NULL != keyval->key) free(keyval->key);
    if (NULL != keyval->value) OBJ_RELEASE(keyval->value);
}

/* define instance of opal_class_t */
OBJ_CLASS_INSTANCE(
    orte_gpr_keyval_t,              /* type name */
    opal_list_item_t,               /* parent "class" name */
    orte_gpr_keyval_construct,      /* constructor */
    orte_gpr_keyval_destructor);    /* destructor */



/** VALUE **/
/* constructor - used to initialize state of registry value instance */
static void orte_gpr_value_construct(orte_gpr_value_t* reg_val)
{
    reg_val->addr_mode = 0;
    reg_val->segment = NULL;
    reg_val->cnt = 0;
    reg_val->keyvals = NULL;
    reg_val->num_tokens = 0;
    reg_val->tokens = NULL;
}

/* destructor - used to free any resources held by instance */
static void orte_gpr_value_destructor(orte_gpr_value_t* reg_val)
{
    char **tokens;
    orte_std_cntr_t i;

    if (NULL != reg_val->segment) free(reg_val->segment);

    if (0 < reg_val->cnt && NULL != reg_val->keyvals) {
        for (i=0; i < reg_val->cnt; i++) {
            if (NULL != reg_val->keyvals[i])
                OBJ_RELEASE(reg_val->keyvals[i]);
        }
       free(reg_val->keyvals);
    }

    if (0 < reg_val->num_tokens && NULL != reg_val->tokens) {
        tokens = reg_val->tokens;
        for (i=0; i < reg_val->num_tokens; i++) {
            if(NULL != tokens[i])
                free(tokens[i]);
        }
        free(tokens);
    }
}

/* define instance of opal_class_t */
OBJ_CLASS_INSTANCE(
           orte_gpr_value_t,  /* type name */
           opal_object_t, /* parent "class" name */
           orte_gpr_value_construct, /* constructor */
           orte_gpr_value_destructor); /* destructor */


/** NOTIFY DATA **/
/* constructor - used to initialize state of registry value instance */
static void orte_gpr_notify_data_construct(orte_gpr_notify_data_t* ptr)
{
    ptr->target = NULL;
    ptr->id = ORTE_GPR_SUBSCRIPTION_ID_MAX;
    ptr->remove = false;
    ptr->cnt = 0;
    orte_pointer_array_init(&(ptr->values), (orte_std_cntr_t)orte_gpr_array_block_size,
                            (orte_std_cntr_t)orte_gpr_array_max_size,
                            (orte_std_cntr_t)orte_gpr_array_block_size);

}

/* destructor - used to free any resources held by instance */
static void orte_gpr_notify_data_destructor(orte_gpr_notify_data_t* ptr)
{
    orte_std_cntr_t i, j;
    orte_gpr_value_t **values;

    if (NULL != ptr->target) free(ptr->target);

    if (NULL != ptr->values) {
        values = (orte_gpr_value_t**)(ptr->values)->addr;
        for (i=0, j=0; j < ptr->cnt &&
                       i < (ptr->values)->size; i++) {
            if (NULL != values[i]) {
                j++;
                OBJ_RELEASE(values[i]);
            }
        }
        OBJ_RELEASE(ptr->values);
    }
}

/* define instance of opal_class_t */
OBJ_CLASS_INSTANCE(
            orte_gpr_notify_data_t,  /* type name */
            opal_object_t, /* parent "class" name */
            orte_gpr_notify_data_construct, /* constructor */
            orte_gpr_notify_data_destructor); /* destructor */


/** SUBSCRIPTION **/
/* constructor - used to initialize state of registry subscription instance */
static void orte_gpr_subscription_construct(orte_gpr_subscription_t* sub)
{
    sub->name = NULL;
    sub->id = ORTE_GPR_SUBSCRIPTION_ID_MAX;
    sub->action = 0;
    sub->cnt = 0;
    sub->values = NULL;
    sub->cbfunc = NULL;
    sub->user_tag = NULL;
}

/* destructor - used to free any resources held by instance */
static void orte_gpr_subscription_destructor(orte_gpr_subscription_t* sub)
{
    orte_std_cntr_t i;

    if (NULL != sub->name) free(sub->name);

    if (0 < sub->cnt && NULL != sub->values) {
        for (i=0; i < sub->cnt; i++) {
            OBJ_RELEASE(sub->values[i]);
        }
        free(sub->values);
    }
}

/* define instance of opal_class_t */
OBJ_CLASS_INSTANCE(
         orte_gpr_subscription_t,  /* type name */
         opal_object_t, /* parent "class" name */
         orte_gpr_subscription_construct, /* constructor */
         orte_gpr_subscription_destructor); /* destructor */


/** TRIGGER **/
/* constructor - used to initialize state of registry subscription instance */
static void orte_gpr_trigger_construct(orte_gpr_trigger_t* trig)
{
    trig->name = NULL;
    trig->id = ORTE_GPR_TRIGGER_ID_MAX;
    trig->action = 0;
    trig->cnt = 0;
    trig->values = NULL;
    trig->cbfunc = NULL;
    trig->user_tag = NULL;
}

/* destructor - used to free any resources held by instance */
static void orte_gpr_trigger_destructor(orte_gpr_trigger_t* trig)
{
    orte_std_cntr_t i;

    if (NULL != trig->name) free(trig->name);

    if (0 < trig->cnt && NULL != trig->values) {
        for (i=0; i < trig->cnt; i++) OBJ_RELEASE(trig->values[i]);
        free(trig->values);
    }

}

/* define instance of opal_class_t */
OBJ_CLASS_INSTANCE(
         orte_gpr_trigger_t,  /* type name */
         opal_object_t, /* parent "class" name */
         orte_gpr_trigger_construct, /* constructor */
         orte_gpr_trigger_destructor); /* destructor */


/** NOTIFY MESSAGE */
/* constructor - used to initialize notify message instance */
static void orte_gpr_notify_message_construct(orte_gpr_notify_message_t* msg)
{
    msg->msg_type = 0;
    msg->target = NULL;
    msg->id = ORTE_GPR_TRIGGER_ID_MAX;
    msg->remove = false;
    msg->cnt = 0;
    orte_pointer_array_init(&(msg->data), (orte_std_cntr_t)orte_gpr_array_block_size,
                            (orte_std_cntr_t)orte_gpr_array_max_size,
                            (orte_std_cntr_t)orte_gpr_array_block_size);
}

/* destructor - used to free any resources held by instance */
static void orte_gpr_notify_message_destructor(orte_gpr_notify_message_t* msg)
{
    orte_std_cntr_t i, j;
    orte_gpr_notify_data_t **data;

    if (NULL != msg->target) free(msg->target);

    if (NULL != msg->data) {
        data = (orte_gpr_notify_data_t**)(msg->data)->addr;
        for (i=0, j=0; j < msg->cnt &&
                       i < (msg->data)->size; i++) {
            if (NULL != data[i]) {
                j++;