gpr_replica_class_instances.h

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

/* -*- C -*-
 *
 * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
 *                         University Research and Technology
 *                         Corporation.  All rights reserved.
 * Copyright (c) 2004-2005 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$
 *
 */
/** @file
 */

#ifndef ORTE_GPR_REPLICA_CLASS_INSTANCES_H_
#define ORTE_GPR_REPLICA_CLASS_INSTANCES_H_

#include "orte_config.h"

#include "orte/class/orte_bitmap.h"
#include "opal/class/opal_object.h"

#include "gpr_replica.h"

/*
 * CONSTRUCTORS, DESTRUCTORS, AND CLASS INSTANTIATIONS
 * FOR GPR REPLICA CLASSES
 */

/*  LOCAL_SUBSCRIBER */
static void orte_gpr_replica_local_subscriber_constructor(orte_gpr_replica_local_subscriber_t *ptr)
{
    ptr->name = NULL;
    ptr->callback = NULL;
    ptr->user_tag = NULL;
}

static void orte_gpr_replica_local_subscriber_destructor(orte_gpr_replica_local_subscriber_t *ptr)
{
    if (NULL != ptr->name) free(ptr->name);
}

OBJ_CLASS_INSTANCE(
          orte_gpr_replica_local_subscriber_t,  /* type name */
          opal_object_t, /* parent "class" name */
          orte_gpr_replica_local_subscriber_constructor, /* constructor */
          orte_gpr_replica_local_subscriber_destructor); /* destructor */


/*  LOCAL_TRIGGER */
static void orte_gpr_replica_local_trigger_constructor(orte_gpr_replica_local_trigger_t *ptr)
{
    ptr->name = NULL;
    ptr->callback = NULL;
    ptr->user_tag = NULL;
}

static void orte_gpr_replica_local_trigger_destructor(orte_gpr_replica_local_trigger_t *ptr)
{
    if (NULL != ptr->name) free(ptr->name);
}

/* define instance */
OBJ_CLASS_INSTANCE(
          orte_gpr_replica_local_trigger_t,  /* type name */
          opal_object_t, /* parent "class" name */
          orte_gpr_replica_local_trigger_constructor, /* constructor */
          orte_gpr_replica_local_trigger_destructor); /* destructor */


