1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
|
//===-- Shared/APITypes.h - Offload and plugin API types --------*- 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
//
//===----------------------------------------------------------------------===//
//
// This file defines types used in the interface between the user code, the
// target independent offload runtime library, and target dependent plugins.
//
//===----------------------------------------------------------------------===//
#ifndef OMPTARGET_SHARED_API_TYPES_H
#define OMPTARGET_SHARED_API_TYPES_H
#include "Environment.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/Frontend/Offloading/Utility.h"
#include <cstddef>
#include <cstdint>
extern "C" {
/// 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
llvm::offloading::EntryTy
*EntriesBegin; // Begin of table with all target entries
llvm::offloading::EntryTy *EntriesEnd; // End of table (non inclusive)
};
struct __tgt_device_info {
void *Context = nullptr;
void *Device = nullptr;
};
/// 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)
llvm::offloading::EntryTy
*HostEntriesBegin; // Begin of table with all host entries
llvm::offloading::EntryTy *HostEntriesEnd; // End of table (non inclusive)
};
/// This struct contains the offload entries identified by the target runtime
struct __tgt_target_table {
llvm::offloading::EntryTy
*EntriesBegin; // Begin of the table with all the entries
llvm::offloading::EntryTy
*EntriesEnd; // End of the table with all the entries (non inclusive)
};
/// This struct contains a handle to a loaded binary in the plugin device.
struct __tgt_device_binary {
uintptr_t handle;
};
// 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;
/// A collection of allocations that are associated with this stream and that
/// should be freed after finalization.
llvm::SmallVector<void *, 2> AssociatedAllocations;
/// The kernel launch environment used to issue a kernel. Stored here to
/// ensure it is a valid location while the transfer to the device is
/// happening.
KernelLaunchEnvironmentTy KernelLaunchEnvironment;
};
/// This struct contains all of the arguments to a target kernel region launch.
struct KernelArgsTy {
uint32_t Version = 0; // Version of this struct for ABI compatibility.
uint32_t NumArgs = 0; // Number of arguments in each input pointer.
void **ArgBasePtrs =
nullptr; // Base pointer of each argument (e.g. a struct).
void **ArgPtrs = nullptr; // Pointer to the argument data.
int64_t *ArgSizes = nullptr; // Size of the argument data in bytes.
int64_t *ArgTypes = nullptr; // Type of the data (e.g. to / from).
void **ArgNames = nullptr; // Name of the data for debugging, possibly null.
void **ArgMappers = nullptr; // User-defined mappers, possibly null.
uint64_t Tripcount =
0; // Tripcount for the teams / distribute loop, 0 otherwise.
struct {
uint64_t NoWait : 1; // Was this kernel spawned with a `nowait` clause.
uint64_t IsCUDA : 1; // Was this kernel spawned via CUDA.
uint64_t Unused : 62;
} Flags = {0, 0, 0};
// The number of teams (for x,y,z dimension).
uint32_t NumTeams[3] = {0, 0, 0};
// The number of threads (for x,y,z dimension).
uint32_t ThreadLimit[3] = {0, 0, 0};
uint32_t DynCGroupMem = 0; // Amount of dynamic cgroup memory requested.
};
static_assert(sizeof(KernelArgsTy().Flags) == sizeof(uint64_t),
"Invalid struct size");
/*static_assert(sizeof(KernelArgsTy) ==
(8 * sizeof(int32_t) + 3 * sizeof(int64_t) +
4 * sizeof(void **) + 2 * sizeof(int64_t *)),
"Invalid struct size");*/
/// Flat array of kernel launch parameters and their total size.
struct KernelLaunchParamsTy {
/// Size of the Data array.
size_t Size = 0;
/// Flat array of kernel parameters.
void *Data = nullptr;
/// Ptrs to the Data entries. Only strictly required for the host plugin.
void **Ptrs = nullptr;
};
}
#endif // OMPTARGET_SHARED_API_TYPES_H
|
