gpr_replica_put_get_fn.c

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

    if (ORTE_SUCCESS != (rc = orte_gpr_replica_find_containers(seg, tokmode,
                                    tokentags, num_tokens))) {
        ORTE_ERROR_LOG(rc);
        OBJ_DESTRUCT(&get_list);
        return rc;
    }

    /* if nothing found, then can return */
    if (0 == orte_gpr_replica_globals.num_srch_cptr) {
        OBJ_DESTRUCT(&get_list);
        return ORTE_SUCCESS;
    }

    /* for each container that was found, search it to find all matching keytags
     * subject to specified mode. Collect the results on get_list
     */
    cptr = (orte_gpr_replica_container_t**)((orte_gpr_replica_globals.srch_cptr)->addr);
    for (i=0, k=0; k < orte_gpr_replica_globals.num_srch_cptr &&
                   i < (orte_gpr_replica_globals.srch_cptr)->size; i++) {
        if (NULL != cptr[i]) {
            k++;
            if (ORTE_SUCCESS == orte_gpr_replica_search_container(keymode,
                                    keytags, num_keys, cptr[i]) &&
                0 < orte_gpr_replica_globals.num_srch_ival) {
                gptr = OBJ_NEW(orte_gpr_replica_get_list_t);
                gptr->cptr = cptr[i];
                iptr = (orte_gpr_replica_itagval_t**)((orte_gpr_replica_globals.srch_ival)->addr);
                for (j=0, m=0; m < orte_gpr_replica_globals.num_srch_ival &&
                               j < (orte_gpr_replica_globals.srch_ival)->size; j++) {
                    if (NULL != iptr[j]) {
                        m++;
                        ival_list = OBJ_NEW(orte_gpr_replica_ival_list_t);
                        if (NULL == ival_list) {
                            ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
                            rc = ORTE_ERR_OUT_OF_RESOURCE;
                            goto CLEANUP;
                        }
                        ival_list->itag = iptr[j]->itag;
                        ival_list->value.type = iptr[j]->value->type;
                        /* it is okay for the data to be NULL as we may not have stored a value yet
                         * or we may be dealing with an UNDEF type
                         */
                        if (NULL != iptr[j]->value->data) {
                            if (ORTE_SUCCESS != (rc = orte_dss.copy(&((ival_list->value).data), iptr[j]->value->data, iptr[j]->value->type))) {
                                ORTE_ERROR_LOG(rc);
                                OBJ_RELEASE(ival_list);
                                return rc;
                            }
                        }
                        opal_list_append(gptr->ival_list, &ival_list->item);
                    }
                }
                opal_list_append(&get_list, &gptr->item);
                (*cnt)++; /* update number of containers that had something found */
            }
        }
    }

    if (0 == *cnt) {  /* nothing found - report that */
        rc = ORTE_SUCCESS;
        goto CLEANUP;
    }

    /* if something found, convert it to array of values */
    *values = (orte_gpr_value_t**)malloc((*cnt) * sizeof(orte_gpr_value_t*));
    if (NULL == *values) {
        ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
        rc = ORTE_ERR_OUT_OF_RESOURCE;
        goto CLEANUP;
    }
    for (i=0; i < *cnt; i++) {
        gptr = (orte_gpr_replica_get_list_t*)opal_list_remove_first(&get_list);
        if (NULL == gptr) {
            ORTE_ERROR_LOG(ORTE_ERROR);
            rc = ORTE_ERROR;
            goto CLEANUP;
        }
        if (stripped) {
            if (ORTE_SUCCESS != (rc = orte_gpr_base_create_value(&((*values)[i]), addr_mode, NULL,
                                                                 (orte_std_cntr_t)opal_list_get_size(gptr->ival_list),
                                                                 0))) {
                ORTE_ERROR_LOG(rc);
                *cnt = 0;
                goto CLEANUP;
            }
        } else {
            cptr2 = gptr->cptr;
            if (ORTE_SUCCESS != (rc = orte_gpr_base_create_value(&((*values)[i]), addr_mode, seg->name,
                                                                 (orte_std_cntr_t)opal_list_get_size(gptr->ival_list),
                                                                 cptr2->num_itags))) {
                ORTE_ERROR_LOG(rc);
                *cnt = 0;
                goto CLEANUP;
            }
            for (j=0; j < cptr2->num_itags; j++) {
                if (ORTE_SUCCESS != (rc = orte_gpr_replica_dict_reverse_lookup(&((*values)[i]->tokens[j]), seg, cptr2->itags[j]))) {
                    ORTE_ERROR_LOG(rc);
                    goto CLEANUP;
                }
            }
        }
        kptr = (*values)[i]->keyvals;
        for (j=0; j < (*values)[i]->cnt; j++) {
            ival_list = (orte_gpr_replica_ival_list_t*)opal_list_remove_first(gptr->ival_list);
            if (NULL == ival_list) {
                ORTE_ERROR_LOG(ORTE_ERROR);
                rc = ORTE_ERROR;
                goto CLEANUP;
            }
            kptr[j] = OBJ_NEW(orte_gpr_keyval_t);
            if (NULL == kptr[j]) {
                ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
                rc = ORTE_ERR_OUT_OF_RESOURCE;
                goto CLEANUP;
            }
            if (ORTE_SUCCESS != (rc = orte_gpr_replica_dict_reverse_lookup(
                                        &(kptr[j]->key), seg, ival_list->itag))) {
                ORTE_ERROR_LOG(rc);
                goto CLEANUP;
            }
            kptr[j]->value = OBJ_NEW(orte_data_value_t);
            if (NULL == kptr[j]->value) {
                ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
                rc = ORTE_ERR_OUT_OF_RESOURCE;
                goto CLEANUP;
            }
            kptr[j]->value->type = ival_list->value.type;
            /* okay to have NULL data */
            if (NULL != ival_list->value.data) {
                if (ORTE_SUCCESS != (rc = orte_dss.copy(&((kptr[j]->value)->data), ival_list->value.data, ival_list->value.type))) {
                    ORTE_ERROR_LOG(rc);
                    goto CLEANUP;
                }
            }
            OBJ_RELEASE(ival_list);
        }
        OBJ_RELEASE(gptr);
    }

