2518cc65d2
As reported by Guilherme Valarini [0], we used to pass stack allocations to calls that can nowadays be asynchronous. This is arguably a problem and it will inevitably result in UB. To remedy the situation we allocate the locations as part of the AsyncInfoTy object. The lifetime of that object matches what we need for now. If the synchronization is not tied to the AsyncInfoTy object anymore we might need to have a different buffer construct in global space. This should be back-ported to LLVM 12 but needs slight modifications as it is based on refactoring patches we do not need to backport. [0] https://lists.llvm.org/pipermail/openmp-dev/2021-February/003867.html Reviewed By: JonChesterfield Differential Revision: https://reviews.llvm.org/D96667
329 lines
14 KiB
C++
329 lines
14 KiB
C++
//===-------- omptarget.h - Target independent OpenMP target RTL -- C++ -*-===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// Interface to be used by Clang during the codegen of a
|
|
// target region.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef _OMPTARGET_H_
|
|
#define _OMPTARGET_H_
|
|
|
|
#include <deque>
|
|
#include <stddef.h>
|
|
#include <stdint.h>
|
|
|
|
#include <SourceInfo.h>
|
|
|
|
#define OFFLOAD_SUCCESS (0)
|
|
#define OFFLOAD_FAIL (~0)
|
|
|
|
#define OFFLOAD_DEVICE_DEFAULT -1
|
|
|
|
// Don't format out enums and structs.
|
|
// clang-format off
|
|
|
|
/// Data attributes for each data reference used in an OpenMP target region.
|
|
enum tgt_map_type {
|
|
// No flags
|
|
OMP_TGT_MAPTYPE_NONE = 0x000,
|
|
// copy data from host to device
|
|
OMP_TGT_MAPTYPE_TO = 0x001,
|
|
// copy data from device to host
|
|
OMP_TGT_MAPTYPE_FROM = 0x002,
|
|
// copy regardless of the reference count
|
|
OMP_TGT_MAPTYPE_ALWAYS = 0x004,
|
|
// force unmapping of data
|
|
OMP_TGT_MAPTYPE_DELETE = 0x008,
|
|
// map the pointer as well as the pointee
|
|
OMP_TGT_MAPTYPE_PTR_AND_OBJ = 0x010,
|
|
// pass device base address to kernel
|
|
OMP_TGT_MAPTYPE_TARGET_PARAM = 0x020,
|
|
// return base device address of mapped data
|
|
OMP_TGT_MAPTYPE_RETURN_PARAM = 0x040,
|
|
// private variable - not mapped
|
|
OMP_TGT_MAPTYPE_PRIVATE = 0x080,
|
|
// copy by value - not mapped
|
|
OMP_TGT_MAPTYPE_LITERAL = 0x100,
|
|
// mapping is implicit
|
|
OMP_TGT_MAPTYPE_IMPLICIT = 0x200,
|
|
// copy data to device
|
|
OMP_TGT_MAPTYPE_CLOSE = 0x400,
|
|
// runtime error if not already allocated
|
|
OMP_TGT_MAPTYPE_PRESENT = 0x1000,
|
|
// descriptor for non-contiguous target-update
|
|
OMP_TGT_MAPTYPE_NON_CONTIG = 0x100000000000,
|
|
// member of struct, member given by [16 MSBs] - 1
|
|
OMP_TGT_MAPTYPE_MEMBER_OF = 0xffff000000000000
|
|
};
|
|
|
|
enum OpenMPOffloadingDeclareTargetFlags {
|
|
/// Mark the entry as having a 'link' attribute.
|
|
OMP_DECLARE_TARGET_LINK = 0x01,
|
|
/// Mark the entry as being a global constructor.
|
|
OMP_DECLARE_TARGET_CTOR = 0x02,
|
|
/// Mark the entry as being a global destructor.
|
|
OMP_DECLARE_TARGET_DTOR = 0x04
|
|
};
|
|
|
|
enum OpenMPOffloadingRequiresDirFlags {
|
|
/// flag undefined.
|
|
OMP_REQ_UNDEFINED = 0x000,
|
|
/// no requires directive present.
|
|
OMP_REQ_NONE = 0x001,
|
|
/// reverse_offload clause.
|
|
OMP_REQ_REVERSE_OFFLOAD = 0x002,
|
|
/// unified_address clause.
|
|
OMP_REQ_UNIFIED_ADDRESS = 0x004,
|
|
/// unified_shared_memory clause.
|
|
OMP_REQ_UNIFIED_SHARED_MEMORY = 0x008,
|
|
/// dynamic_allocators clause.
|
|
OMP_REQ_DYNAMIC_ALLOCATORS = 0x010
|
|
};
|
|
|
|
/// This struct is a record of an entry point or global. For a function
|
|
/// entry point the size is expected to be zero
|
|
struct __tgt_offload_entry {
|
|
void *addr; // Pointer to the offload entry info (function or global)
|
|
char *name; // Name of the function or global
|
|
size_t size; // Size of the entry info (0 if it is a function)
|
|
int32_t flags; // Flags associated with the entry, e.g. 'link'.
|
|
int32_t reserved; // Reserved, to be used by the runtime library.
|
|
};
|
|
|
|
/// This struct is a record of the device image information
|
|
struct __tgt_device_image {
|
|
void *ImageStart; // Pointer to the target code start
|
|
void *ImageEnd; // Pointer to the target code end
|
|
__tgt_offload_entry *EntriesBegin; // Begin of table with all target entries
|
|
__tgt_offload_entry *EntriesEnd; // End of table (non inclusive)
|
|
};
|
|
|
|
/// This struct is a record of all the host code that may be offloaded to a
|
|
/// target.
|
|
struct __tgt_bin_desc {
|
|
int32_t NumDeviceImages; // Number of device types supported
|
|
__tgt_device_image *DeviceImages; // Array of device images (1 per dev. type)
|
|
__tgt_offload_entry *HostEntriesBegin; // Begin of table with all host entries
|
|
__tgt_offload_entry *HostEntriesEnd; // End of table (non inclusive)
|
|
};
|
|
|
|
/// This struct contains the offload entries identified by the target runtime
|
|
struct __tgt_target_table {
|
|
__tgt_offload_entry *EntriesBegin; // Begin of the table with all the entries
|
|
__tgt_offload_entry
|
|
*EntriesEnd; // End of the table with all the entries (non inclusive)
|
|
};
|
|
|
|
// clang-format on
|
|
|
|
/// This struct contains information exchanged between different asynchronous
|
|
/// operations for device-dependent optimization and potential synchronization
|
|
struct __tgt_async_info {
|
|
// A pointer to a queue-like structure where offloading operations are issued.
|
|
// We assume to use this structure to do synchronization. In CUDA backend, it
|
|
// is CUstream.
|
|
void *Queue = nullptr;
|
|
};
|
|
|
|
struct DeviceTy;
|
|
|
|
/// The libomptarget wrapper around a __tgt_async_info object directly
|
|
/// associated with a libomptarget layer device. RAII semantics to avoid
|
|
/// mistakes.
|
|
class AsyncInfoTy {
|
|
/// Locations we used in (potentially) asynchronous calls which should live
|
|
/// as long as this AsyncInfoTy object.
|
|
std::deque<void *> BufferLocations;
|
|
|
|
__tgt_async_info AsyncInfo;
|
|
DeviceTy &Device;
|
|
|
|
public:
|
|
AsyncInfoTy(DeviceTy &Device) : Device(Device) {}
|
|
~AsyncInfoTy() { synchronize(); }
|
|
|
|
/// Implicit conversion to the __tgt_async_info which is used in the
|
|
/// plugin interface.
|
|
operator __tgt_async_info *() { return &AsyncInfo; }
|
|
|
|
/// Synchronize all pending actions.
|
|
///
|
|
/// \returns OFFLOAD_FAIL or OFFLOAD_SUCCESS appropriately.
|
|
int synchronize();
|
|
|
|
/// Return a void* reference with a lifetime that is at least as long as this
|
|
/// AsyncInfoTy object. The location can be used as intermediate buffer.
|
|
void *&getVoidPtrLocation();
|
|
};
|
|
|
|
/// This struct is a record of non-contiguous information
|
|
struct __tgt_target_non_contig {
|
|
uint64_t Offset;
|
|
uint64_t Count;
|
|
uint64_t Stride;
|
|
};
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
int omp_get_num_devices(void);
|
|
int omp_get_initial_device(void);
|
|
void *omp_target_alloc(size_t size, int device_num);
|
|
void omp_target_free(void *device_ptr, int device_num);
|
|
int omp_target_is_present(void *ptr, int device_num);
|
|
int omp_target_memcpy(void *dst, void *src, size_t length, size_t dst_offset,
|
|
size_t src_offset, int dst_device, int src_device);
|
|
int omp_target_memcpy_rect(void *dst, void *src, size_t element_size,
|
|
int num_dims, const size_t *volume,
|
|
const size_t *dst_offsets, const size_t *src_offsets,
|
|
const size_t *dst_dimensions,
|
|
const size_t *src_dimensions, int dst_device,
|
|
int src_device);
|
|
int omp_target_associate_ptr(void *host_ptr, void *device_ptr, size_t size,
|
|
size_t device_offset, int device_num);
|
|
int omp_target_disassociate_ptr(void *host_ptr, int device_num);
|
|
|
|
/// add the clauses of the requires directives in a given file
|
|
void __tgt_register_requires(int64_t flags);
|
|
|
|
/// adds a target shared library to the target execution image
|
|
void __tgt_register_lib(__tgt_bin_desc *desc);
|
|
|
|
/// removes a target shared library from the target execution image
|
|
void __tgt_unregister_lib(__tgt_bin_desc *desc);
|
|
|
|
// creates the host to target data mapping, stores it in the
|
|
// libomptarget.so internal structure (an entry in a stack of data maps) and
|
|
// passes the data to the device;
|
|
void __tgt_target_data_begin(int64_t device_id, int32_t arg_num,
|
|
void **args_base, void **args, int64_t *arg_sizes,
|
|
int64_t *arg_types);
|
|
void __tgt_target_data_begin_nowait(int64_t device_id, int32_t arg_num,
|
|
void **args_base, void **args,
|
|
int64_t *arg_sizes, int64_t *arg_types,
|
|
int32_t depNum, void *depList,
|
|
int32_t noAliasDepNum,
|
|
void *noAliasDepList);
|
|
void __tgt_target_data_begin_mapper(ident_t *loc, int64_t device_id,
|
|
int32_t arg_num, void **args_base,
|
|
void **args, int64_t *arg_sizes,
|
|
int64_t *arg_types,
|
|
map_var_info_t *arg_names,
|
|
void **arg_mappers);
|
|
void __tgt_target_data_begin_nowait_mapper(
|
|
ident_t *loc, int64_t device_id, int32_t arg_num, void **args_base,
|
|
void **args, int64_t *arg_sizes, int64_t *arg_types,
|
|
map_var_info_t *arg_names, void **arg_mappers, int32_t depNum,
|
|
void *depList, int32_t noAliasDepNum, void *noAliasDepList);
|
|
|
|
// passes data from the target, release target memory and destroys the
|
|
// host-target mapping (top entry from the stack of data maps) created by
|
|
// the last __tgt_target_data_begin
|
|
void __tgt_target_data_end(int64_t device_id, int32_t arg_num, void **args_base,
|
|
void **args, int64_t *arg_sizes, int64_t *arg_types);
|
|
void __tgt_target_data_end_nowait(int64_t device_id, int32_t arg_num,
|
|
void **args_base, void **args,
|
|
int64_t *arg_sizes, int64_t *arg_types,
|
|
int32_t depNum, void *depList,
|
|
int32_t noAliasDepNum, void *noAliasDepList);
|
|
void __tgt_target_data_end_mapper(ident_t *loc, int64_t device_id,
|
|
int32_t arg_num, void **args_base,
|
|
void **args, int64_t *arg_sizes,
|
|
int64_t *arg_types, map_var_info_t *arg_names,
|
|
void **arg_mappers);
|
|
void __tgt_target_data_end_nowait_mapper(
|
|
ident_t *loc, int64_t device_id, int32_t arg_num, void **args_base,
|
|
void **args, int64_t *arg_sizes, int64_t *arg_types,
|
|
map_var_info_t *arg_names, void **arg_mappers, int32_t depNum,
|
|
void *depList, int32_t noAliasDepNum, void *noAliasDepList);
|
|
|
|
/// passes data to/from the target
|
|
void __tgt_target_data_update(int64_t device_id, int32_t arg_num,
|
|
void **args_base, void **args, int64_t *arg_sizes,
|
|
int64_t *arg_types);
|
|
void __tgt_target_data_update_nowait(int64_t device_id, int32_t arg_num,
|
|
void **args_base, void **args,
|
|
int64_t *arg_sizes, int64_t *arg_types,
|
|
int32_t depNum, void *depList,
|
|
int32_t noAliasDepNum,
|
|
void *noAliasDepList);
|
|
void __tgt_target_data_update_mapper(ident_t *loc, int64_t device_id,
|
|
int32_t arg_num, void **args_base,
|
|
void **args, int64_t *arg_sizes,
|
|
int64_t *arg_types,
|
|
map_var_info_t *arg_names,
|
|
void **arg_mappers);
|
|
void __tgt_target_data_update_nowait_mapper(
|
|
ident_t *loc, int64_t device_id, int32_t arg_num, void **args_base,
|
|
void **args, int64_t *arg_sizes, int64_t *arg_types,
|
|
map_var_info_t *arg_names, void **arg_mappers, int32_t depNum,
|
|
void *depList, int32_t noAliasDepNum, void *noAliasDepList);
|
|
|
|
// Performs the same actions as data_begin in case arg_num is non-zero
|
|
// and initiates run of offloaded region on target platform; if arg_num
|
|
// is non-zero after the region execution is done it also performs the
|
|
// same action as data_end above. The following types are used; this
|
|
// function returns 0 if it was able to transfer the execution to a
|
|
// target and an int different from zero otherwise.
|
|
int __tgt_target(int64_t device_id, void *host_ptr, int32_t arg_num,
|
|
void **args_base, void **args, int64_t *arg_sizes,
|
|
int64_t *arg_types);
|
|
int __tgt_target_nowait(int64_t device_id, void *host_ptr, int32_t arg_num,
|
|
void **args_base, void **args, int64_t *arg_sizes,
|
|
int64_t *arg_types, int32_t depNum, void *depList,
|
|
int32_t noAliasDepNum, void *noAliasDepList);
|
|
int __tgt_target_mapper(ident_t *loc, int64_t device_id, void *host_ptr,
|
|
int32_t arg_num, void **args_base, void **args,
|
|
int64_t *arg_sizes, int64_t *arg_types,
|
|
map_var_info_t *arg_names, void **arg_mappers);
|
|
int __tgt_target_nowait_mapper(ident_t *loc, int64_t device_id, void *host_ptr,
|
|
int32_t arg_num, void **args_base, void **args,
|
|
int64_t *arg_sizes, int64_t *arg_types,
|
|
map_var_info_t *arg_names, void **arg_mappers,
|
|
int32_t depNum, void *depList,
|
|
int32_t noAliasDepNum, void *noAliasDepList);
|
|
|
|
int __tgt_target_teams(int64_t device_id, void *host_ptr, int32_t arg_num,
|
|
void **args_base, void **args, int64_t *arg_sizes,
|
|
int64_t *arg_types, int32_t num_teams,
|
|
int32_t thread_limit);
|
|
int __tgt_target_teams_nowait(int64_t device_id, void *host_ptr,
|
|
int32_t arg_num, void **args_base, void **args,
|
|
int64_t *arg_sizes, int64_t *arg_types,
|
|
int32_t num_teams, int32_t thread_limit,
|
|
int32_t depNum, void *depList,
|
|
int32_t noAliasDepNum, void *noAliasDepList);
|
|
int __tgt_target_teams_mapper(ident_t *loc, int64_t device_id, void *host_ptr,
|
|
int32_t arg_num, void **args_base, void **args,
|
|
int64_t *arg_sizes, int64_t *arg_types,
|
|
map_var_info_t *arg_names, void **arg_mappers,
|
|
int32_t num_teams, int32_t thread_limit);
|
|
int __tgt_target_teams_nowait_mapper(
|
|
ident_t *loc, int64_t device_id, void *host_ptr, int32_t arg_num,
|
|
void **args_base, void **args, int64_t *arg_sizes, int64_t *arg_types,
|
|
map_var_info_t *arg_names, void **arg_mappers, int32_t num_teams,
|
|
int32_t thread_limit, int32_t depNum, void *depList, int32_t noAliasDepNum,
|
|
void *noAliasDepList);
|
|
|
|
void __kmpc_push_target_tripcount(ident_t *loc, int64_t device_id,
|
|
uint64_t loop_tripcount);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#ifdef __cplusplus
|
|
#define EXTERN extern "C"
|
|
#else
|
|
#define EXTERN extern
|
|
#endif
|
|
|
|
#endif // _OMPTARGET_H_
|