/*  SEGMENT */
/* constructor - used to initialize state of segment instance */
static void orte_gpr_replica_segment_construct(orte_gpr_replica_segment_t* seg)
{
    seg->name = NULL;
    seg->itag = ORTE_GPR_REPLICA_ITAG_MAX;

    seg->num_dict_entries = 0;
    orte_pointer_array_init(&(seg->dict), (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);

    seg->num_containers = 0;
    orte_pointer_array_init(&(seg->containers), (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_replica_segment_destructor(orte_gpr_replica_segment_t* seg)
{
    orte_std_cntr_t i, k;
    char **dptr;
    orte_gpr_replica_itag_t j;
    orte_gpr_replica_container_t **cptr;

    if (NULL != seg->name) {
        free(seg->name);
    }

    if (NULL != seg->dict) {
        dptr = (char**)(seg->dict)->addr;
        for (i=0, j=0; j < seg->num_dict_entries &&
                       i < (seg->dict)->size; i++) {
            if (NULL != dptr[i]) {
                j++;
                free(dptr[i]);
            }
        }
        OBJ_RELEASE(seg->dict);
    }

    if (NULL != seg->containers) {
        cptr = (orte_gpr_replica_container_t**)((seg->containers)->addr);
        for (i=0, k=0; k < seg->num_containers &&
                       i < (seg->containers)->size; i++) {
            if (NULL != cptr[i]) {
                k++;
                OBJ_RELEASE(cptr[i]);
            }
        }
        OBJ_RELEASE(seg->containers);
    }
}

/* define instance of orte_gpr_replica_segment_t */
OBJ_CLASS_INSTANCE(
          orte_gpr_replica_segment_t,  /* type name */
          opal_object_t, /* parent "class" name */
          orte_gpr_replica_segment_construct, /* constructor */
          orte_gpr_replica_segment_destructor); /* destructor */


/* CONTAINER */
/* constructor - used to initialize state of registry container instance */
static void orte_gpr_replica_container_construct(orte_gpr_replica_container_t* reg)
{
    reg->index = 0;
    reg->itags = NULL;
    reg->num_itags = 0;

    orte_pointer_array_init(&(reg->itagvals), (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);
    reg->num_itagvals = 0;

    OBJ_CONSTRUCT(&(reg->itaglist), orte_value_array_t);
    orte_value_array_init(&(reg->itaglist), sizeof(orte_gpr_replica_itag_t));

}

/* destructor - used to free any resources held by instance */
static void orte_gpr_replica_container_destructor(orte_gpr_replica_container_t* reg)
{
    orte_gpr_replica_itagval_t **ptr;
    orte_std_cntr_t i, k;

    if (NULL != reg->itags) {
         free(reg->itags);
    }

    if (NULL != reg->itagvals) {
        ptr = (orte_gpr_replica_itagval_t**)((reg->itagvals)->addr);
        for (i=0, k=0; k < reg->num_itagvals &&
                       i < (reg->itagvals)->size; i++) {
            if (NULL != ptr[i]) {
                k++;
                OBJ_RELEASE(ptr[i]);
            }
        }
        OBJ_RELEASE(reg->itagvals);
    }

    OBJ_DESTRUCT(&(reg->itaglist));

}

/* define instance of opal_class_t */
OBJ_CLASS_INSTANCE(
         orte_gpr_replica_container_t,  /* type name */
         opal_object_t, /* parent "class" name */
         orte_gpr_replica_container_construct, /* constructor */
         orte_gpr_replica_container_destructor); /* destructor */


/* ITAG-VALUE PAIR */
/* constructor - used to initialize state of itagval instance */
static void orte_gpr_replica_itagval_construct(orte_gpr_replica_itagval_t* ptr)
{
    ptr->index = 0;
    ptr->itag = ORTE_GPR_REPLICA_ITAG_MAX;
    ptr->value = NULL;
}

/* destructor - used to free any resources held by instance */
static void orte_gpr_replica_itagval_destructor(orte_gpr_replica_itagval_t* ptr)
{
    if (NULL != ptr->value) OBJ_RELEASE(ptr->value);
}

/* define instance of opal_class_t */
OBJ_CLASS_INSTANCE(
         orte_gpr_replica_itagval_t,  /* type name */
         opal_object_t, /* parent "class" name */
         orte_gpr_replica_itagval_construct, /* constructor */
         orte_gpr_replica_itagval_destructor); /* destructor */


/* IVALUE */
/* constructor - used to initialize state of ivalue instance */
static void orte_gpr_replica_ivalue_construct(orte_gpr_replica_ivalue_t* ptr)
{
    ptr->index = 0;
    ptr->seg = NULL;
    ptr->addr_mode = 0;

    OBJ_CONSTRUCT(&(ptr->tokentags), orte_value_array_t);
    orte_value_array_init(&(ptr->tokentags), sizeof(orte_gpr_replica_itag_t));

    OBJ_CONSTRUCT(&(ptr->keytags), orte_value_array_t);
    orte_value_array_init(&(ptr->keytags), sizeof(orte_gpr_replica_itag_t));

}

/* destructor - used to free any resources held by instance */
static void orte_gpr_replica_ivalue_destructor(orte_gpr_replica_ivalue_t* ptr)
{
    OBJ_DESTRUCT(&(ptr->tokentags));
    OBJ_DESTRUCT(&(ptr->keytags));
}

/* define instance of opal_class_t */
OBJ_CLASS_INSTANCE(
         orte_gpr_replica_ivalue_t,  /* type name */
         opal_object_t, /* parent "class" name */
         orte_gpr_replica_ivalue_construct, /* constructor */
         orte_gpr_replica_ivalue_destructor); /* destructor */


/* COUNTERS */
/* constructor - used to initialize state of counter instance */
static void orte_gpr_replica_counter_construct(orte_gpr_replica_counter_t* cntr)
{
    cntr->seg = NULL;
    cntr->cptr = NULL;
    cntr->iptr = NULL;
    OBJ_CONSTRUCT(&(cntr->trigger_level), orte_gpr_replica_itagval_t);
}

/* destructor - used to free any resources held by instance */
static void orte_gpr_replica_counter_destructor(orte_gpr_replica_counter_t* cntr)
{
    OBJ_DESTRUCT(&(cntr->trigger_level));
}

/* define instance of opal_class_t */
OBJ_CLASS_INSTANCE(
         orte_gpr_replica_counter_t,           /* type name */
         opal_object_t,                 /* parent "class" name */
         orte_gpr_replica_counter_construct,   /* constructor */
         orte_gpr_replica_counter_destructor); /* destructor */


/* REQUESTOR */
/* constructor - used to initialize state of requestor instance */
static void orte_gpr_replica_requestor_construct(orte_gpr_replica_requestor_t* ptr)
{
    ptr->index = 0;
    ptr->requestor = NULL;
    ptr->idtag = 0;
}

/* destructor - used to free any resources held by instance */
static void orte_gpr_replica_requestor_destructor(orte_gpr_replica_requestor_t* ptr)