void
acc_set_device_type (acc_device_t d)
{
struct gomp_device_descr *base_dev, *acc_dev;
struct goacc_thread *thr = goacc_thread ();
gomp_mutex_lock (&acc_device_lock);
if (!cached_base_dev)
gomp_init_targets_once ();
cached_base_dev = base_dev = resolve_device (d);
acc_dev = &base_dev[goacc_device_num];
gomp_mutex_lock (&acc_dev->lock);
if (!acc_dev->is_initialized)
gomp_init_device (acc_dev);
gomp_mutex_unlock (&acc_dev->lock);
gomp_mutex_unlock (&acc_device_lock);
/* We're changing device type: invalidate the current thread's dev and
base_dev pointers. */
if (thr && thr->base_dev != base_dev)
{
thr->base_dev = thr->dev = NULL;
if (thr->mapped_data)
gomp_fatal ("acc_set_device_type in 'acc data' region");
}
goacc_attach_host_thread_to_device (-1);
}
void
acc_shutdown (acc_device_t d)
{
gomp_init_targets_once ();
gomp_mutex_lock (&acc_device_lock);
acc_shutdown_1 (d);
gomp_mutex_unlock (&acc_device_lock);
}
void
acc_init (acc_device_t d)
{
if (!cached_base_dev)
gomp_init_targets_once ();
gomp_mutex_lock (&acc_device_lock);
cached_base_dev = acc_init_1 (d);
gomp_mutex_unlock (&acc_device_lock);
goacc_attach_host_thread_to_device (-1);
}
void
acc_set_device_num (int n, acc_device_t d)
{
const struct gomp_device_descr *dev;
int num_devices;
if (!base_dev)
gomp_init_targets_once ();
if ((int) d == 0)
{
int i;
/* A device setting of zero sets all device types on the system to use
the Nth instance of that device type. Only attempt it for initialized
devices though. */
for (i = acc_device_not_host + 1; i < _ACC_device_hwm; i++)
{
dev = resolve_device (d);
if (dev && dev->is_initialized)
dev->openacc.set_device_num_func (n);
}
/* ...and for future calls to acc_init/acc_set_device_type, etc. */
goacc_device_num = n;
}
else
{
struct goacc_thread *thr = goacc_thread ();
gomp_mutex_lock (&acc_device_lock);
base_dev = lazy_init (d);
num_devices = base_dev->get_num_devices_func ();
if (n >= num_devices)
gomp_fatal ("device %u out of range", n);
/* If we're changing the device number, de-associate this thread with
the device (but don't close the device, since it may be in use by
other threads). */
if (thr && thr->dev && n != thr->dev->target_id)
thr->dev = NULL;
lazy_open (n);
gomp_mutex_unlock (&acc_device_lock);
}
}
static void
lazy_init_and_open (acc_device_t d)
{
if (!base_dev)
gomp_init_targets_once ();
gomp_mutex_lock (&acc_device_lock);
base_dev = lazy_init (d);
lazy_open (-1);
gomp_mutex_unlock (&acc_device_lock);
}
void
acc_init (acc_device_t d)
{
if (!base_dev)
gomp_init_targets_once ();
gomp_mutex_lock (&acc_device_lock);
base_dev = acc_init_1 (d);
lazy_open (-1);
gomp_mutex_unlock (&acc_device_lock);
}
void
acc_set_device_num (int ord, acc_device_t d)
{
struct gomp_device_descr *base_dev, *acc_dev;
int num_devices;
if (!cached_base_dev)
gomp_init_targets_once ();
if (ord < 0)
ord = goacc_device_num;
if ((int) d == 0)
/* Set whatever device is being used by the current host thread to use
device instance ORD. It's unclear if this is supposed to affect other
host threads too (OpenACC 2.0 (3.2.4) acc_set_device_num). */
goacc_attach_host_thread_to_device (ord);
else
{
gomp_mutex_lock (&acc_device_lock);
cached_base_dev = base_dev = resolve_device (d);
num_devices = base_dev->get_num_devices_func ();
if (ord >= num_devices)
gomp_fatal ("device %u out of range", ord);
acc_dev = &base_dev[ord];
gomp_mutex_lock (&acc_dev->lock);
if (!acc_dev->is_initialized)
gomp_init_device (acc_dev);
gomp_mutex_unlock (&acc_dev->lock);
gomp_mutex_unlock (&acc_device_lock);
goacc_attach_host_thread_to_device (ord);
}
goacc_device_num = ord;
}
int
acc_get_device_num (acc_device_t d)
{
const struct gomp_device_descr *dev;
struct goacc_thread *thr = goacc_thread ();
if (d >= _ACC_device_hwm)
gomp_fatal ("unknown device type %u", (unsigned) d);
if (!cached_base_dev)
gomp_init_targets_once ();
gomp_mutex_lock (&acc_device_lock);
dev = resolve_device (d, true);
gomp_mutex_unlock (&acc_device_lock);
if (thr && thr->base_dev == dev && thr->dev)
return thr->dev->target_id;
return goacc_device_num;
}
acc_device_t
acc_get_device_type (void)
{
acc_device_t res = acc_device_none;
const struct gomp_device_descr *dev;
if (base_dev)
res = acc_device_type (base_dev->type);
else
{
gomp_init_targets_once ();
dev = resolve_device (acc_device_default);
res = acc_device_type (dev->type);
}
assert (res != acc_device_default
&& res != acc_device_not_host);
return res;
}
int
acc_get_num_devices (acc_device_t d)
{
int n = 0;
const struct gomp_device_descr *acc_dev;
if (d == acc_device_none)
return 0;
if (!base_dev)
gomp_init_targets_once ();
acc_dev = resolve_device (d);
if (!acc_dev)
return 0;
n = acc_dev->get_num_devices_func ();
if (n < 0)
n = 0;
return n;
}
int
acc_get_device_num (acc_device_t d)
{
const struct gomp_device_descr *dev;
struct goacc_thread *thr = goacc_thread ();
if (d >= _ACC_device_hwm)
gomp_fatal ("device %u out of range", (unsigned)d);
if (!cached_base_dev)
gomp_init_targets_once ();
gomp_mutex_lock (&acc_device_lock);
dev = resolve_device (d);
gomp_mutex_unlock (&acc_device_lock);
if (!dev)
gomp_fatal ("device %s not supported", name_of_acc_device_t (d));
if (thr && thr->base_dev == dev && thr->dev)
return thr->dev->target_id;
return goacc_device_num;
}
acc_device_t
acc_get_device_type (void)
{
acc_device_t res = acc_device_none;
struct gomp_device_descr *dev;
struct goacc_thread *thr = goacc_thread ();
if (thr && thr->base_dev)
res = acc_device_type (thr->base_dev->type);
else
{
gomp_init_targets_once ();
gomp_mutex_lock (&acc_device_lock);
dev = resolve_device (acc_device_default);
gomp_mutex_unlock (&acc_device_lock);
res = acc_device_type (dev->type);
}
assert (res != acc_device_default
&& res != acc_device_not_host);
return res;
}
int
acc_get_num_devices (acc_device_t d)
{
int n = 0;
struct gomp_device_descr *acc_dev;
if (d == acc_device_none)
return 0;
gomp_init_targets_once ();
gomp_mutex_lock (&acc_device_lock);
acc_dev = resolve_device (d);
gomp_mutex_unlock (&acc_device_lock);
if (!acc_dev)
return 0;
n = acc_dev->get_num_devices_func ();
if (n < 0)
n = 0;
return n;
}
int
acc_get_device_num (acc_device_t d)
{
const struct gomp_device_descr *dev;
int num;
if (d >= _ACC_device_hwm)
gomp_fatal ("device %u out of range", (unsigned)d);
if (!base_dev)
gomp_init_targets_once ();
dev = resolve_device (d);
if (!dev)
gomp_fatal ("no devices of type %u", d);
/* We might not have called lazy_open for this host thread yet, in which case
the get_device_num_func hook will return -1. */
num = dev->openacc.get_device_num_func ();
if (num < 0)
num = goacc_device_num;
return num;
}
