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 */