/* OpenACC Runtime Library: acc_device_host. Copyright (C) 2013-2019 Free Software Foundation, Inc. Contributed by Mentor Embedded. This file is part of the GNU Offloading and Multi Processing Library (libgomp). Libgomp is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3, or (at your option) any later version. Libgomp is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. Under Section 7 of GPL version 3, you are granted additional permissions described in the GCC Runtime Library Exception, version 3.1, as published by the Free Software Foundation. You should have received a copy of the GNU General Public License and a copy of the GCC Runtime Library Exception along with this program; see the files COPYING3 and COPYING.RUNTIME respectively. If not, see . */ #include "libgomp.h" #include "oacc-int.h" #include "gomp-constants.h" #include #include static struct gomp_device_descr host_dispatch; static const char * host_get_name (void) { return host_dispatch.name; } static unsigned int host_get_caps (void) { return host_dispatch.capabilities; } static int host_get_type (void) { return host_dispatch.type; } static int host_get_num_devices (void) { return 1; } static bool host_init_device (int n __attribute__ ((unused))) { return true; } static bool host_fini_device (int n __attribute__ ((unused))) { return true; } static unsigned host_version (void) { return GOMP_VERSION; } static int host_load_image (int n __attribute__ ((unused)), unsigned v __attribute__ ((unused)), const void *t __attribute__ ((unused)), struct addr_pair **r __attribute__ ((unused))) { return 0; } static bool host_unload_image (int n __attribute__ ((unused)), unsigned v __attribute__ ((unused)), const void *t __attribute__ ((unused))) { return true; } static void * host_alloc (int n __attribute__ ((unused)), size_t s) { return gomp_malloc (s); } static bool host_free (int n __attribute__ ((unused)), void *p) { free (p); return true; } static bool host_dev2host (int n __attribute__ ((unused)), void *h __attribute__ ((unused)), const void *d __attribute__ ((unused)), size_t s __attribute__ ((unused))) { return true; } static bool host_host2dev (int n __attribute__ ((unused)), void *d __attribute__ ((unused)), const void *h __attribute__ ((unused)), size_t s __attribute__ ((unused))) { return true; } static void host_run (int n __attribute__ ((unused)), void *fn_ptr, void *vars, void **args __attribute__((unused))) { void (*fn)(void *) = (void (*)(void *)) fn_ptr; fn (vars); } static void host_openacc_exec (void (*fn) (void *), size_t mapnum __attribute__ ((unused)), void **hostaddrs, void **devaddrs __attribute__ ((unused)), unsigned *dims __attribute__ ((unused)), void *targ_mem_desc __attribute__ ((unused))) { fn (hostaddrs); } static void host_openacc_async_exec (void (*fn) (void *), size_t mapnum __attribute__ ((unused)), void **hostaddrs, void **devaddrs __attribute__ ((unused)), unsigned *dims __attribute__ ((unused)), void *targ_mem_desc __attribute__ ((unused)), struct goacc_asyncqueue *aq __attribute__ ((unused))) { fn (hostaddrs); } static int host_openacc_async_test (struct goacc_asyncqueue *aq __attribute__ ((unused))) { return 1; } static bool host_openacc_async_synchronize (struct goacc_asyncqueue *aq __attribute__ ((unused))) { return true; } static bool host_openacc_async_serialize (struct goacc_asyncqueue *aq1 __attribute__ ((unused)), struct goacc_asyncqueue *aq2 __attribute__ ((unused))) { return true; } static bool host_openacc_async_host2dev (int ord __attribute__ ((unused)), void *dst __attribute__ ((unused)), const void *src __attribute__ ((unused)), size_t n __attribute__ ((unused)), struct goacc_asyncqueue *aq __attribute__ ((unused))) { return true; } static bool host_openacc_async_dev2host (int ord __attribute__ ((unused)), void *dst __attribute__ ((unused)), const void *src __attribute__ ((unused)), size_t n __attribute__ ((unused)), struct goacc_asyncqueue *aq __attribute__ ((unused))) { return true; } static void host_openacc_async_queue_callback (struct goacc_asyncqueue *aq __attribute__ ((unused)), void (*callback_fn)(void *) __attribute__ ((unused)), void *userptr __attribute__ ((unused))) { } static struct goacc_asyncqueue * host_openacc_async_construct (int device __attribute__((unused))) { /* Non-NULL 0xffff... value as opaque dummy. */ return (struct goacc_asyncqueue *) -1; } static bool host_openacc_async_destruct (struct goacc_asyncqueue *aq __attribute__ ((unused))) { return true; } static void * host_openacc_create_thread_data (int ord __attribute__ ((unused))) { return NULL; } static void host_openacc_destroy_thread_data (void *tls_data __attribute__ ((unused))) { } static struct gomp_device_descr host_dispatch = { .name = "host", .capabilities = (GOMP_OFFLOAD_CAP_SHARED_MEM | GOMP_OFFLOAD_CAP_NATIVE_EXEC | GOMP_OFFLOAD_CAP_OPENACC_200), .target_id = 0, .type = OFFLOAD_TARGET_TYPE_HOST, .get_name_func = host_get_name, .get_caps_func = host_get_caps, .get_type_func = host_get_type, .get_num_devices_func = host_get_num_devices, .init_device_func = host_init_device, .fini_device_func = host_fini_device, .version_func = host_version, .load_image_func = host_load_image, .unload_image_func = host_unload_image, .alloc_func = host_alloc, .free_func = host_free, .dev2host_func = host_dev2host, .host2dev_func = host_host2dev, .run_func = host_run, .mem_map = { NULL }, /* .lock initilized in goacc_host_init. */ .state = GOMP_DEVICE_UNINITIALIZED, .openacc = { .exec_func = host_openacc_exec, .create_thread_data_func = host_openacc_create_thread_data, .destroy_thread_data_func = host_openacc_destroy_thread_data, .async = { .construct_func = host_openacc_async_construct, .destruct_func = host_openacc_async_destruct, .test_func = host_openacc_async_test, .synchronize_func = host_openacc_async_synchronize, .serialize_func = host_openacc_async_serialize, .queue_callback_func = host_openacc_async_queue_callback, .exec_func = host_openacc_async_exec, .dev2host_func = host_openacc_async_dev2host, .host2dev_func = host_openacc_async_host2dev, }, .cuda = { .get_current_device_func = NULL, .get_current_context_func = NULL, .get_stream_func = NULL, .set_stream_func = NULL, } } }; /* Initialize and register this device type. */ void goacc_host_init (void) { gomp_mutex_init (&host_dispatch.lock); goacc_register (&host_dispatch); }