libgomp/oacc-host.c

   1 /* OpenACC Runtime Library: acc_device_host.
   2
   3    Copyright (C) 2013-2019 Free Software Foundation, Inc.
   4
   5    Contributed by Mentor Embedded.
   6
   7    This file is part of the GNU Offloading and Multi Processing Library
   8    (libgomp).
   9
  10    Libgomp is free software; you can redistribute it and/or modify it
  11    under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3, or (at your option)
  13    any later version.
  14
  15    Libgomp is distributed in the hope that it will be useful, but WITHOUT ANY
  16    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  17    FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  18    more details.
  19
  20    Under Section 7 of GPL version 3, you are granted additional
  21    permissions described in the GCC Runtime Library Exception, version
  22    3.1, as published by the Free Software Foundation.
  23
  24    You should have received a copy of the GNU General Public License and
  25    a copy of the GCC Runtime Library Exception along with this program;
  26    see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  27    <http://www.gnu.org/licenses/>.  */
  28
  29 #include "libgomp.h"
  30 #include "oacc-int.h"
  31 #include "gomp-constants.h"
  32
  33 #include <stdbool.h>
  34 #include <stddef.h>
  35 #include <stdint.h>
  36
  37 static struct gomp_device_descr host_dispatch;
  38
  39 static const char *
  40 host_get_name (void)
  41 {
  42   return host_dispatch.name;
  43 }
  44
  45 static unsigned int
  46 host_get_caps (void)
  47 {
  48   return host_dispatch.capabilities;
  49 }
  50
  51 static int
  52 host_get_type (void)
  53 {
  54   return host_dispatch.type;
  55 }
  56
  57 static int
  58 host_get_num_devices (void)
  59 {
  60   return 1;
  61 }
  62
  63 static bool
  64 host_init_device (int n __attribute__ ((unused)))
  65 {
  66   return true;
  67 }
  68
  69 static bool
  70 host_fini_device (int n __attribute__ ((unused)))
  71 {
  72   return true;
  73 }
  74
  75 static unsigned
  76 host_version (void)
  77 {
  78   return GOMP_VERSION;
  79 }
  80
  81 static int
  82 host_load_image (int n __attribute__ ((unused)),
  83                  unsigned v __attribute__ ((unused)),
  84                  const void *t __attribute__ ((unused)),
  85                  struct addr_pair **r __attribute__ ((unused)))
  86 {
  87   return 0;
  88 }
  89
  90 static bool
  91 host_unload_image (int n __attribute__ ((unused)),
  92                    unsigned v __attribute__ ((unused)),
  93                    const void *t __attribute__ ((unused)))
  94 {
  95   return true;
  96 }
  97
  98 static void *
  99 host_alloc (int n __attribute__ ((unused)), size_t s)
 100 {
 101   return gomp_malloc (s);
 102 }
 103
 104 static bool
 105 host_free (int n __attribute__ ((unused)), void *p)
 106 {
 107   free (p);
 108   return true;
 109 }
 110
 111 static bool
 112 host_dev2host (int n __attribute__ ((unused)),
 113                void *h __attribute__ ((unused)),
 114                const void *d __attribute__ ((unused)),
 115                size_t s __attribute__ ((unused)))
 116 {
 117   return true;
 118 }
 119
 120 static bool
 121 host_host2dev (int n __attribute__ ((unused)),
 122                void *d __attribute__ ((unused)),
 123                const void *h __attribute__ ((unused)),
 124                size_t s __attribute__ ((unused)))
 125 {
 126   return true;
 127 }
 128
 129 static void
 130 host_run (int n __attribute__ ((unused)), void *fn_ptr, void *vars,
 131           void **args __attribute__((unused)))
 132 {
 133   void (*fn)(void *) = (void (*)(void *)) fn_ptr;
 134
 135   fn (vars);
 136 }
 137
 138 static void
 139 host_openacc_exec (void (*fn) (void *),
 140                    size_t mapnum __attribute__ ((unused)),
 141                    void **hostaddrs,
 142                    void **devaddrs __attribute__ ((unused)),
 143                    unsigned *dims __attribute__ ((unused)),
 144                    void *targ_mem_desc __attribute__ ((unused)))
 145 {
 146   fn (hostaddrs);
 147 }
 148
 149 static void
 150 host_openacc_async_exec (void (*fn) (void *),
 151                          size_t mapnum __attribute__ ((unused)),
 152                          void **hostaddrs,
 153                          void **devaddrs __attribute__ ((unused)),
 154                          unsigned *dims __attribute__ ((unused)),
 155                          void *targ_mem_desc __attribute__ ((unused)),
 156                          struct goacc_asyncqueue *aq __attribute__ ((unused)))
 157 {
 158   fn (hostaddrs);
 159 }
 160
 161 static int
 162 host_openacc_async_test (struct goacc_asyncqueue *aq __attribute__ ((unused)))
 163 {
 164   return 1;
 165 }
 166
 167 static bool
 168 host_openacc_async_synchronize (struct goacc_asyncqueue *aq
 169                                 __attribute__ ((unused)))
 170 {
 171   return true;
 172 }
 173
 174 static bool
 175 host_openacc_async_serialize (struct goacc_asyncqueue *aq1
 176                               __attribute__ ((unused)),
 177                               struct goacc_asyncqueue *aq2
 178                               __attribute__ ((unused)))
 179 {
 180   return true;
 181 }
 182
 183 static bool
 184 host_openacc_async_host2dev (int ord __attribute__ ((unused)),
 185                              void *dst __attribute__ ((unused)),
 186                              const void *src __attribute__ ((unused)),
 187                              size_t n __attribute__ ((unused)),
 188                              struct goacc_asyncqueue *aq
 189                              __attribute__ ((unused)))
 190 {
 191   return true;
 192 }
 193
 194 static bool
 195 host_openacc_async_dev2host (int ord __attribute__ ((unused)),
 196                              void *dst __attribute__ ((unused)),
 197                              const void *src __attribute__ ((unused)),
 198                              size_t n __attribute__ ((unused)),
 199                              struct goacc_asyncqueue *aq
 200                              __attribute__ ((unused)))
 201 {
 202   return true;
 203 }
 204
 205 static void
 206 host_openacc_async_queue_callback (struct goacc_asyncqueue *aq
 207                                    __attribute__ ((unused)),
 208                                    void (*callback_fn)(void *)
 209                                    __attribute__ ((unused)),
 210                                    void *userptr __attribute__ ((unused)))
 211 {
 212 }
 213
 214 static struct goacc_asyncqueue *
 215 host_openacc_async_construct (void)
 216 {
 217   /* Non-NULL 0xffff... value as opaque dummy.  */
 218   return (struct goacc_asyncqueue *) -1;
 219 }
 220
 221 static bool
 222 host_openacc_async_destruct (struct goacc_asyncqueue *aq
 223                              __attribute__ ((unused)))
 224 {
 225   return true;
 226 }
 227
 228 static void *
 229 host_openacc_create_thread_data (int ord __attribute__ ((unused)))
 230 {
 231   return NULL;
 232 }
 233
 234 static void
 235 host_openacc_destroy_thread_data (void *tls_data __attribute__ ((unused)))
 236 {
 237 }
 238
 239 static struct gomp_device_descr host_dispatch =
 240   {
 241     .name = "host",
 242     .capabilities = (GOMP_OFFLOAD_CAP_SHARED_MEM
 243                      | GOMP_OFFLOAD_CAP_NATIVE_EXEC
 244                      | GOMP_OFFLOAD_CAP_OPENACC_200),
 245     .target_id = 0,
 246     .type = OFFLOAD_TARGET_TYPE_HOST,
 247
 248     .get_name_func = host_get_name,
 249     .get_caps_func = host_get_caps,
 250     .get_type_func = host_get_type,
 251     .get_num_devices_func = host_get_num_devices,
 252     .init_device_func = host_init_device,
 253     .fini_device_func = host_fini_device,
 254     .version_func = host_version,
 255     .load_image_func = host_load_image,
 256     .unload_image_func = host_unload_image,
 257     .alloc_func = host_alloc,
 258     .free_func = host_free,
 259     .dev2host_func = host_dev2host,
 260     .host2dev_func = host_host2dev,
 261     .run_func = host_run,
 262
 263     .mem_map = { NULL },
 264     /* .lock initilized in goacc_host_init.  */
 265     .state = GOMP_DEVICE_UNINITIALIZED,
 266
 267     .openacc = {
 268       .data_environ = NULL,
 269
 270       .exec_func = host_openacc_exec,
 271
 272       .create_thread_data_func = host_openacc_create_thread_data,
 273       .destroy_thread_data_func = host_openacc_destroy_thread_data,
 274
 275       .async = {
 276         .construct_func = host_openacc_async_construct,
 277         .destruct_func = host_openacc_async_destruct,
 278         .test_func = host_openacc_async_test,
 279         .synchronize_func = host_openacc_async_synchronize,
 280         .serialize_func = host_openacc_async_serialize,
 281         .queue_callback_func = host_openacc_async_queue_callback,
 282         .exec_func = host_openacc_async_exec,
 283         .dev2host_func = host_openacc_async_dev2host,
 284         .host2dev_func = host_openacc_async_host2dev,
 285       },
 286
 287       .cuda = {
 288         .get_current_device_func = NULL,
 289         .get_current_context_func = NULL,
 290         .get_stream_func = NULL,
 291         .set_stream_func = NULL,
 292       }
 293     }
 294   };
 295
 296 /* Initialize and register this device type.  */
 297 void
 298 goacc_host_init (void)
 299 {
 300   gomp_mutex_init (&host_dispatch.lock);
 301   goacc_register (&host_dispatch);
 302 }