libgomp/plugin/plugin-host.c

   1 /* OpenACC Runtime Library: acc_device_host, acc_device_host_nonshm.
   2
   3    Copyright (C) 2013-2014 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 /* Simple implementation of support routines for a shared-memory
  30    acc_device_host, and a non-shared memory acc_device_host_nonshm, with the
  31    latter built as a plugin.  */
  32
  33 #include "openacc.h"
  34 #include "config.h"
  35 #include "libgomp.h"
  36 #include "libgomp_target.h"
  37 #ifdef HOST_NONSHM_PLUGIN
  38 #include "libgomp-plugin.h"
  39 #include "oacc-plugin.h"
  40 #else
  41 #include "oacc-int.h"
  42 #endif
  43
  44 #include <stdint.h>
  45 #include <stdlib.h>
  46 #include <string.h>
  47 #include <stdio.h>
  48
  49 #ifdef HOST_NONSHM_PLUGIN
  50 #define STATIC
  51 #define GOMP(X) GOMP_PLUGIN_##X
  52 #define SELF "host_nonshm plugin: "
  53 #else
  54 #define STATIC static
  55 #define GOMP(X) gomp_##X
  56 #define SELF "host: "
  57 #endif
  58
  59 #ifndef HOST_NONSHM_PLUGIN
  60 static struct gomp_device_descr host_dispatch;
  61 #endif
  62
  63 STATIC const char *
  64 GOMP_OFFLOAD_get_name (void)
  65 {
  66 #ifdef HOST_NONSHM_PLUGIN
  67   return "host_nonshm";
  68 #else
  69   return "host";
  70 #endif
  71 }
  72
  73 STATIC unsigned int
  74 GOMP_OFFLOAD_get_caps (void)
  75 {
  76   unsigned int caps = (GOMP_OFFLOAD_CAP_OPENACC_200
  77                        | GOMP_OFFLOAD_CAP_NATIVE_EXEC);
  78
  79 #ifndef HOST_NONSHM_PLUGIN
  80   caps |= GOMP_OFFLOAD_CAP_SHARED_MEM;
  81 #endif
  82
  83   return caps;
  84 }
  85
  86 STATIC int
  87 GOMP_OFFLOAD_get_type (void)
  88 {
  89 #ifdef HOST_NONSHM_PLUGIN
  90   return OFFLOAD_TARGET_TYPE_HOST_NONSHM;
  91 #else
  92   return OFFLOAD_TARGET_TYPE_HOST;
  93 #endif
  94 }
  95
  96 STATIC int
  97 GOMP_OFFLOAD_get_num_devices (void)
  98 {
  99   return 1;
 100 }
 101
 102 STATIC void
 103 GOMP_OFFLOAD_register_image (void *host_table __attribute__((unused)),
 104                              void *target_data __attribute__((unused)))
 105 {
 106 }
 107
 108 STATIC void
 109 GOMP_OFFLOAD_init_device (int n __attribute__((unused)))
 110 {
 111 }
 112
 113 STATIC void
 114 GOMP_OFFLOAD_fini_device (int n __attribute__((unused)))
 115 {
 116 }
 117
 118 STATIC int
 119 GOMP_OFFLOAD_get_table (int n __attribute__((unused)),
 120                         struct mapping_table **table __attribute__((unused)))
 121 {
 122   return 0;
 123 }
 124
 125 STATIC void *
 126 GOMP_OFFLOAD_openacc_open_device (int n)
 127 {
 128   return (void *) (intptr_t) n;
 129 }
 130
 131 STATIC int
 132 GOMP_OFFLOAD_openacc_close_device (void *hnd)
 133 {
 134   return 0;
 135 }
 136
 137 STATIC int
 138 GOMP_OFFLOAD_openacc_get_device_num (void)
 139 {
 140   return 0;
 141 }
 142
 143 STATIC void
 144 GOMP_OFFLOAD_openacc_set_device_num (int n)
 145 {
 146   if (n > 0)
 147     GOMP(fatal) ("device number %u out of range for host execution", n);
 148 }
 149
 150 STATIC void *
 151 GOMP_OFFLOAD_alloc (int n __attribute__((unused)), size_t s)
 152 {
 153   return GOMP(malloc) (s);
 154 }
 155
 156 STATIC void
 157 GOMP_OFFLOAD_free (int n __attribute__((unused)), void *p)
 158 {
 159   free (p);
 160 }
 161
 162 STATIC void *
 163 GOMP_OFFLOAD_host2dev (int n __attribute__((unused)), void *d, const void *h,
 164                        size_t s)
 165 {
 166 #ifdef HOST_NONSHM_PLUGIN
 167   memcpy (d, h, s);
 168 #endif
 169
 170   return 0;
 171 }
 172
 173 STATIC void *
 174 GOMP_OFFLOAD_dev2host (int n __attribute__((unused)), void *h, const void *d,
 175                        size_t s)
 176 {
 177 #ifdef HOST_NONSHM_PLUGIN
 178   memcpy (h, d, s);
 179 #endif
 180
 181   return 0;
 182 }
 183
 184 STATIC void
 185 GOMP_OFFLOAD_run (int n __attribute__((unused)), void *fn_ptr, void *vars)
 186 {
 187   void (*fn)(void *) = (void (*)(void *)) fn_ptr;
 188
 189   fn (vars);
 190 }
 191
 192 STATIC void
 193 GOMP_OFFLOAD_openacc_parallel (void (*fn) (void *),
 194                                size_t mapnum __attribute__((unused)),
 195                                void **hostaddrs __attribute__((unused)),
 196                                void **devaddrs __attribute__((unused)),
 197                                size_t *sizes __attribute__((unused)),
 198                                unsigned short *kinds __attribute__((unused)),
 199                                int num_gangs __attribute__((unused)),
 200                                int num_workers __attribute__((unused)),
 201                                int vector_length __attribute__((unused)),
 202                                int async __attribute__((unused)),
 203                                void *targ_mem_desc __attribute__((unused)))
 204 {
 205 #ifdef HOST_NONSHM_PLUGIN
 206   fn (devaddrs);
 207 #else
 208   fn (hostaddrs);
 209 #endif
 210 }
 211
 212 STATIC void
 213 GOMP_OFFLOAD_openacc_register_async_cleanup (void *targ_mem_desc)
 214 {
 215 #ifdef HOST_NONSHM_PLUGIN
 216   /* "Asynchronous" launches are executed synchronously on the (non-SHM) host,
 217      so there's no point in delaying host-side cleanup -- just do it now.  */
 218   GOMP_PLUGIN_async_unmap_vars (targ_mem_desc);
 219 #endif
 220 }
 221
 222 STATIC void
 223 GOMP_OFFLOAD_openacc_async_set_async (int async __attribute__((unused)))
 224 {
 225 }
 226
 227 STATIC int
 228 GOMP_OFFLOAD_openacc_async_test (int async __attribute__((unused)))
 229 {
 230   return 1;
 231 }
 232
 233 STATIC int
 234 GOMP_OFFLOAD_openacc_async_test_all (void)
 235 {
 236   return 1;
 237 }
 238
 239 STATIC void
 240 GOMP_OFFLOAD_openacc_async_wait (int async __attribute__((unused)))
 241 {
 242 }
 243
 244 STATIC void
 245 GOMP_OFFLOAD_openacc_async_wait_all (void)
 246 {
 247 }
 248
 249 STATIC void
 250 GOMP_OFFLOAD_openacc_async_wait_async (int async1 __attribute__((unused)),
 251                                        int async2 __attribute__((unused)))
 252 {
 253 }
 254
 255 STATIC void
 256 GOMP_OFFLOAD_openacc_async_wait_all_async (int async __attribute__((unused)))
 257 {
 258 }
 259
 260 STATIC void *
 261 GOMP_OFFLOAD_openacc_create_thread_data (void *targ_data
 262                                          __attribute__((unused)))
 263 {
 264   return NULL;
 265 }
 266
 267 STATIC void
 268 GOMP_OFFLOAD_openacc_destroy_thread_data (void *tls_data
 269                                           __attribute__((unused)))
 270 {
 271 }