mercury_proc.h

Go to the documentation of this file.

/*
 * Copyright (C) 2013 Argonne National Laboratory, Department of Energy,
 *                    UChicago Argonne, LLC and The HDF Group.
 * All rights reserved.
 *
 * The full copyright notice, including terms governing use, modification,
 * and redistribution, is contained in the COPYING file that can be
 * found at the root of the source code distribution tree.
 */

#ifndef MERCURY_PROC_H
#define MERCURY_PROC_H

#include "mercury_types.h"
#include "mercury_error.h"
#include "mercury_bulk.h"

#include <stdlib.h>
#include <string.h>
#ifdef HG_HAS_XDR
#include <rpc/types.h>
#include <rpc/xdr.h>
#    ifdef __APPLE__
#        define xdr_int8_t   xdr_char
#        define xdr_uint8_t  xdr_u_char
#        define xdr_uint16_t xdr_u_int16_t
#        define xdr_uint32_t xdr_u_int32_t
#        define xdr_uint64_t xdr_u_int64_t
#    endif
#endif

#ifndef HG_PROC_INLINE
  #if defined(__GNUC__) && !defined(__GNUC_STDC_INLINE__)
    #define HG_PROC_INLINE extern HG_INLINE
  #else
    #define HG_PROC_INLINE HG_INLINE
  #endif
#endif

