gpr_replica_dump_fn.c

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

                         sprintf(tmp_out, "\n\tKeyval DELETED:");
                         orte_gpr_replica_dump_load_string(buffer, &tmp_out);
                     }
                     if (ORTE_GPR_REPLICA_ENTRY_CHANGED & action[i]->action) {
                         sprintf(tmp_out, "\n\tKeyval CHANGED");
                         orte_gpr_replica_dump_load_string(buffer, &tmp_out);
                     }
                     if (ORTE_GPR_REPLICA_ENTRY_CHG_TO & action[i]->action) {
                         sprintf(tmp_out, "\t\tKeyval CHANGED TO:");
                         orte_gpr_replica_dump_load_string(buffer, &tmp_out);
                     }
                     if (ORTE_GPR_REPLICA_ENTRY_CHG_FRM & action[i]->action) {
                         sprintf(tmp_out, "\t\tKeyval CHANGED FROM:");
                         orte_gpr_replica_dump_load_string(buffer, &tmp_out);
                     }

                     if (ORTE_SUCCESS != orte_gpr_replica_dict_reverse_lookup(
                                                     &token, action[i]->seg, action[i]->iptr->itag)) {
                         sprintf(tmp_out, "\t\tNo entry found for itag %lu",
                                 (unsigned long) action[i]->iptr->itag);
                     } else {
                         sprintf(tmp_out, "\t\titag %lu\tKey: %s",
                                 (unsigned long) action[i]->iptr->itag, token);
                         free(token);
                     }
                     orte_gpr_replica_dump_load_string(buffer, &tmp_out);
                     orte_gpr_replica_dump_itagval_value(buffer, action[i]->iptr);
                 } else {
                    sprintf(tmp_out, "\tNULL Keyval");
                     orte_gpr_replica_dump_load_string(buffer, &tmp_out);
                 }
             }
        }
    } else {
        sprintf(tmp_out, "\nNO GPR ACTION RECORDS STORED\n");
        orte_gpr_replica_dump_load_string(buffer, &tmp_out);
    }

    free(tmp_out);
    return ORTE_SUCCESS;
}


int orte_gpr_replica_dump_triggers_fn(orte_buffer_t *buffer,
                                      orte_gpr_trigger_id_t start)
{
    orte_gpr_replica_trigger_t **trig;
    char tmp_out[100], *tmp;
    orte_std_cntr_t j, k, m;
    int rc;

    tmp = tmp_out;
    sprintf(tmp_out, "\nDUMP OF GPR TRIGGERS\n");
    orte_gpr_replica_dump_load_string(buffer, &tmp);

    trig = (orte_gpr_replica_trigger_t**)((orte_gpr_replica.triggers)->addr);
    sprintf(tmp_out, "Number of triggers: %lu\n", (unsigned long) orte_gpr_replica.num_trigs);
    orte_gpr_replica_dump_load_string(buffer, &tmp);

    /* dump the trigger info for the registry */
    if (0 == start) { /* dump the whole thing */
        m = 0;
    } else {
        m = orte_gpr_replica.num_trigs - start;
    }

    for (j=0, k=0; k < orte_gpr_replica.num_trigs &&
                   j < (orte_gpr_replica.triggers)->size; j++) {
        if (NULL != trig[j]) {
            if (k >= m) {
                if (ORTE_SUCCESS != (rc = orte_gpr_replica_dump_trigger(buffer, trig[j]))) {
                    ORTE_ERROR_LOG(rc);
                    return rc;
                }
            }
            k++;
        }
    }

    return ORTE_SUCCESS;
}

