path: root/libgomp/oacc-host.c

/* OpenACC Runtime Library: acc_device_host.

   Copyright (C) 2013-2022 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
   <http://www.gnu.org/licenses/>.  */

#include "libgomp.h"
#include "oacc-int.h"
#include "gomp-constants.h"

#include <stdbool.h>
#include <stddef.h>

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 (unsigned int omp_requires_mask __attribute__((unused)))
{
  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)),
		 uint64_t **f __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 union goacc_property_value
host_openacc_get_property (int n, enum goacc_property prop)
{
  union goacc_property_value nullval = { .val = 0 };

  if (n >= host_get_num_devices (0))
    return nullval;

  switch (prop)
    {
    case GOACC_PROPERTY_NAME:
      return (union goacc_property_value) { .ptr = "GOMP" };
    case GOACC_PROPERTY_VENDOR:
      return (union goacc_property_value) { .ptr = "GNU" };
    case GOACC_PROPERTY_DRIVER:
      return (union goacc_property_value) { .ptr = VERSION };
    case GOACC_PROPERTY_MEMORY:
    case GOACC_PROPERTY_FREE_MEMORY:
    default:
      return nullval;
    }
}

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 },
    .mem_map_rev = { NULL },
    /* .lock initialized 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,
      },

      .get_property_func = host_openacc_get_property,

      .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);
}