#ifdef __cplusplus
extern "C" {
#endif

HG_EXPORT void *
hg_proc_buf_alloc(size_t size);

HG_EXPORT hg_return_t
hg_proc_buf_free(void *mem_ptr);

HG_EXPORT hg_return_t
hg_proc_create(void *buf, size_t buf_size, hg_proc_op_t op, hg_proc_hash_t hash,
        hg_proc_t *proc);

HG_EXPORT hg_return_t
hg_proc_free(hg_proc_t proc);

HG_EXPORT hg_proc_op_t
hg_proc_get_op(hg_proc_t proc);

HG_EXPORT size_t
hg_proc_get_size(hg_proc_t proc);

HG_EXPORT hg_return_t
hg_proc_set_size(hg_proc_t proc, size_t buf_size);

HG_EXPORT size_t
hg_proc_get_size_left(hg_proc_t proc);

HG_EXPORT void *
hg_proc_get_buf_ptr(hg_proc_t proc);

#ifdef HG_HAS_XDR

HG_EXPORT XDR *
hg_proc_get_xdr_ptr(hg_proc_t proc);
#endif

HG_EXPORT hg_return_t
hg_proc_set_buf_ptr(hg_proc_t proc, void *buf_ptr);

HG_EXPORT void *
hg_proc_get_extra_buf(hg_proc_t proc);

HG_EXPORT size_t
hg_proc_get_extra_size(hg_proc_t proc);

HG_EXPORT hg_return_t
hg_proc_set_extra_buf_is_mine(hg_proc_t proc, hg_bool_t mine);

HG_EXPORT hg_return_t
hg_proc_flush(hg_proc_t proc);

HG_EXPORT hg_return_t
hg_proc_memcpy(hg_proc_t proc, void *data, size_t data_size);

static HG_INLINE void *
hg_proc_buf_memcpy(void *buf, void *data, size_t data_size, hg_proc_op_t op)
{
    const void *src = NULL;
    void *dest = NULL;

    if ((op != HG_ENCODE) && (op != HG_DECODE)) return NULL;
    src = (op == HG_ENCODE) ? (const void *) data : (const void *) buf;
    dest = (op == HG_ENCODE) ? buf : data;
    memcpy(dest, src, data_size);

    return ((char *) buf + data_size);
}

HG_EXPORT HG_PROC_INLINE hg_return_t hg_proc_hg_int8_t(hg_proc_t proc,
        hg_int8_t *data);
HG_EXPORT HG_PROC_INLINE hg_return_t hg_proc_hg_uint8_t(hg_proc_t proc,
        hg_uint8_t *data);
HG_EXPORT HG_PROC_INLINE hg_return_t hg_proc_hg_int16_t(hg_proc_t proc,
        hg_int16_t *data);
HG_EXPORT HG_PROC_INLINE hg_return_t hg_proc_hg_uint16_t(hg_proc_t proc,
        hg_uint16_t *data);
HG_EXPORT HG_PROC_INLINE hg_return_t hg_proc_hg_int32_t(hg_proc_t proc,
        hg_int32_t *data);
HG_EXPORT HG_PROC_INLINE hg_return_t hg_proc_hg_uint32_t(hg_proc_t proc,
        hg_uint32_t *data);
HG_EXPORT HG_PROC_INLINE hg_return_t hg_proc_hg_int64_t(hg_proc_t proc,
        hg_int64_t *data);
HG_EXPORT HG_PROC_INLINE hg_return_t hg_proc_hg_uint64_t(hg_proc_t proc,
        hg_uint64_t *data);
HG_EXPORT HG_PROC_INLINE hg_return_t hg_proc_raw(hg_proc_t proc, void *buf,
        size_t buf_size);
HG_EXPORT HG_PROC_INLINE hg_return_t hg_proc_hg_bulk_t(hg_proc_t proc,
        hg_bulk_t *handle);


/* Note: float types are not supported but can be built on top of the existing
 * proc routines; encoding floats using XDR could modify checksum */

#define hg_proc_int8_t   hg_proc_hg_int8_t
#define hg_proc_uint8_t  hg_proc_hg_uint8_t
#define hg_proc_int16_t  hg_proc_hg_int16_t
#define hg_proc_uint16_t hg_proc_hg_uint16_t
#define hg_proc_int32_t  hg_proc_hg_int32_t
#define hg_proc_uint32_t hg_proc_hg_uint32_t
#define hg_proc_int64_t  hg_proc_hg_int64_t
#define hg_proc_uint64_t hg_proc_hg_uint64_t

/* Map mercury common types */
#define hg_proc_hg_bool_t     hg_proc_hg_uint8_t
#define hg_proc_hg_ptr_t      hg_proc_hg_uint64_t
#define hg_proc_hg_id_t       hg_proc_hg_uint32_t

HG_PROC_INLINE hg_return_t
hg_proc_hg_int8_t(hg_proc_t proc, hg_int8_t *data)
{
    hg_return_t ret = HG_FAIL;
#ifdef HG_HAS_XDR
    ret = xdr_int8_t(hg_proc_get_xdr_ptr(proc), data) ? HG_SUCCESS : HG_FAIL;
#else
    ret = hg_proc_memcpy(proc, data, sizeof(hg_int8_t));
#endif
    return ret;
}

HG_PROC_INLINE hg_return_t
hg_proc_hg_uint8_t(hg_proc_t proc, hg_uint8_t *data)
{
    hg_return_t ret = HG_FAIL;
#ifdef HG_HAS_XDR
    ret = xdr_uint8_t(hg_proc_get_xdr_ptr(proc), data) ? HG_SUCCESS : HG_FAIL;
#else
    ret = hg_proc_memcpy(proc, data, sizeof(hg_uint8_t));
#endif
    return ret;
}

HG_PROC_INLINE hg_return_t
hg_proc_hg_int16_t(hg_proc_t proc, hg_int16_t *data)
{
    hg_return_t ret = HG_FAIL;
#ifdef HG_HAS_XDR
    ret = xdr_int16_t(hg_proc_get_xdr_ptr(proc), data) ? HG_SUCCESS : HG_FAIL;
#else
    ret = hg_proc_memcpy(proc, data, sizeof(hg_int16_t));
#endif
    return ret;
}

HG_PROC_INLINE hg_return_t
hg_proc_hg_uint16_t(hg_proc_t proc, hg_uint16_t *data)
{
    hg_return_t ret = HG_FAIL;
#ifdef HG_HAS_XDR
    ret = xdr_uint16_t(hg_proc_get_xdr_ptr(proc), data) ? HG_SUCCESS : HG_FAIL;
#else
    ret = hg_proc_memcpy(proc, data, sizeof(hg_uint16_t));
#endif
    return ret;
}

HG_PROC_INLINE hg_return_t
hg_proc_hg_int32_t(hg_proc_t proc, hg_int32_t *data)
{
    hg_return_t ret = HG_FAIL;
#ifdef HG_HAS_XDR
    ret = xdr_int32_t(hg_proc_get_xdr_ptr(proc), data) ? HG_SUCCESS : HG_FAIL;
#else
    ret = hg_proc_memcpy(proc, data, sizeof(hg_int32_t));
#endif
    return ret;
}

HG_PROC_INLINE hg_return_t
hg_proc_hg_uint32_t(hg_proc_t proc, hg_uint32_t *data)
{
    hg_return_t ret = HG_FAIL;
#ifdef HG_HAS_XDR
    ret = xdr_uint32_t(hg_proc_get_xdr_ptr(proc), data) ? HG_SUCCESS : HG_FAIL;
#else
    ret = hg_proc_memcpy(proc, data, sizeof(hg_uint32_t));
#endif
    return ret;
}

HG_PROC_INLINE hg_return_t
hg_proc_hg_int64_t(hg_proc_t proc, hg_int64_t *data)
{
    hg_return_t ret = HG_FAIL;
#ifdef HG_HAS_XDR
    ret = xdr_int64_t(hg_proc_get_xdr_ptr(proc), data) ? HG_SUCCESS : HG_FAIL;
#else
    ret = hg_proc_memcpy(proc, data, sizeof(hg_int64_t));
#endif
    return ret;
}

HG_PROC_INLINE hg_return_t
hg_proc_hg_uint64_t(hg_proc_t proc, hg_uint64_t *data)
{
    hg_return_t ret = HG_FAIL;
#ifdef HG_HAS_XDR
    ret = xdr_uint64_t(hg_proc_get_xdr_ptr(proc), data) ? HG_SUCCESS : HG_FAIL;
#else
    ret = hg_proc_memcpy(proc, data, sizeof(hg_uint64_t));
#endif
    return ret;
}

HG_PROC_INLINE hg_return_t
hg_proc_raw(hg_proc_t proc, void *buf, size_t buf_size)
{
    hg_uint8_t *buf_ptr;
    hg_uint8_t *buf_ptr_lim = (hg_uint8_t*) buf + buf_size;
    hg_return_t ret = HG_FAIL;

    for (buf_ptr = (hg_uint8_t*) buf; buf_ptr < buf_ptr_lim; buf_ptr++) {
        ret = hg_proc_uint8_t(proc, buf_ptr);
        if (ret != HG_SUCCESS) {
            HG_ERROR_DEFAULT("Proc error");
            break;
        }
    }

    return ret;
}

HG_PROC_INLINE hg_return_t
hg_proc_hg_bulk_t(hg_proc_t proc, hg_bulk_t *handle)
{
    hg_return_t ret = HG_FAIL;
    void *buf = NULL;
    hg_uint64_t buf_size = 0;

    switch (hg_proc_get_op(proc)) {
        case HG_ENCODE:
            if (*handle != HG_BULK_NULL) {
                buf_size = HG_Bulk_handle_get_serialize_size(*handle);
                buf = malloc(buf_size);
                ret = HG_Bulk_handle_serialize(buf, buf_size, *handle);
                if (ret != HG_SUCCESS) {
                    HG_ERROR_DEFAULT("Could not serialize bulk handle");
                    ret = HG_FAIL;
                    return ret;
                }
            } else {
                /* If HG_BULK_NULL set 0 to buf_size */
                buf_size = 0;
            }
            /* Encode size */
            ret = hg_proc_uint64_t(proc, &buf_size);
            if (ret != HG_SUCCESS) {
                HG_ERROR_DEFAULT("Proc error");
                ret = HG_FAIL;
                return ret;
            }
            if (buf_size) {
                /* Encode serialized buffer */
                ret = hg_proc_raw(proc, buf, buf_size);
                if (ret != HG_SUCCESS) {
                    HG_ERROR_DEFAULT("Proc error");
                    ret = HG_FAIL;
                    return ret;
                }
                free(buf);
                buf = NULL;
            }
            break;
        case HG_DECODE:
            /* Decode size */
            ret = hg_proc_uint64_t(proc, &buf_size);
            if (ret != HG_SUCCESS) {
                HG_ERROR_DEFAULT("Proc error");
                ret = HG_FAIL;
                return ret;
            }
            if (buf_size) {
                buf = malloc(buf_size);
                /* Decode serialized buffer */
                ret = hg_proc_raw(proc, buf, buf_size);
                if (ret != HG_SUCCESS) {
                    HG_ERROR_DEFAULT("Proc error");
                    ret = HG_FAIL;
                    return ret;
                }
                ret = HG_Bulk_handle_deserialize(handle, buf, buf_size);
                if (ret != HG_SUCCESS) {
                    HG_ERROR_DEFAULT("Could not deserialize bulk handle");
                    ret = HG_FAIL;
                    return ret;
                }
                free(buf);
                buf = NULL;
            } else {
                /* If buf_size is 0, define handle to HG_BULK_NULL */
                *handle = HG_BULK_NULL;
            }
            break;
        case HG_FREE:
            if (*handle != HG_BULK_NULL) {
                ret = HG_Bulk_handle_free(*handle);
                if (ret != HG_SUCCESS) {
                    HG_ERROR_DEFAULT("Could not free bulk handle");
                    ret = HG_FAIL;
                    return ret;
                }
                *handle = HG_BULK_NULL;
            } else {
                /* If *handle is HG_BULK_NULL, just return success */
                ret = HG_SUCCESS;
            }
            break;
        default:
            break;
    }
    return ret;
}

#ifdef __cplusplus
}
#endif

#endif /* MERCURY_PROC_H */