gpr_replica_dump_fn.c

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

    if (sub->cleanup) {
        sprintf(tmp_out, "\tSubscription scheduled for cleanup");
    } else {
        sprintf(tmp_out, "\tSubscription NOT scheduled for cleanup");
    }
    orte_gpr_replica_dump_load_string(buffer, &tmp);

    /* output recipient info */
    sprintf(tmp_out, "\tList of requestors for this subscription:");
    orte_gpr_replica_dump_load_string(buffer, &tmp);
    reqs = (orte_gpr_replica_requestor_t**)(sub->requestors)->addr;
    for (j=0, k=0; k < sub->num_requestors &&
                   j < (sub->requestors)->size; j++) {
        if (NULL != reqs[j]) {
            k++;
            if (NULL == reqs[j]->requestor) {
                sprintf(tmp_out, "\t\tRequestor: LOCAL @ subscription id %lu",
                        (unsigned long) reqs[j]->idtag);
            } else {
                sprintf(tmp_out, "\t\tRequestor: [%lu,%lu,%lu] @ subscription id %lu",
                        ORTE_NAME_ARGS(reqs[j]->requestor),
                        (unsigned long) reqs[j]->idtag);
            }
            orte_gpr_replica_dump_load_string(buffer, &tmp_out);
        }
    }

    sprintf(tmp_out, "\tActions:");
    orte_gpr_replica_dump_load_string(buffer, &tmp_out);
    if (ORTE_GPR_NOTIFY_VALUE_CHG & sub->action) {
        sprintf(tmp_out, "\t\tORTE_GPR_NOTIFY_VALUE_CHG");
        orte_gpr_replica_dump_load_string(buffer, &tmp_out);
    } else if (ORTE_GPR_NOTIFY_VALUE_CHG_TO & sub->action) {
        sprintf(tmp_out, "\t\tORTE_GPR_NOTIFY_VALUE_CHG_TO");
        orte_gpr_replica_dump_load_string(buffer, &tmp_out);
    } else if (ORTE_GPR_NOTIFY_VALUE_CHG_FRM & sub->action) {
        sprintf(tmp_out, "\t\tORTE_GPR_NOTIFY_VALUE_CHG_FRM");
        orte_gpr_replica_dump_load_string(buffer, &tmp_out);
    }
    if (ORTE_GPR_NOTIFY_DEL_ENTRY & sub->action) {
        sprintf(tmp_out, "\t\tORTE_GPR_NOTIFY_DEL_ENTRY");
        orte_gpr_replica_dump_load_string(buffer, &tmp_out);
    }
    if (ORTE_GPR_NOTIFY_ADD_ENTRY & sub->action) {
        sprintf(tmp_out, "\t\tORTE_GPR_NOTIFY_ADD_ENTRY");
        orte_gpr_replica_dump_load_string(buffer, &tmp_out);
    }
    if (ORTE_GPR_NOTIFY_PRE_EXISTING & sub->action) {
        sprintf(tmp_out, "\t\tORTE_GPR_NOTIFY_PRE_EXISTING");
        orte_gpr_replica_dump_load_string(buffer, &tmp_out);
    }
    if (ORTE_GPR_NOTIFY_STARTS_AFTER_TRIG & sub->action) {
        sprintf(tmp_out, "\t\tORTE_GPR_NOTIFY_STARTS_AFTER_TRIG");
        orte_gpr_replica_dump_load_string(buffer, &tmp_out);
    }
    if (ORTE_GPR_NOTIFY_DELETE_AFTER_TRIG & sub->action) {
        sprintf(tmp_out, "\t\tORTE_GPR_NOTIFY_DELETE_AFTER_TRIG");
        orte_gpr_replica_dump_load_string(buffer, &tmp_out);
    }

    sprintf(tmp_out, "\n\tData covered by this subscription");
    orte_gpr_replica_dump_load_string(buffer, &tmp_out);

    ivals = (orte_gpr_replica_ivalue_t**)(sub->values)->addr;
    for (n=0, p=0; p < sub->num_values &&
                   n < (sub->values)->size; n++) {
        if (NULL != ivals[n]) {
            p++;
            sprintf(tmp_out, "\t\tData on segment %s", (ivals[n]->seg)->name);
            orte_gpr_replica_dump_load_string(buffer, &tmp_out);

            k = (int)orte_value_array_get_size(&(ivals[n]->tokentags));
            if (0 == k) {
                sprintf(tmp_out, "\t\tNULL token (wildcard)");
                orte_gpr_replica_dump_load_string(buffer, &tmp_out);
            } else {
                sprintf(tmp_out, "\t\tNumber of tokens: %lu",
                        (unsigned long) k);
                orte_gpr_replica_dump_load_string(buffer, &tmp_out);

                for (j=0; j < k; j++) {
                    if (ORTE_SUCCESS == orte_gpr_replica_dict_reverse_lookup(&token, ivals[n]->seg,
                            ORTE_VALUE_ARRAY_GET_ITEM(&(ivals[n]->tokentags), orte_gpr_replica_itag_t, j))) {
                        sprintf(tmp_out, "\t\t\tToken: %s", token);
                           orte_gpr_replica_dump_load_string(buffer, &tmp_out);
                        free(token);
                    }
                   }
            }

            sprintf(tmp_out, "\t\tToken addressing mode:\n");
            orte_gpr_replica_dump_load_string(buffer, &tmp_out);

            if (ORTE_GPR_TOKENS_NOT & ivals[n]->addr_mode) {
                sprintf(tmp_out, "\t\t\tORTE_GPR_TOKENS_NOT\n");
                orte_gpr_replica_dump_load_string(buffer, &tmp_out);
            }
            if (ORTE_GPR_TOKENS_AND & ivals[n]->addr_mode) {
                sprintf(tmp_out, "\t\t\tORTE_GPR_TOKENS_AND\n");
                orte_gpr_replica_dump_load_string(buffer, &tmp_out);
            }
            if (ORTE_GPR_TOKENS_OR & ivals[n]->addr_mode) {
                sprintf(tmp_out, "\t\t\tORTE_GPR_TOKENS_OR\n");
                orte_gpr_replica_dump_load_string(buffer, &tmp_out);
            }
            if (ORTE_GPR_TOKENS_XAND & ivals[n]->addr_mode) {
                sprintf(tmp_out, "\t\t\tORTE_GPR_TOKENS_XAND\n");
                orte_gpr_replica_dump_load_string(buffer, &tmp_out);
            }
            if (ORTE_GPR_TOKENS_XOR & ivals[n]->addr_mode) {
                sprintf(tmp_out, "\t\t\tORTE_GPR_TOKENS_XOR\n");
                orte_gpr_replica_dump_load_string(buffer, &tmp_out);
            }

            k = (int)orte_value_array_get_size(&(ivals[n]->keytags));
            if (0 == k) {
                sprintf(tmp_out, "\t\tNULL key (wildcard)");
                orte_gpr_replica_dump_load_string(buffer, &tmp_out);
            } else {
                sprintf(tmp_out, "\t\tNumber of keys: %lu", (unsigned long) k);
                orte_gpr_replica_dump_load_string(buffer, &tmp_out);

                for (j=0; j < k; j++) {
                    if (ORTE_SUCCESS == orte_gpr_replica_dict_reverse_lookup(&token, ivals[n]->seg,
                            ORTE_VALUE_ARRAY_GET_ITEM(&(ivals[n]->keytags), orte_gpr_replica_itag_t, j))) {
                        sprintf(tmp_out, "\t\t\tKey: %s", token);
                        orte_gpr_replica_dump_load_string(buffer, &tmp_out);
                        free(token);
                    }
                }
            }

            sprintf(tmp_out, "\t\tKey addressing mode:\n");
            orte_gpr_replica_dump_load_string(buffer, &tmp_out);

            if (ORTE_GPR_KEYS_NOT & ivals[n]->addr_mode) {
                sprintf(tmp_out, "\t\t\tORTE_GPR_KEYS_NOT\n");
                orte_gpr_replica_dump_load_string(buffer, &tmp_out);
            }
            if (ORTE_GPR_KEYS_AND & ivals[n]->addr_mode) {
                sprintf(tmp_out, "\t\t\tORTE_GPR_KEYS_AND\n");
                orte_gpr_replica_dump_load_string(buffer, &tmp_out);
            }
            if (ORTE_GPR_KEYS_OR & ivals[n]->addr_mode) {
                sprintf(tmp_out, "\t\t\tORTE_GPR_KEYS_OR\n");
                orte_gpr_replica_dump_load_string(buffer, &tmp_out);
            }
            if (ORTE_GPR_KEYS_XAND & ivals[n]->addr_mode) {
                sprintf(tmp_out, "\t\t\tORTE_GPR_KEYS_XAND\n");
                orte_gpr_replica_dump_load_string(buffer, &tmp_out);
            }
            if (ORTE_GPR_KEYS_XOR & ivals[n]->addr_mode) {
                sprintf(tmp_out, "\t\t\tORTE_GPR_KEYS_XOR\n");
                orte_gpr_replica_dump_load_string(buffer, &tmp_out);
            }
        } /* if ivals[n] not NULL */
    } /* for n */

    free(tmp_out);
    return ORTE_SUCCESS;
}


