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
148
149
150
151
152
153
154
155
156
157
158
|
/*
* Copyright (C) 2019-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "shared/source/built_ins/sip_kernel_type.h"
#include "shared/source/helpers/affinity_mask.h"
#include "shared/source/helpers/non_copyable_or_moveable.h"
#include "shared/source/helpers/options.h"
#include <functional>
#include <memory>
#include <mutex>
namespace NEO {
class AssertHandler;
class AubCenter;
class BindlessHeapsHelper;
class BuiltIns;
class CompilerInterface;
class SipExternalLib;
class Debugger;
class Device;
class ExecutionEnvironment;
class GmmClientContext;
class GmmHelper;
class GmmPageTableMngr;
class HwDeviceId;
class MemoryManager;
class MemoryOperationsHandler;
class OSInterface;
class OSTime;
class SipKernel;
class SWTagsManager;
class ProductHelper;
class GfxCoreHelper;
class ApiGfxCoreHelper;
class CompilerProductHelper;
class GraphicsAllocation;
class ReleaseHelper;
class AILConfiguration;
class HostFunctionWorker;
struct AllocationProperties;
struct HardwareInfo;
struct RootDeviceEnvironment : NonCopyableClass {
protected:
std::unique_ptr<HardwareInfo> hwInfo;
public:
RootDeviceEnvironment(ExecutionEnvironment &executionEnvironment);
MOCKABLE_VIRTUAL ~RootDeviceEnvironment();
MOCKABLE_VIRTUAL const HardwareInfo *getHardwareInfo() const;
HardwareInfo *getMutableHardwareInfo() const;
void setHwInfoAndInitHelpers(const HardwareInfo *hwInfo);
void setHwInfo(const HardwareInfo *hwInfo);
bool isFullRangeSvm() const;
bool isWddmOnLinux() const;
MOCKABLE_VIRTUAL void initAubCenter(bool localMemoryEnabled, const std::string &aubFileName, CommandStreamReceiverType csrType);
MOCKABLE_VIRTUAL bool initOsInterface(std::unique_ptr<HwDeviceId> &&hwDeviceId, uint32_t rootDeviceIndex);
void initOsTime();
void initGmm();
void initDebuggerL0(Device *neoDevice);
void initWaitUtils();
MOCKABLE_VIRTUAL void initDummyAllocation();
void setDummyBlitProperties(uint32_t rootDeviceIndex);
MOCKABLE_VIRTUAL void prepareForCleanup() const;
MOCKABLE_VIRTUAL bool initAilConfiguration();
GmmHelper *getGmmHelper() const;
GmmClientContext *getGmmClientContext() const;
MOCKABLE_VIRTUAL CompilerInterface *getCompilerInterface();
MOCKABLE_VIRTUAL SipExternalLib *getSipExternalLibInterface();
BuiltIns *getBuiltIns();
BindlessHeapsHelper *getBindlessHeapsHelper() const;
AssertHandler *getAssertHandler(Device *neoDevice);
void createBindlessHeapsHelper(Device *rootDevice, bool availableDevices);
bool setNumberOfCcs(uint32_t numberOfCcs);
uint32_t getNumberOfCcs() const;
bool isNumberOfCcsLimited() const;
void setRcsExposure();
void initProductHelper();
void initHelpers();
void initGfxCoreHelper();
void initializeGfxCoreHelperFromHwInfo();
void initializeGfxCoreHelperFromProductHelper();
void initApiGfxCoreHelper();
void initCompilerProductHelper();
void initReleaseHelper();
void initAilConfigurationHelper();
ReleaseHelper *getReleaseHelper() const;
AILConfiguration *getAILConfigurationHelper() const;
template <typename HelperType>
HelperType &getHelper() const;
const ProductHelper &getProductHelper() const;
GraphicsAllocation *getDummyAllocation() const;
void releaseDummyAllocation();
void setExposeSingleDeviceMode(bool singleDeviceMode) {
exposeSingleDevice = singleDeviceMode;
}
bool isExposeSingleDeviceMode() const {
return exposeSingleDevice;
}
void setHostFunctionScheduler(std::unique_ptr<HostFunctionWorker> &&scheduler);
HostFunctionWorker *getHostFunctionScheduler() const;
std::unique_ptr<SipKernel> sipKernels[static_cast<uint32_t>(SipKernelType::count)];
std::unique_ptr<GmmHelper> gmmHelper;
std::unique_ptr<OSInterface> osInterface;
std::unique_ptr<MemoryOperationsHandler> memoryOperationsInterface;
std::unique_ptr<AubCenter> aubCenter;
std::unique_ptr<OSTime> osTime;
std::unique_ptr<CompilerInterface> compilerInterface;
std::unique_ptr<SipExternalLib> sipExternalLib;
std::unique_ptr<BuiltIns> builtins;
std::unique_ptr<Debugger> debugger;
std::unique_ptr<SWTagsManager> tagsManager;
std::unique_ptr<ApiGfxCoreHelper> apiGfxCoreHelper;
std::unique_ptr<GfxCoreHelper> gfxCoreHelper;
std::unique_ptr<ProductHelper> productHelper;
std::unique_ptr<CompilerProductHelper> compilerProductHelper;
std::unique_ptr<ReleaseHelper> releaseHelper;
std::unique_ptr<AILConfiguration> ailConfiguration;
std::unique_ptr<BindlessHeapsHelper> bindlessHeapsHelper;
std::unique_ptr<HostFunctionWorker> hostFunctionScheduler;
std::unique_ptr<AssertHandler> assertHandler;
ExecutionEnvironment &executionEnvironment;
AffinityMaskHelper deviceAffinityMask{true};
protected:
using GraphicsAllocationUniquePtrType = std::unique_ptr<GraphicsAllocation, std::function<void(GraphicsAllocation *)>>;
GraphicsAllocationUniquePtrType dummyAllocation = nullptr;
bool limitedNumberOfCcs = false;
bool isWddmOnLinuxEnable = false;
bool exposeSingleDevice = false;
std::once_flag isDummyAllocationInitialized;
std::unique_ptr<AllocationProperties> dummyBlitProperties;
private:
std::mutex mtx;
};
static_assert(NEO::NonCopyable<RootDeviceEnvironment>);
} // namespace NEO
|
