gpr_replica_dump_fn.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-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:
 *
 * The Open MPI general purpose registry - implementation.
 *
 */

/*
 * includes
 */

#include "orte_config.h"

#include "orte/orte_constants.h"
#include "orte/orte_types.h"

#include "orte/dss/dss.h"
#include "opal/util/output.h"

#include "orte/mca/errmgr/errmgr.h"
#include "orte/mca/ns/ns_types.h"
#include "orte/mca/smr/smr_types.h"

#include "orte/mca/gpr/replica/transition_layer/gpr_replica_tl.h"
#include "gpr_replica_fn.h"

static void orte_gpr_replica_dump_load_string(orte_buffer_t *buffer, char **tmp);

void orte_gpr_replica_dump_itagval_value(orte_buffer_t *buffer,
                                         orte_gpr_replica_itagval_t *iptr);

static int orte_gpr_replica_get_segment_size_fn(size_t *segsize, orte_gpr_replica_segment_t *seg);


int orte_gpr_replica_dump_all_fn(orte_buffer_t *buffer)
{
    char tmp_out[80], *tmp;
    int rc;

    tmp = tmp_out;
    sprintf(tmp_out, "\n\n\nDUMP OF GENERAL PURPOSE REGISTRY");
    orte_gpr_replica_dump_load_string(buffer, &tmp);

    if (ORTE_SUCCESS != (rc = orte_gpr_replica_dump_triggers_fn(buffer, 0))) {
        return rc;
    }

    if (ORTE_SUCCESS != (rc = orte_gpr_replica_dump_subscriptions_fn(buffer, 0))) {
        return rc;
    }

    if (ORTE_SUCCESS != (rc = orte_gpr_replica_dump_callbacks_fn(buffer))) {
        return rc;
    }

    rc = orte_gpr_replica_dump_segments_fn(buffer, NULL);

    return rc;
}