void orte_gpr_replica_dump_itagval_value(orte_buffer_t *buffer,
                                         orte_gpr_replica_itagval_t *iptr)
{
    char *tmp;
    int rc;

    if (ORTE_SUCCESS != (rc = orte_dss.print(&tmp, "\t\t\t", iptr->value, ORTE_DATA_VALUE))) {
        ORTE_ERROR_LOG(rc);
        return;
    }

    if (NULL == buffer) {
        opal_output(0, "%s", tmp);
    } else {
        orte_gpr_replica_dump_load_string(buffer, &tmp);
    }

    free(tmp);
}


int orte_gpr_replica_dump_segment_size_fn(orte_buffer_t *buffer, char *segment)
{
    orte_gpr_replica_segment_t **seg, *segptr;
    orte_std_cntr_t i, m;
    size_t segsize, total;
    char tmp[100], *tptr;
    int rc;

    tptr = tmp;

    /* if segment = NULL, loop through all segments */
    if (NULL == segment) {
        seg = (orte_gpr_replica_segment_t**)(orte_gpr_replica.segments)->addr;
        total = 0;
        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_get_segment_size_fn(&segsize, seg[i]))) {
                     ORTE_ERROR_LOG(rc);
                     return rc;
                 }
                 total += segsize;
             }
         }
         sprintf(tmp, "Total registry size: %lu bytes", (unsigned long)total);
         orte_gpr_replica_dump_load_string(buffer, &tptr);

         return ORTE_SUCCESS;
    }

    /* otherwise, get the size of 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_get_segment_size_fn(&segsize, segptr))) {
        ORTE_ERROR_LOG(rc);
        return rc;
    }
    sprintf(tmp, "Size of segment %s: %lu bytes", segment, (unsigned long)segsize);
    orte_gpr_replica_dump_load_string(buffer, &tptr);

    return ORTE_SUCCESS;
}


static void orte_gpr_replica_dump_load_string(orte_buffer_t *buffer, char **tmp)
{
    orte_dss.pack(buffer, tmp, 1, ORTE_STRING);
}

static int orte_gpr_replica_get_segment_size_fn(size_t *segsize, orte_gpr_replica_segment_t *seg)
{
    size_t data_size, isize;
    orte_std_cntr_t i, j, k, m;
    char **dict;
    orte_gpr_replica_container_t **cptr;
    orte_gpr_replica_itagval_t **iptr;
    int rc;

    data_size = strlen(seg->name);
    data_size += 2*sizeof(orte_gpr_replica_itag_t); /* itag, num_dict_entries */

    data_size += (seg->dict)->size * sizeof(void*);  /* account for size of pointer array */
    dict = (char**)(seg->dict)->addr;
    for (i=0, j=0; j < seg->num_dict_entries &&
         i < (seg->dict)->size; i++) {
             if (NULL != dict[i]) {
                 j++;
                 data_size += strlen(dict[i]) + 1;
             }
         }

         data_size += sizeof(orte_std_cntr_t);  /* num_containers */
         cptr = (orte_gpr_replica_container_t**)(seg->containers)->addr;
         for (i=0, j=0; j < (seg->num_containers) &&
              i < (seg->containers)->size; i++) {
                  if (NULL != cptr[i]) {
                      j++;
                      data_size += sizeof(orte_std_cntr_t);  /* index */
                      data_size += cptr[i]->num_itags * sizeof(orte_gpr_replica_itag_t);  /* itags array */
                      data_size += sizeof(orte_std_cntr_t);  /* num_itags */
                      data_size += (cptr[i]->itagvals)->size * sizeof(void*);  /* account for size of pointer array */
                      data_size += sizeof(orte_std_cntr_t);  /* num_itagvals */
                      iptr = (orte_gpr_replica_itagval_t**)(cptr[i]->itagvals)->addr;
                      for (k=0, m=0; m < cptr[i]->num_itagvals &&
                           k < (cptr[i]->itagvals)->size; k++) {
                               if (NULL != iptr[k]) {
                                   m++;
                                   data_size += sizeof(orte_std_cntr_t);  /* index */
                                   data_size += sizeof(orte_gpr_replica_itag_t);
                                   data_size += sizeof(orte_data_type_t);
                                   if (ORTE_SUCCESS != (rc = orte_dss.size(&isize, iptr[k]->value->data, iptr[k]->value->type))) {
                                       ORTE_ERROR_LOG(rc);
                                       *segsize = 0;
                                       return rc;
                                   }
                                   data_size += isize;
                               }
                           }
                           data_size += 3*sizeof(orte_std_cntr_t);
                           data_size += (cptr[i]->itaglist).array_size * sizeof(unsigned char*);
                  }
              }

              *segsize = data_size;
              return ORTE_SUCCESS;
}