static HG_THREAD_RETURN_TYPE
thread_cb_cas32(void *arg)
{
hg_thread_ret_t thread_ret = (hg_thread_ret_t) 0;
hg_atomic_int32_t *atomic_int32 = (hg_atomic_int32_t *) arg;
hg_atomic_incr32(atomic_int32);
if (HG_UTIL_TRUE == hg_atomic_cas32(atomic_int32, 2, 99)) {
hg_atomic_incr32(atomic_int32);
}
hg_thread_exit(thread_ret);
return thread_ret;
}
/*---------------------------------------------------------------------------*/
static hg_return_t
hg_bulk_complete(struct hg_bulk_op_id *hg_bulk_op_id)
{
hg_context_t *context = hg_bulk_op_id->context;
hg_return_t ret = HG_SUCCESS;
/* Mark operation as completed */
hg_atomic_incr32(&hg_bulk_op_id->completed);
if (hg_bulk_op_id->hg_bulk_origin->eager_mode) {
/* In the case of eager bulk transfer, directly trigger the operation
* to avoid potential deadlocks */
ret = hg_bulk_trigger_entry(hg_bulk_op_id);
if (ret != HG_SUCCESS) {
HG_LOG_ERROR("Could not trigger completion entry");
goto done;
}
} else {
struct hg_completion_entry *hg_completion_entry =
&hg_bulk_op_id->hg_completion_entry;
hg_completion_entry->op_type = HG_BULK;
hg_completion_entry->op_id.hg_bulk_op_id = hg_bulk_op_id;
ret = hg_core_completion_add(context, hg_completion_entry,
hg_bulk_op_id->is_self);
if (ret != HG_SUCCESS) {
HG_LOG_ERROR("Could not add HG completion entry to completion queue");
goto done;
}
}
done:
return ret;
}
/*---------------------------------------------------------------------------*/
static int
hg_bulk_transfer_cb(const struct na_cb_info *callback_info)
{
struct hg_bulk_op_id *hg_bulk_op_id =
(struct hg_bulk_op_id *) callback_info->arg;
na_return_t na_ret = NA_SUCCESS;
int ret = 0;
if (callback_info->ret == NA_CANCELED) {
/* If canceled, mark handle as canceled */
hg_atomic_cas32(&hg_bulk_op_id->canceled, 0, 1);
} else if (callback_info->ret != NA_SUCCESS) {
HG_LOG_ERROR("Error in NA callback: %s",
NA_Error_to_string(callback_info->ret));
na_ret = NA_PROTOCOL_ERROR;
goto done;
}
/* When all NA transfers that correspond to bulk operation complete
* add HG user callback to completion queue
*/
if ((unsigned int) hg_atomic_incr32(&hg_bulk_op_id->op_completed_count)
== hg_bulk_op_id->op_count) {
hg_bulk_complete(hg_bulk_op_id);
ret++;
}
done:
(void) na_ret;
return ret;
}
static hg_return_t
hg_test_perf_forward_cb(const struct hg_cb_info *callback_info)
{
struct hg_test_perf_args *args =
(struct hg_test_perf_args *) callback_info->arg;
if ((unsigned int) hg_atomic_incr32(&args->op_completed_count)
== args->op_count) {
hg_request_complete(args->request);
}
return HG_SUCCESS;
}
static HG_THREAD_RETURN_TYPE
thread_cb_incr32(void *arg)
{
hg_thread_ret_t thread_ret = (hg_thread_ret_t) 0;
hg_atomic_int32_t *atomic_int32 = (hg_atomic_int32_t *) arg;
hg_util_int32_t incr;
incr = hg_atomic_incr32(atomic_int32);
if (!incr)
fprintf(stderr, "Error: incr is %d\n", incr);
incr = hg_atomic_decr32(atomic_int32);
if (incr)
fprintf(stderr, "Error: incr is %d\n", incr);
hg_thread_exit(thread_ret);
return thread_ret;
}
/*---------------------------------------------------------------------------*/
static hg_return_t
hg_test_bulk_seg_transfer_cb(const struct hg_cb_info *hg_cb_info)
{
struct hg_test_bulk_args *bulk_args = (struct hg_test_bulk_args *)
hg_cb_info->arg;
hg_bulk_t local_bulk_handle = hg_cb_info->info.bulk.local_handle;
hg_return_t ret = HG_SUCCESS;
bulk_write_out_t out_struct;
void *buf;
size_t write_ret;
if (hg_atomic_incr32(&bulk_args->completed_transfers) != 2)
goto done;
/* Call bulk_write */
HG_Bulk_access(local_bulk_handle, 0, bulk_args->nbytes, HG_BULK_READWRITE,
1, &buf, NULL, NULL);
write_ret = bulk_write(bulk_args->fildes, buf, 0,
bulk_args->nbytes, 1);
/* Fill output structure */
out_struct.ret = write_ret;
/* Free block handle */
ret = HG_Bulk_free(local_bulk_handle);
if (ret != HG_SUCCESS) {
fprintf(stderr, "Could not free HG bulk handle\n");
return ret;
}
/* Send response back */
ret = HG_Respond(bulk_args->handle, NULL, NULL, &out_struct);
if (ret != HG_SUCCESS) {
fprintf(stderr, "Could not respond\n");
return ret;
}
HG_Destroy(bulk_args->handle);
free(bulk_args);
done:
return ret;
}
/*---------------------------------------------------------------------------*/
static hg_return_t
hg_test_finalize2_cb(hg_handle_t handle)
{
hg_return_t ret = HG_SUCCESS;
hg_atomic_incr32(&hg_test_finalizing_count_g);
/* Free handle and send response back */
ret = HG_Respond(handle, NULL, NULL, NULL);
if (ret != HG_SUCCESS) {
fprintf(stderr, "Could not respond\n");
return ret;
}
HG_Destroy(handle);
return ret;
}
/*---------------------------------------------------------------------------*/
hg_return_t
HG_Bulk_ref_incr(hg_bulk_t handle)
{
struct hg_bulk *hg_bulk = (struct hg_bulk *) handle;
hg_return_t ret = HG_SUCCESS;
if (!hg_bulk) {
HG_LOG_ERROR("NULL memory handle passed");
ret = HG_INVALID_PARAM;
goto done;
}
/* Increment ref count */
hg_atomic_incr32(&hg_bulk->ref_count);
done:
return ret;
}
/*---------------------------------------------------------------------------*/
static hg_return_t
hg_bulk_transfer(hg_context_t *context, hg_cb_t callback, void *arg,
hg_bulk_op_t op, struct hg_addr *origin_addr,
struct hg_bulk *hg_bulk_origin, hg_size_t origin_offset,
struct hg_bulk *hg_bulk_local, hg_size_t local_offset, hg_size_t size,
hg_op_id_t *op_id)
{
hg_uint32_t origin_segment_start_index = 0, local_segment_start_index = 0;
hg_size_t origin_segment_start_offset = origin_offset,
local_segment_start_offset = local_offset;
struct hg_bulk_op_id *hg_bulk_op_id = NULL;
na_bulk_op_t na_bulk_op;
na_addr_t na_origin_addr = HG_Core_addr_get_na(origin_addr);
na_class_t *na_class = HG_Core_class_get_na(hg_bulk_origin->hg_class);
hg_bool_t is_self = NA_Addr_is_self(na_class, na_origin_addr);
hg_bool_t scatter_gather =
(na_class->mem_handle_create_segments && !is_self) ? HG_TRUE : HG_FALSE;
hg_return_t ret = HG_SUCCESS;
unsigned int i;
/* Map op to NA op */
switch (op) {
case HG_BULK_PUSH:
na_bulk_op = (is_self) ? hg_bulk_memcpy_put : hg_bulk_na_put;
break;
case HG_BULK_PULL:
/* Eager mode can only be used when data is pulled from origin */
na_bulk_op = (is_self || hg_bulk_origin->eager_mode) ?
hg_bulk_memcpy_get : hg_bulk_na_get;
break;
default:
HG_LOG_ERROR("Unknown bulk operation");
ret = HG_INVALID_PARAM;
goto done;
}
/* Allocate op_id */
hg_bulk_op_id = (struct hg_bulk_op_id *) malloc(
sizeof(struct hg_bulk_op_id));
if (!hg_bulk_op_id) {
HG_LOG_ERROR("Could not allocate HG Bulk operation ID");
ret = HG_NOMEM_ERROR;
goto done;
}
hg_bulk_op_id->hg_class = hg_bulk_origin->hg_class;
hg_bulk_op_id->context = context;
hg_bulk_op_id->callback = callback;
hg_bulk_op_id->arg = arg;
hg_atomic_set32(&hg_bulk_op_id->completed, 0);
hg_atomic_set32(&hg_bulk_op_id->canceled, 0);
hg_bulk_op_id->op_count = 1; /* Default */
hg_atomic_set32(&hg_bulk_op_id->op_completed_count, 0);
hg_bulk_op_id->op = op;
hg_bulk_op_id->hg_bulk_origin = hg_bulk_origin;
hg_atomic_incr32(&hg_bulk_origin->ref_count); /* Increment ref count */
hg_bulk_op_id->hg_bulk_local = hg_bulk_local;
hg_atomic_incr32(&hg_bulk_local->ref_count); /* Increment ref count */
hg_bulk_op_id->na_op_ids = NULL;
hg_bulk_op_id->is_self = is_self;
/* Translate bulk_offset */
if (origin_offset && !scatter_gather)
hg_bulk_offset_translate(hg_bulk_origin, origin_offset,
&origin_segment_start_index, &origin_segment_start_offset);
/* Translate block offset */
if (local_offset && !scatter_gather)
hg_bulk_offset_translate(hg_bulk_local, local_offset,
&local_segment_start_index, &local_segment_start_offset);
/* Figure out number of NA operations required */
if (!scatter_gather) {
hg_bulk_transfer_pieces(NULL, NA_ADDR_NULL, hg_bulk_origin,
origin_segment_start_index, origin_segment_start_offset,
hg_bulk_local, local_segment_start_index,
local_segment_start_offset, size, HG_FALSE, NULL,
&hg_bulk_op_id->op_count);
if (!hg_bulk_op_id->op_count) {
HG_LOG_ERROR("Could not get bulk op_count");
ret = HG_INVALID_PARAM;
goto done;
}
}
/* Allocate memory for NA operation IDs */
hg_bulk_op_id->na_op_ids = malloc(sizeof(na_op_id_t) * hg_bulk_op_id->op_count);
if (!hg_bulk_op_id->na_op_ids) {
HG_LOG_ERROR("Could not allocate memory for op_ids");
ret = HG_NOMEM_ERROR;
goto done;
}
for (i = 0; i < hg_bulk_op_id->op_count; i++)
hg_bulk_op_id->na_op_ids[i] = NA_OP_ID_NULL;
/* Assign op_id */
if (op_id && op_id != HG_OP_ID_IGNORE) *op_id = (hg_op_id_t) hg_bulk_op_id;
/* Do actual transfer */
ret = hg_bulk_transfer_pieces(na_bulk_op, na_origin_addr, hg_bulk_origin,
origin_segment_start_index, origin_segment_start_offset, hg_bulk_local,
local_segment_start_index, local_segment_start_offset, size,
scatter_gather, hg_bulk_op_id, NULL);
if (ret != HG_SUCCESS) {
HG_LOG_ERROR("Could not transfer data pieces");
goto done;
}
done:
if (ret != HG_SUCCESS && hg_bulk_op_id) {
free(hg_bulk_op_id->na_op_ids);
free(hg_bulk_op_id);
}
return ret;
}
