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
|
/*
* Copyright (C) 2018-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "shared/source/aub/aub_helper.h"
#include "shared/source/command_stream/command_stream_receiver_simulated_common_hw.h"
#include "shared/source/gmm_helper/cache_settings_helper.h"
#include "shared/source/gmm_helper/gmm.h"
#include "shared/source/helpers/gfx_core_helper.h"
#include "shared/source/helpers/hardware_context_controller.h"
#include "shared/source/memory_manager/physical_address_allocator.h"
#include "shared/source/os_interface/os_context.h"
#include "aubstream/allocation_params.h"
#include "aubstream/hint_values.h"
namespace NEO {
class GraphicsAllocation;
template <typename GfxFamily>
class CommandStreamReceiverSimulatedHw : public CommandStreamReceiverSimulatedCommonHw<GfxFamily> {
protected:
using CommandStreamReceiverSimulatedCommonHw<GfxFamily>::CommandStreamReceiverSimulatedCommonHw;
using CommandStreamReceiverSimulatedCommonHw<GfxFamily>::osContext;
using CommandStreamReceiverSimulatedCommonHw<GfxFamily>::getDeviceIndex;
using CommandStreamReceiverSimulatedCommonHw<GfxFamily>::aubManager;
using CommandStreamReceiverSimulatedCommonHw<GfxFamily>::hardwareContextController;
using CommandStreamReceiverSimulatedCommonHw<GfxFamily>::writeMemory;
using CommandStreamReceiverSimulatedCommonHw<GfxFamily>::downloadAllocations;
public:
uint32_t getMemoryBank(GraphicsAllocation *allocation) const {
if (aubManager) {
return static_cast<uint32_t>(getMemoryBanksBitfield(allocation).to_ulong());
}
uint32_t deviceIndexChosen = allocation->storageInfo.memoryBanks.any()
? getDeviceIndexFromStorageInfo(allocation->storageInfo)
: getDeviceIndex();
if (allocation->getMemoryPool() == MemoryPool::localMemory) {
return MemoryBanks::getBankForLocalMemory(deviceIndexChosen);
}
return MemoryBanks::getBank(deviceIndexChosen);
}
static uint32_t getDeviceIndexFromStorageInfo(StorageInfo storageInfo) {
uint32_t deviceIndex = 0;
while (!storageInfo.memoryBanks.test(0)) {
storageInfo.memoryBanks >>= 1;
deviceIndex++;
}
return deviceIndex;
}
DeviceBitfield getMemoryBanksBitfield(GraphicsAllocation *allocation) const {
if (allocation->getMemoryPool() == MemoryPool::localMemory) {
if (allocation->storageInfo.memoryBanks.any()) {
if (allocation->storageInfo.cloningOfPageTables || this->isMultiOsContextCapable()) {
return allocation->storageInfo.memoryBanks;
}
}
return this->osContext->getDeviceBitfield();
}
return {};
}
PhysicalAddressAllocator *createPhysicalAddressAllocator(const HardwareInfo *hwInfo, const ReleaseHelper *releaseHelper) {
const auto bankSize = AubHelper::getPerTileLocalMemorySize(hwInfo, releaseHelper);
const auto devicesCount = GfxCoreHelper::getSubDevicesCount(hwInfo);
return new PhysicalAddressAllocatorHw<GfxFamily>(bankSize, devicesCount);
}
void writeMemoryWithAubManager(GraphicsAllocation &graphicsAllocation, bool isChunkCopy, uint64_t gpuVaChunkOffset, size_t chunkSize) override {
uint64_t gpuAddress;
void *cpuAddress;
size_t allocSize;
this->getParametersForMemory(graphicsAllocation, gpuAddress, cpuAddress, allocSize);
int hint = graphicsAllocation.getAllocationType() == AllocationType::commandBuffer
? aub_stream::DataTypeHintValues::TraceBatchBuffer
: aub_stream::DataTypeHintValues::TraceNotype;
if (isChunkCopy) {
gpuAddress += gpuVaChunkOffset;
cpuAddress = ptrOffset(cpuAddress, static_cast<uintptr_t>(gpuVaChunkOffset));
allocSize = chunkSize;
}
std::unique_ptr<unsigned char[]> memoryCopy;
if (graphicsAllocation.isLocked() && debugManager.flags.CopyLockedMemoryBeforeWrite.get()) {
memoryCopy = std::make_unique_for_overwrite<unsigned char[]>(allocSize);
memcpy_s(memoryCopy.get(), allocSize, cpuAddress, allocSize);
cpuAddress = memoryCopy.get();
}
aub_stream::AllocationParams allocationParams(gpuAddress, cpuAddress, allocSize, this->getMemoryBank(&graphicsAllocation),
hint, graphicsAllocation.getUsedPageSize());
auto gmm = graphicsAllocation.getDefaultGmm();
if (gmm) {
allocationParams.additionalParams.compressionEnabled = gmm->isCompressionEnabled();
allocationParams.additionalParams.uncached = CacheSettingsHelper::isUncachedType(gmm->resourceParams.Usage);
}
if (graphicsAllocation.storageInfo.cloningOfPageTables || !graphicsAllocation.isAllocatedInLocalMemoryPool()) {
UNRECOVERABLE_IF(nullptr == aubManager);
aubManager->writeMemory2(allocationParams);
} else {
UNRECOVERABLE_IF(nullptr == hardwareContextController);
hardwareContextController->writeMemory(allocationParams);
}
}
void setAubWritable(bool writable, GraphicsAllocation &graphicsAllocation) override {
auto bank = getMemoryBank(&graphicsAllocation);
if (bank == 0u || graphicsAllocation.storageInfo.cloningOfPageTables) {
bank = GraphicsAllocation::defaultBank;
}
graphicsAllocation.setAubWritable(writable, bank);
}
bool isAubWritable(GraphicsAllocation &graphicsAllocation) const override {
auto bank = getMemoryBank(&graphicsAllocation);
if (bank == 0u || graphicsAllocation.storageInfo.cloningOfPageTables) {
bank = GraphicsAllocation::defaultBank;
}
return graphicsAllocation.isAubWritable(bank);
}
void setTbxWritable(bool writable, GraphicsAllocation &graphicsAllocation) override {
auto bank = getMemoryBank(&graphicsAllocation);
if (bank == 0u || graphicsAllocation.storageInfo.cloningOfPageTables) {
bank = GraphicsAllocation::defaultBank;
}
graphicsAllocation.setTbxWritable(writable, bank);
}
bool isTbxWritable(GraphicsAllocation &graphicsAllocation) const override {
auto bank = getMemoryBank(&graphicsAllocation);
if (bank == 0u || graphicsAllocation.storageInfo.cloningOfPageTables) {
bank = GraphicsAllocation::defaultBank;
}
return graphicsAllocation.isTbxWritable(bank);
}
};
} // namespace NEO
|