int orte_gpr_replica_dump_trigger(orte_buffer_t *buffer,
                                  orte_gpr_replica_trigger_t *trig)
{
    char *tmp_out, *token;
    orte_std_cntr_t i, j;
    orte_gpr_replica_counter_t **cntr;
    orte_gpr_replica_subscription_t **subs;
    orte_gpr_replica_trigger_requestor_t **attached;

    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, "\nData for trigger %lu", (unsigned long) trig->index);
    orte_gpr_replica_dump_load_string(buffer, &tmp_out);

    if (NULL == trig->name) {
        sprintf(tmp_out, "\tNOT a named trigger");
    } else {
        sprintf(tmp_out, "\ttrigger name: %s", trig->name);
    }
    orte_gpr_replica_dump_load_string(buffer, &tmp_out);

    if (0 < trig->num_attached) {
        sprintf(tmp_out, "\t%lu requestors attached to this trigger",
            (unsigned long) trig->num_attached);
    } else {
        sprintf(tmp_out, "\tNo requestors attached to this trigger");
    }
    orte_gpr_replica_dump_load_string(buffer, &tmp_out);

    attached = (orte_gpr_replica_trigger_requestor_t**)
                    (trig->attached)->addr;
    for (i=0, j=0; j < trig->num_attached &&
                   i < (trig->attached)->size; i++) {
        if (NULL != attached[i]) {
            j++;
            if (NULL == attached[i]->requestor) {
                sprintf(tmp_out, "\t\tRequestor %lu: LOCAL@idtag %lu",
                    (unsigned long)j, (unsigned long)attached[i]->idtag);
            } else {
                sprintf(tmp_out, "\t\tRequestor %lu: [%lu,%lu,%lu]@idtag %lu",
                    (unsigned long)j, ORTE_NAME_ARGS(attached[i]->requestor),
                    (unsigned long)attached[i]->idtag);
            }
            orte_gpr_replica_dump_load_string(buffer, &tmp_out);
        }
    }

    if (NULL == trig->master) {
        sprintf(tmp_out, "\tNO MASTER registered");
    } else {
        if (NULL == trig->master->requestor) {
            sprintf(tmp_out, "\tTRIGGER MASTER: LOCAL@idtag %lu",
                (unsigned long)trig->master->idtag);
        } else {
            sprintf(tmp_out, "\tTRIGGER MASTER: [%lu,%lu,%lu]@idtag %lu",
                ORTE_NAME_ARGS(trig->master->requestor),
                (unsigned long)trig->master->idtag);
        }
    }
    orte_gpr_replica_dump_load_string(buffer, &tmp_out);

    if (ORTE_GPR_TRIG_ONE_SHOT & trig->action) {
        sprintf(tmp_out, "\tORTE_GPR_TRIG_ONE_SHOT");
        orte_gpr_replica_dump_load_string(buffer, &tmp_out);
    }
    if (ORTE_GPR_TRIG_AT_LEVEL & trig->action) {
        sprintf(tmp_out, "\tORTE_GPR_TRIG_AT_LEVEL");
        orte_gpr_replica_dump_load_string(buffer, &tmp_out);
    }
    if (ORTE_GPR_TRIG_CMP_LEVELS & trig->action) {
        sprintf(tmp_out, "\tORTE_GPR_TRIG_CMP_LEVELS");
        orte_gpr_replica_dump_load_string(buffer, &tmp_out);
    }
    if (ORTE_GPR_TRIG_INCLUDE_TRIG_CNTRS & trig->action) {
        sprintf(tmp_out, "\tORTE_GPR_TRIG_INCLUDE_TRIG_CNTRS");
        orte_gpr_replica_dump_load_string(buffer, &tmp_out);
    }

    if (trig->one_shot_fired) {
        sprintf(tmp_out, "\tONE SHOT HAS FIRED");
    } else {
        sprintf(tmp_out, "\tONE SHOT HAS NOT FIRED");
    }
    orte_gpr_replica_dump_load_string(buffer, &tmp_out);

    if (0 < trig->num_counters) {
        if (ORTE_GPR_TRIG_AT_LEVEL & trig->action) {
            sprintf(tmp_out, "\tTrigger monitoring %lu counters for level",
                    (unsigned long) trig->num_counters);
        } else {
            sprintf(tmp_out, "\tTrigger monitoring %lu counters for compare",
                    (unsigned long) trig->num_counters);
        }
        orte_gpr_replica_dump_load_string(buffer, &tmp_out);
        cntr = (orte_gpr_replica_counter_t**)((trig->counters)->addr);
        for (i=0, j=0; j < trig->num_counters &&
                       i < (trig->counters)->size; i++) {
            if (NULL != cntr[i] &&
                ORTE_SUCCESS == orte_gpr_replica_dict_reverse_lookup(&token, cntr[i]->seg,
                    (cntr[i]->iptr)->itag)) {
                j++;
                sprintf(tmp_out, "\t\tCounter: %lu\tSegment: %s\tName: %s",
                        (unsigned long) i, (cntr[i]->seg)->name, token);
                free(token);
                orte_gpr_replica_dump_load_string(buffer, &tmp_out);
                if (ORTE_GPR_TRIG_AT_LEVEL & trig->action) {
                    sprintf(tmp_out, "\t\tTrigger Level:");
                    orte_gpr_replica_dump_load_string(buffer, &tmp_out);
                    orte_gpr_replica_dump_itagval_value(buffer, &(cntr[i]->trigger_level));
                }
                sprintf(tmp_out, "\t\tCurrent Value:");
                orte_gpr_replica_dump_load_string(buffer, &tmp_out);
                orte_gpr_replica_dump_itagval_value(buffer, cntr[i]->iptr);
            }
        }
    }

    if (0 < trig->num_subscriptions) {
        sprintf(tmp_out, "\tTrigger has %lu subscriptions attached to it",
                        (unsigned long) trig->num_subscriptions);
        orte_gpr_replica_dump_load_string(buffer, &tmp_out);
        subs = (orte_gpr_replica_subscription_t**)((trig->subscriptions)->addr);
        for (i=0, j=0; j < trig->num_subscriptions &&
                       i < (trig->subscriptions)->size; i++) {
            if (NULL != subs[i]) {
                j++;
                orte_gpr_replica_dump_subscription(buffer, subs[i]);
            }
        }
    }

    free(tmp_out);
    return ORTE_SUCCESS;
}