int orte_gpr_replica_dump_segments_fn(orte_buffer_t *buffer, char *segment)
{
    orte_gpr_replica_segment_t **seg, *segptr;
    orte_std_cntr_t i, m;
    int rc;

    /* if segment = NULL, loop through all segments */
    if (NULL == segment) {
        seg = (orte_gpr_replica_segment_t**)(orte_gpr_replica.segments)->addr;
        for (i=0, m=0; m < orte_gpr_replica.num_segs &&
                       i < (orte_gpr_replica.segments)->size; i++) {
             if (NULL != seg[i]) {
                 m++;
                 if (ORTE_SUCCESS != (rc = orte_gpr_replica_dump_a_segment_fn(buffer, seg[i]))) {
                     ORTE_ERROR_LOG(rc);
                     return rc;
                 }
             }
         }
         return ORTE_SUCCESS;
     }

     /* otherwise, dump just the one specified */
     if (ORTE_SUCCESS != (rc = orte_gpr_replica_find_seg(&segptr, false, segment))) {
         ORTE_ERROR_LOG(rc);
         return rc;
     }
     if (ORTE_SUCCESS != (rc = orte_gpr_replica_dump_a_segment_fn(buffer, segptr))) {
         ORTE_ERROR_LOG(rc);
         return rc;
     }
     return ORTE_SUCCESS;
 }

 int orte_gpr_replica_dump_a_segment_fn(orte_buffer_t *buffer, orte_gpr_replica_segment_t *seg)
 {
    orte_gpr_replica_container_t **cptr;
    orte_gpr_replica_itag_t *itaglist;
    orte_gpr_replica_itagval_t **iptr;
    char *token;
    orte_std_cntr_t num_objects;
    orte_std_cntr_t j, k, n, p;
    char *tmp_out;

    tmp_out = (char*)malloc(1000);
    if (NULL == tmp_out) {
        ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
        return ORTE_ERR_OUT_OF_RESOURCE;
    }

    sprintf(tmp_out, "\nDUMP OF GPR SEGMENT %s", seg->name);
    orte_gpr_replica_dump_load_string(buffer, &tmp_out);

     num_objects = (seg->containers)->size - (seg->containers)->number_free;

     sprintf(tmp_out, "\tNumber of containers: %lu\n",
             (unsigned long) num_objects);
     orte_gpr_replica_dump_load_string(buffer, &tmp_out);

     /* loop through all containers and print their info and contents */
     cptr = (orte_gpr_replica_container_t**)(seg->containers)->addr;
     for (j=0, n=0; n < seg->num_containers &&
                    j < (seg->containers)->size; j++) {
         if (NULL != cptr[j]) {
             n++;
             sprintf(tmp_out, "\n\tInfo for container %lu"
                              "\tNumber of keyvals: %lu"
                              "\n\tTokens:\n",
                     (unsigned long) j,
                     ((unsigned long) (cptr[j]->itagvals)->size - (cptr[j]->itagvals)->number_free));
             orte_gpr_replica_dump_load_string(buffer, &tmp_out);

             /* reverse lookup tokens and print them */
             itaglist = cptr[j]->itags;
             for (k=0; k < cptr[j]->num_itags; k++) {
                 if (ORTE_SUCCESS != orte_gpr_replica_dict_reverse_lookup(
                                                       &token, seg, itaglist[k])) {
                     sprintf(tmp_out, "\t\titag num %lu"
                             ": No entry found for itag %lu",
                             (unsigned long) k,
                             (unsigned long) itaglist[k]);
                 } else {
                     sprintf(tmp_out, "\t\titag num %lu: itag %lu\tToken: %s",
                             (unsigned long) k,
                             (unsigned long) itaglist[k], token);
                     free(token);
                 }
                 orte_gpr_replica_dump_load_string(buffer, &tmp_out);
             }

             sprintf(tmp_out, "\n\tKeyval info:");
             orte_gpr_replica_dump_load_string(buffer, &tmp_out);

             /* loop through all itagvals and print their info */
             iptr = (orte_gpr_replica_itagval_t**)(cptr[j]->itagvals)->addr;
             for (k=0, p=0; p < cptr[j]->num_itagvals &&
                            k < (cptr[j]->itagvals)->size; k++) {
                 if (NULL != iptr[k]) {
                     p++;
                     if (ORTE_SUCCESS != orte_gpr_replica_dict_reverse_lookup(
                                                     &token, seg, iptr[k]->itag)) {
                         sprintf(tmp_out, "\n\t\titag num %lu: No entry found for itag %lu",
                                 (unsigned long) k,
                                 (unsigned long) iptr[k]->itag);
                     } else {
                         sprintf(tmp_out, "\n\t\tEntry %lu: itag %lu\tKey: %s",
                                 (unsigned long) k,
                                 (unsigned long) iptr[k]->itag, token);
                         free(token);
                     }
                     orte_gpr_replica_dump_load_string(buffer, &tmp_out);
                     orte_gpr_replica_dump_itagval_value(buffer, iptr[k]);
                 }
             }
         }
     }

    free(tmp_out);
    return ORTE_SUCCESS;
}


