libgomp/oacc-host.c

   1 /* OpenACC Runtime Library: acc_device_host.
   2
   3    Copyright (C) 2013-2015 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 void
  64 host_init_device (int n __attribute__ ((unused)))
  65 {
  66 }
  67
  68 static void
  69 host_fini_device (int n __attribute__ ((unused)))
  70 {
  71 }
  72
  73 static unsigned
  74 host_version (void)
  75 {
  76   return GOMP_VERSION;
  77 }
  78
  79 static int
  80 host_load_image (int n __attribute__ ((unused)),
  81                  unsigned v __attribute__ ((unused)),
  82                  const void *t __attribute__ ((unused)),
  83                  struct addr_pair **r __attribute__ ((unused)))
  84 {
  85   return 0;
  86 }
  87
  88 static void
  89 host_unload_image (int n __attribute__ ((unused)),
  90                    unsigned v __attribute__ ((unused)),
  91                    const void *t __attribute__ ((unused)))
  92 {
  93 }
  94
  95 static void *
  96 host_alloc (int n __attribute__ ((unused)), size_t s)
  97 {
  98   return gomp_malloc (s);
  99 }
 100
 101 static void
 102 host_free (int n __attribute__ ((unused)), void *p)
 103 {
 104   free (p);
 105 }
 106
 107 static void *
 108 host_dev2host (int n __attribute__ ((unused)),
 109                void *h __attribute__ ((unused)),
 110                const void *d __attribute__ ((unused)),
 111                size_t s __attribute__ ((unused)))
 112 {
 113   return NULL;
 114 }
 115
 116 static void *
 117 host_host2dev (int n __attribute__ ((unused)),
 118                void *d __attribute__ ((unused)),
 119                const void *h __attribute__ ((unused)),
 120                size_t s __attribute__ ((unused)))
 121 {
 122   return NULL;
 123 }
 124
 125 static void
 126 host_run (int n __attribute__ ((unused)), void *fn_ptr, void *vars)
 127 {
 128   void (*fn)(void *) = (void (*)(void *)) fn_ptr;
 129
 130   fn (vars);
 131 }
 132
 133 static void
 134 host_openacc_exec (void (*fn) (void *),
 135                    size_t mapnum __attribute__ ((unused)),
 136                    void **hostaddrs,
 137                    void **devaddrs __attribute__ ((unused)),
 138                    int async __attribute__ ((unused)),
 139                    unsigned *dims __attribute ((unused)),
 140                    void *targ_mem_desc __attribute__ ((unused)))
 141 {
 142   fn (hostaddrs);
 143 }
 144
 145 static void
 146 host_openacc_register_async_cleanup (void *targ_mem_desc __attribute__ ((unused)))
 147 {
 148 }
 149
 150 static int
 151 host_openacc_async_test (int async __attribute__ ((unused)))
 152 {
 153   return 1;
 154 }
 155
 156 static int
 157 host_openacc_async_test_all (void)
 158 {
 159   return 1;
 160 }
 161
 162 static void
 163 host_openacc_async_wait (int async __attribute__ ((unused)))
 164 {
 165 }
 166
 167 static void
 168 host_openacc_async_wait_async (int async1 __attribute__ ((unused)),
 169                                int async2 __attribute__ ((unused)))
 170 {
 171 }
 172
 173 static void
 174 host_openacc_async_wait_all (void)
 175 {
 176 }
 177
 178 static void
 179 host_openacc_async_wait_all_async (int async __attribute__ ((unused)))
 180 {
 181 }
 182
 183 static void
 184 host_openacc_async_set_async (int async __attribute__ ((unused)))
 185 {
 186 }
 187
 188 static void *
 189 host_openacc_create_thread_data (int ord __attribute__ ((unused)))
 190 {
 191   return NULL;
 192 }
 193
 194 static void
 195 host_openacc_destroy_thread_data (void *tls_data __attribute__ ((unused)))
 196 {
 197 }
 198
 199 static struct gomp_device_descr host_dispatch =
 200   {
 201     .name = "host",
 202     .capabilities = (GOMP_OFFLOAD_CAP_SHARED_MEM
 203                      | GOMP_OFFLOAD_CAP_NATIVE_EXEC
 204                      | GOMP_OFFLOAD_CAP_OPENACC_200),
 205     .target_id = 0,
 206     .type = OFFLOAD_TARGET_TYPE_HOST,
 207
 208     .get_name_func = host_get_name,
 209     .get_caps_func = host_get_caps,
 210     .get_type_func = host_get_type,
 211     .get_num_devices_func = host_get_num_devices,
 212     .init_device_func = host_init_device,
 213     .fini_device_func = host_fini_device,
 214     .version_func = host_version,
 215     .load_image_func = host_load_image,
 216     .unload_image_func = host_unload_image,
 217     .alloc_func = host_alloc,
 218     .free_func = host_free,
 219     .dev2host_func = host_dev2host,
 220     .host2dev_func = host_host2dev,
 221     .run_func = host_run,
 222
 223     .mem_map = { NULL },
 224     /* .lock initilized in goacc_host_init.  */
 225     .is_initialized = false,
 226
 227     .openacc = {
 228       .data_environ = NULL,
 229
 230       .exec_func = host_openacc_exec,
 231
 232       .register_async_cleanup_func = host_openacc_register_async_cleanup,
 233
 234       .async_test_func = host_openacc_async_test,
 235       .async_test_all_func = host_openacc_async_test_all,
 236       .async_wait_func = host_openacc_async_wait,
 237       .async_wait_async_func = host_openacc_async_wait_async,
 238       .async_wait_all_func = host_openacc_async_wait_all,
 239       .async_wait_all_async_func = host_openacc_async_wait_all_async,
 240       .async_set_async_func = host_openacc_async_set_async,
 241
 242       .create_thread_data_func = host_openacc_create_thread_data,
 243       .destroy_thread_data_func = host_openacc_destroy_thread_data,
 244
 245       .cuda = {
 246         .get_current_device_func = NULL,
 247         .get_current_context_func = NULL,
 248         .get_stream_func = NULL,
 249         .set_stream_func = NULL,
 250       }
 251     }
 252   };
 253
 254 /* Initialize and register this device type.  */
 255 void
 256 goacc_host_init (void)
 257 {
 258   gomp_mutex_init (&host_dispatch.lock);
 259   goacc_register (&host_dispatch);
 260 }