int orte_gpr_replica_dump_subscriptions_fn(orte_buffer_t *buffer,
                    orte_gpr_subscription_id_t start)
{
    char *tmp_out, *tmp;
    orte_std_cntr_t i, m, n;
    orte_gpr_replica_subscription_t **subs;
    int rc;

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

    sprintf(tmp_out, "\nDUMP OF GPR SUBSCRIPTIONS\n");
    orte_gpr_replica_dump_load_string(buffer, &tmp);

    subs = (orte_gpr_replica_subscription_t**)((orte_gpr_replica.subscriptions)->addr);
    sprintf(tmp_out, "Number of subscriptions: %lu\n", (unsigned long) orte_gpr_replica.num_subs);
    orte_gpr_replica_dump_load_string(buffer, &tmp);

    /* dump the subscription info for the registry */
    if (0 == start) {  /* dump the whole thing */
        n = 0;
    } else {
        n = orte_gpr_replica.num_subs - start;
    }

    for (i=0, m=0; m < orte_gpr_replica.num_subs &&
                   i < (orte_gpr_replica.subscriptions)->size; i++) {
        if (NULL != subs[i]) {
            if (m >= n) {
                if (ORTE_SUCCESS != (rc = orte_gpr_replica_dump_subscription(buffer, subs[i]))) {
                    ORTE_ERROR_LOG(rc);
                    return rc;
                }
            }
            m++;
        }
    }
    free(tmp_out);
    return ORTE_SUCCESS;
}

int orte_gpr_replica_dump_subscription(orte_buffer_t *buffer,
                                       orte_gpr_replica_subscription_t *sub)
{
    char *tmp_out, *token, *tmp;
    orte_std_cntr_t j, k, n, p;
    orte_gpr_replica_requestor_t **reqs;
    orte_gpr_replica_ivalue_t **ivals;

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

    if (NULL == sub->name) {
        sprintf(tmp, "\nSubscription %lu: UNNAMED idtag %lu",
            (unsigned long) sub->index, (unsigned long) sub->idtag);
    } else {
        sprintf(tmp, "\nSubscription %lu: name %s idtag %lu",
                (unsigned long) sub->index,
                sub->name, (unsigned long) sub->idtag);
    }
    orte_gpr_replica_dump_load_string(buffer, &tmp);

    if (sub->active) {
        sprintf(tmp_out, "\tSubscription ACTIVE");
    } else {
        sprintf(tmp_out, "\tSubscription INACTIVE");
    }
    orte_gpr_replica_dump_load_string(buffer, &tmp);