コード例 #1
0
void hclib_async_memset_helper(place_t *pl, void *ptr, int val, size_t nbytes,
                               hclib_future_t **future_list, void *user_arg,
                               hclib_promise_t *out_promise) {
    gpu_task_t *task = malloc(sizeof(gpu_task_t));
    task->t._fp = NULL;
    task->t.is_asyncAnyType = 0;
    task->t.future_list = NULL;
    task->t.args = NULL;
    task->t.place = NULL;

    hclib_promise_init(out_promise);
    task->gpu_type = GPU_MEMSET_TASK;
    task->promise_to_put = out_promise;
    task->arg_to_put = user_arg;

    task->gpu_task_def.memset_task.pl = pl;
    task->gpu_task_def.memset_task.ptr = ptr;
    task->gpu_task_def.memset_task.val = val;
    task->gpu_task_def.memset_task.nbytes = nbytes;

#ifdef VERBOSE
    fprintf(stderr, "hclib_async_memset: pl=%p ptr=%p nbytes=%lu\n", pl, ptr,
            (unsigned long)nbytes);
#endif

    if (future_list) {
        hclib_async(async_gpu_task_launcher, task, future_list, NULL, NULL, 0);
    } else {
        spawn_gpu_task((hclib_task_t *)task);
    }
}
コード例 #2
0
void hclib_async_copy_helper(place_t *dst_pl, void *dst, place_t *src_pl,
                             void *src, size_t nbytes, hclib_future_t **future_list,
                             void *user_arg, hclib_promise_t *out_promise) {
    gpu_task_t *task = malloc(sizeof(gpu_task_t));
    task->t._fp = NULL;
    task->t.is_asyncAnyType = 0;
    task->t.future_list = NULL;
    task->t.args = NULL;
    task->t.place = NULL;

    hclib_promise_init(out_promise);
    task->gpu_type = GPU_COMM_TASK;
    task->promise_to_put = out_promise;
    task->arg_to_put = user_arg;

    task->gpu_task_def.comm_task.src_pl = src_pl;
    task->gpu_task_def.comm_task.dst_pl = dst_pl;
    task->gpu_task_def.comm_task.src = src;
    task->gpu_task_def.comm_task.dst = dst;
    task->gpu_task_def.comm_task.nbytes = nbytes;

#ifdef VERBOSE
    fprintf(stderr, "hclib_async_copy: dst_pl=%p dst=%p src_pl=%p src=%p "
            "nbytes=%lu future_list=%p\n", dst_pl, dst, src_pl, src,
            (unsigned long)nbytes, future_list);
#endif

    if (future_list) {
        hclib_async(async_gpu_task_launcher, task, future_list, NULL, NULL, 0);
    } else {
        spawn_gpu_task((hclib_task_t *)task);
    }
}
コード例 #3
0
ファイル: hclib.c プロジェクト: habanero-rice/hclib
hclib_future_t *hclib_async_future(future_fct_t fp, void *arg,
                                   hclib_future_t **futures, const int nfutures,
                                   hclib_locale_t *locale) {
    future_args_wrapper *wrapper = malloc(sizeof(future_args_wrapper));
    hclib_promise_init(&wrapper->event);
    wrapper->fp = fp;
    wrapper->actual_in = arg;
    hclib_async(future_caller, wrapper, futures, nfutures, locale);

    return hclib_get_future_for_promise(&wrapper->event);
}