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
|
/*
* Copyright (C) 2019-2024 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 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;
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);
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();
BuiltIns *getBuiltIns();
BindlessHeapsHelper *getBindlessHeapsHelper() const;
AssertHandler *getAssertHandler(Device *neoDevice);
void createBindlessHeapsHelper(Device *rootDevice, bool availableDevices);
void limitNumberOfCcs(uint32_t numberOfCcs);
bool isNumberOfCcsLimited() const;
void setRcsExposure();
void initProductHelper();
void initHelpers();
void initGfxCoreHelper();
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();
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<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<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;
std::once_flag isDummyAllocationInitialized;
std::unique_ptr<AllocationProperties> dummyBlitProperties;
private:
std::mutex mtx;
};
} // namespace NEO
|