int orte_gpr_replica_dump_callbacks_fn(orte_buffer_t *buffer)
{
    orte_gpr_replica_callbacks_t *cb;
    orte_gpr_replica_action_taken_t **action;
    orte_gpr_replica_itag_t *itaglist;
    char *tmp_out, *token;
    orte_std_cntr_t i, j, k;

    tmp_out = (char*)malloc(1000);
    if (NULL == tmp_out) {
        ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
        return ORTE_ERR_OUT_OF_RESOURCE;
    }

    sprintf(tmp_out, "\nDUMP OF GPR REGISTERED CALLBACKS\n");
    orte_gpr_replica_dump_load_string(buffer, &tmp_out);

    if (0 >= (k = (orte_std_cntr_t)opal_list_get_size(&(orte_gpr_replica.callbacks)))) {
        sprintf(tmp_out, "--- None registered at this time ---");
        orte_gpr_replica_dump_load_string(buffer, &tmp_out);
    } else {
        sprintf(tmp_out, "--- %lu callback(s) registered at this time",
                (unsigned long) k);
        orte_gpr_replica_dump_load_string(buffer, &tmp_out);

        i=0;
        for (cb = (orte_gpr_replica_callbacks_t*)opal_list_get_first(&(orte_gpr_replica.callbacks));
             cb != (orte_gpr_replica_callbacks_t*)opal_list_get_end(&(orte_gpr_replica.callbacks));
             cb = (orte_gpr_replica_callbacks_t*)opal_list_get_next(cb)) {
             if (NULL == cb) {
                sprintf(tmp_out, "\n\t---  BAD CALLBACK POINTER %lu ---",
                        (unsigned long) i);
                orte_gpr_replica_dump_load_string(buffer, &tmp_out);
                return ORTE_SUCCESS;
             }
             sprintf(tmp_out, "\nInfo for callback %lu", (unsigned long) i);
             orte_gpr_replica_dump_load_string(buffer, &tmp_out);
             if (NULL == cb->requestor) {
                sprintf(tmp_out, "Local requestor");
             } else {
                sprintf(tmp_out, "Requestor: [%lu,%lu,%lu]",
                        ORTE_NAME_ARGS(cb->requestor));
             }
             orte_gpr_replica_dump_load_string(buffer, &tmp_out);
             orte_gpr_base_dump_notify_msg(buffer, cb->message);
             i++;
        }
    }

    sprintf(tmp_out, "\n");
    orte_gpr_replica_dump_load_string(buffer, &tmp_out);

    if (0 < orte_gpr_replica_globals.num_acted_upon) {
        sprintf(tmp_out, "\nDUMP OF GPR ACTION RECORDS\n");
        orte_gpr_replica_dump_load_string(buffer, &tmp_out);

        action = (orte_gpr_replica_action_taken_t**)orte_gpr_replica_globals.acted_upon->addr;
        for (i=0, j=0; j < orte_gpr_replica_globals.num_acted_upon &&
                       i < (orte_gpr_replica_globals.acted_upon)->size; i++) {
            if (NULL != action[i]) {
                j++;
                if (NULL != action[i]->seg) {
                    sprintf(tmp_out, "\nAction Taken on Segment: %s", action[i]->seg->name);
                    orte_gpr_replica_dump_load_string(buffer, &tmp_out);
                } else {
                    sprintf(tmp_out, "\nAction Taken on NULL Segment");
                    orte_gpr_replica_dump_load_string(buffer, &tmp_out);
                }
                if (NULL != action[i]->cptr) {
                     sprintf(tmp_out, "\tContainer Tokens:");
                     orte_gpr_replica_dump_load_string(buffer, &tmp_out);

                     /* reverse lookup tokens and print them */
                     itaglist = action[i]->cptr->itags;
                     for (k=0; k < action[i]->cptr->num_itags; k++) {
                         if (ORTE_SUCCESS != orte_gpr_replica_dict_reverse_lookup(
                                                               &token, action[i]->seg, itaglist[k])) {
                             sprintf(tmp_out, "\t\titag num %lu"
                                     ": No entry found for itag %lu",
                                     (unsigned long) k,
                                     (unsigned long) itaglist[k]);
                         } else {
                             sprintf(tmp_out, "\t\titag num %lu: itag %lu\tToken: %s",
                                     (unsigned long) k,
                                     (unsigned long) itaglist[k], token);
                             free(token);
                         }
                         orte_gpr_replica_dump_load_string(buffer, &tmp_out);
                     }
                } else {
                    sprintf(tmp_out, "\tNULL Container");
                    orte_gpr_replica_dump_load_string(buffer, &tmp_out);
                }
                if (NULL != action[i]->iptr) {
                     if (ORTE_GPR_REPLICA_ENTRY_ADDED & action[i]->action) {
                         sprintf(tmp_out, "\n\tKeyval ADDED:");
                         orte_gpr_replica_dump_load_string(buffer, &tmp_out);
                     }
                     if (ORTE_GPR_REPLICA_ENTRY_DELETED & action[i]->action) {