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
  36 static struct gomp_device_descr host_dispatch;
  37
  38 static const char *
  39 host_get_name (void)
  40 {
  41   return host_dispatch.name;
  42 }
  43
  44 static unsigned int
  45 host_get_caps (void)
  46 {
  47   return host_dispatch.capabilities;
  48 }
  49
  50 static int
  51 host_get_type (void)
  52 {
  53   return host_dispatch.type;
  54 }
  55
  56 static int
  57 host_get_num_devices (void)
  58 {
  59   return 1;
  60 }
  61
  62 static bool
  63 host_init_device (int n __attribute__ ((unused)))
  64 {
  65   return true;
  66 }
  67
  68 static bool
  69 host_fini_device (int n __attribute__ ((unused)))
  70 {
  71   return true;
  72 }
  73
  74 static unsigned
  75 host_version (void)
  76 {
  77   return GOMP_VERSION;
  78 }
  79
  80 static int
  81 host_load_image (int n __attribute__ ((unused)),
  82                  unsigned v __attribute__ ((unused)),
  83                  const void *t __attribute__ ((unused)),
  84                  struct addr_pair **r __attribute__ ((unused)))
  85 {
  86   return 0;
  87 }
  88
  89 static bool
  90 host_unload_image (int n __attribute__ ((unused)),
  91                    unsigned v __attribute__ ((unused)),
  92                    const void *t __attribute__ ((unused)))
  93 {
  94   return true;
  95 }
  96
  97 static void *
  98 host_alloc (int n __attribute__ ((unused)), size_t s)
  99 {
 100   return gomp_malloc (s);
 101 }
 102
 103 static bool
 104 host_free (int n __attribute__ ((unused)), void *p)
 105 {
 106   free (p);
 107   return true;
 108 }
 109
 110 static bool
 111 host_dev2host (int n __attribute__ ((unused)),
 112                void *h __attribute__ ((unused)),
 113                const void *d __attribute__ ((unused)),
 114                size_t s __attribute__ ((unused)))
 115 {
 116   return true;
 117 }
 118
 119 static bool
 120 host_host2dev (int n __attribute__ ((unused)),
 121                void *d __attribute__ ((unused)),
 122                const void *h __attribute__ ((unused)),
 123                size_t s __attribute__ ((unused)))
 124 {
 125   return true;
 126 }
 127
 128 static void
 129 host_run (int n __attribute__ ((unused)), void *fn_ptr, void *vars,
 130           void **args __attribute__((unused)))
 131 {
 132   void (*fn)(void *) = (void (*)(void *)) fn_ptr;
 133
 134   fn (vars);
 135 }
 136
 137 static void
 138 host_openacc_exec (void (*fn) (void *),
 139                    size_t mapnum __attribute__ ((unused)),
 140                    void **hostaddrs,
 141                    void **devaddrs __attribute__ ((unused)),
 142                    unsigned *dims __attribute__ ((unused)),
 143                    void *targ_mem_desc __attribute__ ((unused)))
 144 {
 145   fn (hostaddrs);
 146 }
 147
 148 static void
 149 host_openacc_async_exec (void (*fn) (void *),
 150                          size_t mapnum __attribute__ ((unused)),
 151                          void **hostaddrs,
 152                          void **devaddrs __attribute__ ((unused)),
 153                          unsigned *dims __attribute__ ((unused)),
 154                          void *targ_mem_desc __attribute__ ((unused)),
 155                          struct goacc_asyncqueue *aq __attribute__ ((unused)))
 156 {
 157   fn (hostaddrs);
 158 }
 159
 160 static int
 161 host_openacc_async_test (struct goacc_asyncqueue *aq __attribute__ ((unused)))
 162 {
 163   return 1;
 164 }
 165
 166 static bool
 167 host_openacc_async_synchronize (struct goacc_asyncqueue *aq
 168                                 __attribute__ ((unused)))
 169 {
 170   return true;
 171 }
 172
 173 static bool
 174 host_openacc_async_serialize (struct goacc_asyncqueue *aq1
 175                               __attribute__ ((unused)),
 176                               struct goacc_asyncqueue *aq2
 177                               __attribute__ ((unused)))
 178 {
 179   return true;
 180 }
 181
 182 static bool
 183 host_openacc_async_host2dev (int ord __attribute__ ((unused)),
 184                              void *dst __attribute__ ((unused)),
 185                              const void *src __attribute__ ((unused)),
 186                              size_t n __attribute__ ((unused)),
 187                              struct goacc_asyncqueue *aq
 188                              __attribute__ ((unused)))
 189 {
 190   return true;
 191 }
 192
 193 static bool
 194 host_openacc_async_dev2host (int ord __attribute__ ((unused)),
 195                              void *dst __attribute__ ((unused)),
 196                              const void *src __attribute__ ((unused)),
 197                              size_t n __attribute__ ((unused)),
 198                              struct goacc_asyncqueue *aq
 199                              __attribute__ ((unused)))
 200 {
 201   return true;
 202 }
 203
 204 static void
 205 host_openacc_async_queue_callback (struct goacc_asyncqueue *aq
 206                                    __attribute__ ((unused)),
 207                                    void (*callback_fn)(void *)
 208                                    __attribute__ ((unused)),
 209                                    void *userptr __attribute__ ((unused)))
 210 {
 211 }
 212
 213 static struct goacc_asyncqueue *
 214 host_openacc_async_construct (void)
 215 {
 216   /* Non-NULL 0xffff... value as opaque dummy.  */
 217   return (struct goacc_asyncqueue *) -1;
 218 }
 219
 220 static bool
 221 host_openacc_async_destruct (struct goacc_asyncqueue *aq
 222                              __attribute__ ((unused)))
 223 {
 224   return true;
 225 }
 226
 227 static void *
 228 host_openacc_create_thread_data (int ord __attribute__ ((unused)))
 229 {
 230   return NULL;
 231 }
 232
 233 static void
 234 host_openacc_destroy_thread_data (void *tls_data __attribute__ ((unused)))
 235 {
 236 }
 237
 238 static struct gomp_device_descr host_dispatch =
 239   {
 240     .name = "host",
 241     .capabilities = (GOMP_OFFLOAD_CAP_SHARED_MEM
 242                      | GOMP_OFFLOAD_CAP_NATIVE_EXEC
 243                      | GOMP_OFFLOAD_CAP_OPENACC_200),
 244     .target_id = 0,
 245     .type = OFFLOAD_TARGET_TYPE_HOST,
 246
 247     .get_name_func = host_get_name,
 248     .get_caps_func = host_get_caps,
 249     .get_type_func = host_get_type,
 250     .get_num_devices_func = host_get_num_devices,
 251     .init_device_func = host_init_device,
 252     .fini_device_func = host_fini_device,
 253     .version_func = host_version,
 254     .load_image_func = host_load_image,
 255     .unload_image_func = host_unload_image,
 256     .alloc_func = host_alloc,
 257     .free_func = host_free,
 258     .dev2host_func = host_dev2host,
 259     .host2dev_func = host_host2dev,
 260     .run_func = host_run,
 261
 262     .mem_map = { NULL },
 263     /* .lock initilized in goacc_host_init.  */
 264     .state = GOMP_DEVICE_UNINITIALIZED,
 265
 266     .openacc = {
 267       .data_environ = NULL,
 268
 269       .exec_func = host_openacc_exec,
 270
 271       .create_thread_data_func = host_openacc_create_thread_data,
 272       .destroy_thread_data_func = host_openacc_destroy_thread_data,
 273
 274       .async = {
 275         .construct_func = host_openacc_async_construct,
 276         .destruct_func = host_openacc_async_destruct,
 277         .test_func = host_openacc_async_test,
 278         .synchronize_func = host_openacc_async_synchronize,
 279         .serialize_func = host_openacc_async_serialize,
 280         .queue_callback_func = host_openacc_async_queue_callback,
 281         .exec_func = host_openacc_async_exec,
 282         .dev2host_func = host_openacc_async_dev2host,
 283         .host2dev_func = host_openacc_async_host2dev,
 284       },
 285
 286       .cuda = {
 287         .get_current_device_func = NULL,
 288         .get_current_context_func = NULL,
 289         .get_stream_func = NULL,
 290         .set_stream_func = NULL,
 291       }
 292     }
 293   };
 294
 295 /* Initialize and register this device type.  */
 296 void
 297 goacc_host_init (void)
 298 {
 299   gomp_mutex_init (&host_dispatch.lock);
 300   goacc_register (&host_dispatch);
 301 }