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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
|
//===--- Level Zero Target RTL Implementation -----------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
// Level Zero Program abstraction.
//
//===----------------------------------------------------------------------===//
#ifndef OPENMP_LIBOMPTARGET_PLUGINS_NEXTGEN_LEVEL_ZERO_L0PROGRAM_H
#define OPENMP_LIBOMPTARGET_PLUGINS_NEXTGEN_LEVEL_ZERO_L0PROGRAM_H
#include "L0Kernel.h"
namespace llvm::omp::target::plugin {
class L0DeviceTy;
/// Program data to be initialized by plugin.
struct ProgramDataTy {
int Initialized = 0;
int NumDevices = 0;
int DeviceNum = -1;
uint32_t TotalEUs = 0;
uint32_t HWThreadsPerEU = 0;
uintptr_t DynamicMemoryLB = 0;
uintptr_t DynamicMemoryUB = 0;
int DeviceType = 0;
void *DynamicMemPool = nullptr;
int TeamsThreadLimit = 0;
};
class L0ProgramBuilderTy {
L0DeviceTy &Device;
std::unique_ptr<MemoryBuffer> Image;
/// Handle multiple modules within a single target image.
llvm::SmallVector<ze_module_handle_t> Modules;
/// Module that contains global data including device RTL.
ze_module_handle_t GlobalModule = nullptr;
/// Requires module link.
bool RequiresModuleLink = false;
/// Build a single module with the given image, build option, and format.
Error addModule(const size_t Size, const uint8_t *Image,
const std::string_view BuildOption,
ze_module_format_t Format);
Error linkModules();
public:
L0ProgramBuilderTy(L0DeviceTy &Device, std::unique_ptr<MemoryBuffer> &&Image)
: Device(Device), Image(std::move(Image)) {}
~L0ProgramBuilderTy() = default;
L0DeviceTy &getL0Device() const { return Device; }
ze_module_handle_t getGlobalModule() const { return GlobalModule; }
llvm::SmallVector<ze_module_handle_t> &getModules() { return Modules; }
MemoryBufferRef getMemoryBuffer() const { return MemoryBufferRef(*Image); }
Error buildModules(const std::string_view BuildOptions);
/// Retrieve the ELF binary for the program.
Expected<std::unique_ptr<MemoryBuffer>> getELF();
};
/// Level Zero program that can contain multiple modules.
class L0ProgramTy : public DeviceImageTy {
/// Handle multiple modules within a single target image.
llvm::SmallVector<ze_module_handle_t> Modules;
/// Map of kernel names to Modules
std::unordered_map<std::string, ze_module_handle_t> KernelsToModuleMap;
/// List of kernels built for this image.
/// We need to delete them ourselves as the main library is not doing
/// that right now.
std::list<L0KernelTy *> Kernels;
/// Module that contains global data including device RTL.
ze_module_handle_t GlobalModule = nullptr;
L0DeviceTy &getL0Device() const;
public:
L0ProgramTy() = delete;
L0ProgramTy(int32_t ImageId, GenericDeviceTy &Device,
std::unique_ptr<MemoryBuffer> Image,
ze_module_handle_t GlobalModule,
llvm::SmallVector<ze_module_handle_t> &&Modules)
: DeviceImageTy(ImageId, Device, std::move(Image)),
Modules(std::move(Modules)), GlobalModule(GlobalModule) {}
~L0ProgramTy() = default;
L0ProgramTy(const L0ProgramTy &other) = delete;
L0ProgramTy(L0ProgramTy &&) = delete;
L0ProgramTy &operator=(const L0ProgramTy &) = delete;
L0ProgramTy &operator=(const L0ProgramTy &&) = delete;
Error deinit();
static L0ProgramTy &makeL0Program(DeviceImageTy &Device) {
return static_cast<L0ProgramTy &>(Device);
}
/// Loads the kernels names from all modules.
Error loadModuleKernels();
/// Read data from the location in the device image which corresponds to the
/// specified global variable name.
Error readGlobalVariable(const char *Name, size_t Size, void *HostPtr);
/// Write data to the location in the device image which corresponds to the
/// specified global variable name.
Error writeGlobalVariable(const char *Name, size_t Size, const void *HostPtr);
/// Looks up a device global symbol with the given \p Name in the device.
Expected<void *> getSymbolDeviceAddr(const char *Name) const;
/// Returns the handle of a module that contains a given Kernel name.
ze_module_handle_t findModuleFromKernelName(const char *KernelName) const {
auto K = KernelsToModuleMap.find(std::string(KernelName));
if (K == KernelsToModuleMap.end())
return nullptr;
return K->second;
}
void addKernel(L0KernelTy *Kernel) { Kernels.push_back(Kernel); }
};
struct L0GlobalHandlerTy final : public GenericGlobalHandlerTy {
Error getGlobalMetadataFromDevice(GenericDeviceTy &Device,
DeviceImageTy &Image,
GlobalTy &DeviceGlobal) override;
};
bool isValidOneOmpImage(StringRef Image, uint64_t &MajorVer,
uint64_t &MinorVer);
} // namespace llvm::omp::target::plugin
#endif // OPENMP_LIBOMPTARGET_PLUGINS_NEXTGEN_LEVEL_ZERO_L0PROGRAM_H
|