CLEANUP:

    while (NULL != (gptr = (orte_gpr_replica_get_list_t*)opal_list_remove_first(&get_list))) {
        OBJ_RELEASE(gptr);
    }
    OBJ_DESTRUCT(&get_list);

    if (orte_gpr_replica_globals.debug) {
        opal_output(0, "[%lu,%lu,%lu] gpr_replica_get: finished search",
                    ORTE_NAME_ARGS(orte_process_info.my_name));
    }

    return rc;
}


int orte_gpr_replica_get_conditional_fn(orte_gpr_addr_mode_t addr_mode,
                            orte_gpr_replica_segment_t *seg,
                            orte_gpr_replica_itag_t *tokentags, orte_std_cntr_t num_tokens,
                            orte_gpr_replica_itag_t *keytags, orte_std_cntr_t num_keys,
                            orte_std_cntr_t num_conditions, orte_gpr_replica_itagval_t **conditions,
                            orte_std_cntr_t *cnt, orte_gpr_value_t ***values)
{
    opal_list_t get_list;
    orte_gpr_replica_get_list_t *gptr;
    orte_gpr_replica_ival_list_t *ival_list;
    orte_gpr_replica_container_t **cptr, *cptr2;
    orte_gpr_replica_itagval_t **iptr;
    orte_gpr_keyval_t **kptr;
    orte_gpr_replica_addr_mode_t tokmode, keymode;
    int rc;
    orte_std_cntr_t i, j, k, m, n;
    bool stripped;

    OPAL_TRACE(2);

    /* initialize the list of findings */
    OBJ_CONSTRUCT(&get_list, opal_list_t);
    *cnt = 0;
    *values = NULL;

    tokmode = ORTE_GPR_REPLICA_TOKMODE(addr_mode);
    if (0x00 == tokmode) {  /* default token addressing mode to AND */
        tokmode = ORTE_GPR_REPLICA_AND;
    }
    keymode = ORTE_GPR_REPLICA_KEYMODE(addr_mode);
    if (0x00 == keymode) {  /* default key addressing mode to OR */
        keymode = ORTE_GPR_REPLICA_OR;
    }
    if (ORTE_GPR_REPLICA_STRIPPED(addr_mode)) {
        stripped = true;
    } else {
        stripped = false;
    }

    /* find all containers that meet search criteria for tokens */
    if (ORTE_SUCCESS != (rc = orte_gpr_replica_find_containers(seg, tokmode,
                                    tokentags, num_tokens))) {
        ORTE_ERROR_LOG(rc);
        OBJ_DESTRUCT(&get_list);
        return rc;
    }

    /* if nothing found, then can return */
    if (0 == orte_gpr_replica_globals.num_srch_cptr) {
        OBJ_DESTRUCT(&get_list);
        return ORTE_SUCCESS;
    }

    /* for each container that was found, search it to find all matching keytags
     * subject to specified mode and conditions. Collect the results on get_list
     */
    cptr = (orte_gpr_replica_container_t**)((orte_gpr_replica_globals.srch_cptr)->addr);
    for (i=0, k=0; k < orte_gpr_replica_globals.num_srch_cptr &&
                   i < (orte_gpr_replica_globals.srch_cptr)->size; i++) {
        if (NULL != cptr[i]) {
            /* see if the conditions are met within this container */
            for (n=0; n < num_conditions; n++) {
                if (!orte_gpr_replica_value_in_container(cptr[i], conditions[n])) { /* condition not met */
                    goto MOVEON;
                }
            }
            /* all conditions must have been met - check for requested keys & return them */
            if (ORTE_SUCCESS == orte_gpr_replica_search_container(keymode,
                                    keytags, num_keys, cptr[i]) &&
                0 < orte_gpr_replica_globals.num_srch_ival) {
                gptr = OBJ_NEW(orte_gpr_replica_get_list_t);
                gptr->cptr = cptr[i];
                iptr = (orte_gpr_replica_itagval_t**)((orte_gpr_replica_globals.srch_ival)->addr);
                for (j=0, m=0; m < orte_gpr_replica_globals.num_srch_ival &&
                               j < (orte_gpr_replica_globals.srch_ival)->size; j++) {
                    if (NULL != iptr[j]) {
                        m++;
                        ival_list = OBJ_NEW(orte_gpr_replica_ival_list_t);
                        if (NULL == ival_list) {
                            ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
                            rc = ORTE_ERR_OUT_OF_RESOURCE;
                            goto CLEANUP;
                        }
                        ival_list->itag = iptr[j]->itag;
                        ival_list->value.type = iptr[j]->value->type;
                        /* it is okay to have NULL data */
                        if (NULL != iptr[j]->value->data) {
                            if (ORTE_SUCCESS != (rc = orte_dss.copy(&((ival_list->value).data), iptr[j]->value->data, iptr[j]->value->type))) {
                                ORTE_ERROR_LOG(rc);
                                OBJ_RELEASE(ival_list);
                                return rc;
                            }
                        }
                        opal_list_append(gptr->ival_list, &ival_list->item);
                    }
                }
                opal_list_append(&get_list, &gptr->item);
                (*cnt)++; /* update number of containers that had something found */
            }
MOVEON:
            k++;
        }
    }

    if (0 == *cnt) {  /* nothing found - report that */
        rc = ORTE_SUCCESS;
        goto CLEANUP;
    }

    /* if something found, convert it to array of values */
    *values = (orte_gpr_value_t**)malloc((*cnt) * sizeof(orte_gpr_value_t*));
    if (NULL == *values) {
        ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
        rc = ORTE_ERR_OUT_OF_RESOURCE;
        goto CLEANUP;
    }
    for (i=0; i < *cnt; i++) {
        gptr = (orte_gpr_replica_get_list_t*)opal_list_remove_first(&get_list);
        if (NULL == gptr) {
            ORTE_ERROR_LOG(ORTE_ERROR);
            rc = ORTE_ERROR;
            goto CLEANUP;
        }
        if (stripped) {
            if (ORTE_SUCCESS != (rc = orte_gpr_base_create_value(&((*values)[i]), addr_mode, NULL,
                                                                 (orte_std_cntr_t)opal_list_get_size(gptr->ival_list),
                                                                 0))) {
                ORTE_ERROR_LOG(rc);
                *cnt = 0;
                goto CLEANUP;
            }
        } else {
            cptr2 = gptr->cptr;
            if (ORTE_SUCCESS != (rc = orte_gpr_base_create_value(&((*values)[i]), addr_mode, seg->name,
                                                                 (orte_std_cntr_t)opal_list_get_size(gptr->ival_list),
                                                                 cptr2->num_itags))) {
                ORTE_ERROR_LOG(rc);
                *cnt = 0;
                goto CLEANUP;
            }
            for (j=0; j < cptr2->num_itags; j++) {
                if (ORTE_SUCCESS != (rc = orte_gpr_replica_dict_reverse_lookup(&((*values)[i]->tokens[j]), seg, cptr2->itags[j]))) {
                    ORTE_ERROR_LOG(rc);
                    goto CLEANUP;
                }
            }
        }
        kptr = (*values)[i]->keyvals;
        for (j=0; j < (*values)[i]->cnt; j++) {
            ival_list = (orte_gpr_replica_ival_list_t*)opal_list_remove_first(gptr->ival_list);
            if (NULL == ival_list) {
                ORTE_ERROR_LOG(ORTE_ERROR);
                rc = ORTE_ERROR;
                goto CLEANUP;
            }
            kptr[j] = OBJ_NEW(orte_gpr_keyval_t);
            if (NULL == kptr[j]) {
                ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
                rc = ORTE_ERR_OUT_OF_RESOURCE;
                goto CLEANUP;
            }
            if (ORTE_SUCCESS != (rc = orte_gpr_replica_dict_reverse_lookup(
                                        &(kptr[j]->key), seg, ival_list->itag))) {
                ORTE_ERROR_LOG(rc);
                goto CLEANUP;
            }
            kptr[j]->value = OBJ_NEW(orte_data_value_t);
            if (NULL == kptr[j]->value) {
                ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
                rc = ORTE_ERR_OUT_OF_RESOURCE;
                goto CLEANUP;
            }
            kptr[j]->value->type = ival_list->value.type;
            /* okay to have NULL data */
            if (NULL != ival_list->value.data) {
                if (ORTE_SUCCESS != (rc = orte_dss.copy(&((kptr[j]->value)->data), ival_list->value.data, ival_list->value.type))) {
                    ORTE_ERROR_LOG(rc);
                    goto CLEANUP;
                }
            }
            OBJ_RELEASE(ival_list);
        }
        OBJ_RELEASE(gptr);
    }

CLEANUP:

    while (NULL != (gptr = (orte_gpr_replica_get_list_t*)opal_list_remove_first(&get_list))) {
        OBJ_RELEASE(gptr);
    }
    OBJ_DESTRUCT(&get_list);

    if (orte_gpr_replica_globals.debug) {
        opal_output(0, "[%lu,%lu,%lu] gpr_replica_get: finished search",
                    ORTE_NAME_ARGS(orte_process_info.my_name));
    }

    return rc;
}


int orte_gpr_replica_get_nb_fn(orte_gpr_addr_mode_t addr_mode,
                                orte_gpr_replica_segment_t *seg,
                                orte_gpr_replica_itag_t *tokentags, orte_std_cntr_t num_tokens,
                                orte_gpr_replica_itag_t *keytags, orte_std_cntr_t num_keys,
                                orte_gpr_notify_cb_fn_t cbfunc, void *user_tag)
{
    OPAL_TRACE(2);

    return ORTE_ERR_NOT_IMPLEMENTED;
}