intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-11 00:10:58 +08:00
Code Issues Packages Projects Releases Wiki Activity

Move some mocks to shared

Browse Source 
- MockAllocationProperties
- MockBuiltinsLib
- MockWddmMemoryManager
- MockAubCsr


Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>
This commit is contained in:
Mateusz Jablonski
2021-10-14 16:53:11 +00:00
committed by Compute-Runtime-Automation
parent 8eb85e9365
commit 7b57e87ad1
100 changed files with 124 additions and 140 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
shared/test/common/fixtures/CMakeLists.txt
View File

@@ -11,6 +11,7 @@ target_sources(${TARGET_NAME} PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/front_window_fixture.cpp
${CMAKE_CURRENT_SOURCE_DIR}/front_window_fixture.h
${CMAKE_CURRENT_SOURCE_DIR}/implicit_scaling_fixture.h
${CMAKE_CURRENT_SOURCE_DIR}/linear_stream_fixture.h
${CMAKE_CURRENT_SOURCE_DIR}/preemption_fixture.cpp
${CMAKE_CURRENT_SOURCE_DIR}/preemption_fixture.h
)

34
shared/test/common/fixtures/linear_stream_fixture.h Normal file
View File

@@ -0,0 +1,34 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "shared/source/command_stream/linear_stream.h"
#include "shared/test/common/mocks/mock_graphics_allocation.h"
#include "test.h"
#include <cstdint>
namespace NEO {
struct LinearStreamFixture {
LinearStreamFixture(void)
: gfxAllocation(static_cast<void *>(pCmdBuffer), sizeof(pCmdBuffer)), linearStream(&gfxAllocation) {
}
virtual void SetUp(void) {
}
virtual void TearDown(void) {
}
MockGraphicsAllocation gfxAllocation;
LinearStream linearStream;
uint32_t pCmdBuffer[1024]{};
};
typedef Test<LinearStreamFixture> LinearStreamTest;
} // namespace NEO

3
shared/test/common/helpers/CMakeLists.txt
View File

@@ -18,8 +18,9 @@ set(NEO_CORE_HELPERS_TESTS
${CMAKE_CURRENT_SOURCE_DIR}/engine_descriptor_helper.h
${CMAKE_CURRENT_SOURCE_DIR}/engine_node_helper_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/file_io_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}hw_helper_extended_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/hash_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}hw_helper_extended_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/hw_helper_tests.h
${CMAKE_CURRENT_SOURCE_DIR}/kernel_binary_helper.h
${CMAKE_CURRENT_SOURCE_DIR}/kernel_filename_helper.h
${CMAKE_CURRENT_SOURCE_DIR}/kernel_helpers_tests.cpp

41
shared/test/common/helpers/hw_helper_tests.h Normal file
View File

@@ -0,0 +1,41 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "shared/source/device/device.h"
#include "shared/source/helpers/constants.h"
#include "shared/source/helpers/hw_helper.h"
#include "shared/test/common/fixtures/device_fixture.h"
#include "test.h"
using namespace NEO;
using HwHelperTest = Test<DeviceFixture>;
struct ComputeSlmTestInput {
uint32_t expected;
uint32_t slmSize;
};
constexpr ComputeSlmTestInput computeSlmValuesXeHPAndLaterTestsInput[] = {
{0, 0 * KB},
{1, 0 * KB + 1},
{1, 1 * KB},
{2, 1 * KB + 1},
{2, 2 * KB},
{3, 2 * KB + 1},
{3, 4 * KB},
{4, 4 * KB + 1},
{4, 8 * KB},
{5, 8 * KB + 1},
{5, 16 * KB},
{6, 16 * KB + 1},
{6, 32 * KB},
{7, 32 * KB + 1},
{7, 64 * KB}};

3
shared/test/common/mocks/CMakeLists.txt
View File

@@ -15,10 +15,13 @@ set_property(GLOBAL PROPERTY NEO_CORE_tests_compiler_mocks ${NEO_CORE_tests_comp
set(NEO_CORE_tests_mocks
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/mock_allocation_properties.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_aub_center.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_aub_csr.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_aub_file_stream.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_aub_manager.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_bindless_heaps_helper.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_builtinslib.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_cif.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_cif.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_command_stream_receiver.cpp

3
shared/test/common/mocks/linux/mock_drm_memory_manager.cpp
View File

@@ -9,11 +9,10 @@
#include "shared/source/os_interface/linux/allocator_helper.h"
#include "shared/source/os_interface/linux/drm_memory_manager.h"
#include "shared/test/common/mocks/mock_allocation_properties.h"
#include "shared/test/common/mocks/mock_host_ptr_manager.h"
#include "shared/test/common/mocks/mock_memory_manager.h"
#include "opencl/test/unit_test/mocks/mock_allocation_properties.h"
#include <atomic>
namespace NEO {

21
shared/test/common/mocks/mock_allocation_properties.h Normal file
View File

@@ -0,0 +1,21 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "shared/source/memory_manager/memory_manager.h"
#include "shared/test/common/mocks/mock_graphics_allocation.h"
namespace NEO {
struct MockAllocationProperties : public AllocationProperties {
MockAllocationProperties(uint32_t rootDeviceIndex, size_t size) : AllocationProperties(rootDeviceIndex, true, size, GraphicsAllocation::AllocationType::INTERNAL_HOST_MEMORY, false, mockDeviceBitfield) {}
MockAllocationProperties(uint32_t rootDeviceIndex, size_t size, DeviceBitfield deviceBitfield) : AllocationProperties(rootDeviceIndex, true, size, GraphicsAllocation::AllocationType::INTERNAL_HOST_MEMORY, false, deviceBitfield) {}
MockAllocationProperties(uint32_t rootDeviceIndex, bool allocateMemory, size_t size) : AllocationProperties(rootDeviceIndex, allocateMemory, size, GraphicsAllocation::AllocationType::INTERNAL_HOST_MEMORY, false, mockDeviceBitfield) {}
MockAllocationProperties(uint32_t rootDeviceIndex, bool allocateMemory, size_t size, DeviceBitfield deviceBitfield) : AllocationProperties(rootDeviceIndex, allocateMemory, size, GraphicsAllocation::AllocationType::INTERNAL_HOST_MEMORY, false, deviceBitfield) {}
MockAllocationProperties(uint32_t rootDeviceIndex, bool allocateMemory, size_t size, GraphicsAllocation::AllocationType allocationType) : AllocationProperties(rootDeviceIndex, allocateMemory, size, allocationType, false, mockDeviceBitfield) {}
MockAllocationProperties(uint32_t rootDeviceIndex, bool allocateMemory, size_t size, GraphicsAllocation::AllocationType allocationType, DeviceBitfield deviceBitfield) : AllocationProperties(rootDeviceIndex, allocateMemory, size, allocationType, false, deviceBitfield) {}
};
} // namespace NEO

223
shared/test/common/mocks/mock_aub_csr.h Normal file
View File

@@ -0,0 +1,223 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "shared/source/command_stream/aub_command_stream_receiver_hw.h"
#include "shared/source/command_stream/preemption.h"
#include "shared/source/execution_environment/execution_environment.h"
#include "shared/source/execution_environment/root_device_environment.h"
#include "shared/source/helpers/hw_info.h"
#include "shared/test/common/helpers/default_hw_info.h"
#include "shared/test/common/helpers/dispatch_flags_helper.h"
#include "shared/test/common/helpers/engine_descriptor_helper.h"
#include "shared/test/common/mocks/mock_allocation_properties.h"
#include "gmock/gmock.h"
#include <string>
namespace NEO {
struct MockAubFileStreamMockMmioWrite : public AubMemDump::AubFileStream {
void writeMMIOImpl(uint32_t offset, uint32_t value) override {
mmioList.push_back(std::make_pair(offset, value));
}
bool isOnMmioList(const MMIOPair &mmio) {
bool mmioFound = false;
for (auto &mmioPair : mmioList) {
if (mmioPair.first == mmio.first && mmioPair.second == mmio.second) {
mmioFound = true;
break;
}
}
return mmioFound;
}
std::vector<std::pair<uint32_t, uint32_t>> mmioList;
};
template <typename GfxFamily>
struct MockAubCsrToTestDumpContext : public AUBCommandStreamReceiverHw<GfxFamily> {
using AUBCommandStreamReceiverHw<GfxFamily>::AUBCommandStreamReceiverHw;
void addContextToken(uint32_t dumpHandle) override {
handle = dumpHandle;
}
uint32_t handle = 0;
};
template <typename GfxFamily>
struct MockAubCsr : public AUBCommandStreamReceiverHw<GfxFamily> {
using CommandStreamReceiverHw<GfxFamily>::defaultSshSize;
using AUBCommandStreamReceiverHw<GfxFamily>::taskCount;
using AUBCommandStreamReceiverHw<GfxFamily>::latestSentTaskCount;
using AUBCommandStreamReceiverHw<GfxFamily>::pollForCompletionTaskCount;
using AUBCommandStreamReceiverHw<GfxFamily>::getParametersForWriteMemory;
using AUBCommandStreamReceiverHw<GfxFamily>::writeMemory;
using AUBCommandStreamReceiverHw<GfxFamily>::AUBCommandStreamReceiverHw;
CompletionStamp flushTask(LinearStream &commandStream, size_t commandStreamStart,
const IndirectHeap &dsh, const IndirectHeap &ioh, const IndirectHeap &ssh,
uint32_t taskLevel, DispatchFlags &dispatchFlags, Device &device) override {
recordedDispatchFlags = dispatchFlags;
return AUBCommandStreamReceiverHw<GfxFamily>::flushTask(commandStream, commandStreamStart, dsh, ioh, ssh, taskLevel, dispatchFlags, device);
}
DispatchMode peekDispatchMode() const {
return this->dispatchMode;
}
GraphicsAllocation *getTagAllocation() const {
return this->tagAllocation;
}
bool flushBatchedSubmissions() override {
flushBatchedSubmissionsCalled = true;
return true;
}
void initProgrammingFlags() override {
initProgrammingFlagsCalled = true;
}
void initializeEngine() override {
AUBCommandStreamReceiverHw<GfxFamily>::initializeEngine();
initializeEngineCalled = true;
}
void writeMemory(uint64_t gpuAddress, void *cpuAddress, size_t size, uint32_t memoryBank, uint64_t entryBits) override {
AUBCommandStreamReceiverHw<GfxFamily>::writeMemory(gpuAddress, cpuAddress, size, memoryBank, entryBits);
writeMemoryCalled = true;
}
void writeMMIO(uint32_t offset, uint32_t value) override {
AUBCommandStreamReceiverHw<GfxFamily>::writeMMIO(offset, value);
writeMMIOCalled = true;
}
void submitBatchBufferAub(uint64_t batchBufferGpuAddress, const void *batchBuffer, size_t batchBufferSize, uint32_t memoryBank, uint64_t entryBits) override {
AUBCommandStreamReceiverHw<GfxFamily>::submitBatchBufferAub(batchBufferGpuAddress, batchBuffer, batchBufferSize, memoryBank, entryBits);
submitBatchBufferCalled = true;
}
void writeMemoryWithAubManager(GraphicsAllocation &graphicsAllocation) override {
CommandStreamReceiverSimulatedHw<GfxFamily>::writeMemoryWithAubManager(graphicsAllocation);
writeMemoryWithAubManagerCalled = true;
}
void pollForCompletion() override {
AUBCommandStreamReceiverHw<GfxFamily>::pollForCompletion();
pollForCompletionCalled = true;
}
bool expectMemoryEqual(void *gfxAddress, const void *srcAddress, size_t length) override {
expectMemoryEqualCalled = true;
return AUBCommandStreamReceiverHw<GfxFamily>::expectMemoryEqual(gfxAddress, srcAddress, length);
}
bool expectMemoryNotEqual(void *gfxAddress, const void *srcAddress, size_t length) override {
expectMemoryNotEqualCalled = true;
return AUBCommandStreamReceiverHw<GfxFamily>::expectMemoryNotEqual(gfxAddress, srcAddress, length);
}
bool expectMemoryCompressed(void *gfxAddress, const void *srcAddress, size_t length) override {
expectMemoryCompressedCalled = true;
return AUBCommandStreamReceiverHw<GfxFamily>::expectMemoryCompressed(gfxAddress, srcAddress, length);
}
bool waitForCompletionWithTimeout(bool enableTimeout, int64_t timeoutMicroseconds, uint32_t taskCountToWait) override {
return true;
}
void addAubComment(const char *message) override {
AUBCommandStreamReceiverHw<GfxFamily>::addAubComment(message);
addAubCommentCalled = true;
}
void dumpAllocation(GraphicsAllocation &gfxAllocation) override {
AUBCommandStreamReceiverHw<GfxFamily>::dumpAllocation(gfxAllocation);
dumpAllocationCalled = true;
}
bool isMultiOsContextCapable() const override {
return multiOsContextCapable;
}
DispatchFlags recordedDispatchFlags = DispatchFlagsHelper::createDefaultDispatchFlags();
bool multiOsContextCapable = false;
bool flushBatchedSubmissionsCalled = false;
bool initProgrammingFlagsCalled = false;
bool initializeEngineCalled = false;
bool writeMemoryCalled = false;
bool writeMemoryWithAubManagerCalled = false;
bool writeMMIOCalled = false;
bool submitBatchBufferCalled = false;
bool pollForCompletionCalled = false;
bool expectMemoryEqualCalled = false;
bool expectMemoryNotEqualCalled = false;
bool expectMemoryCompressedCalled = false;
bool addAubCommentCalled = false;
bool dumpAllocationCalled = false;
void initFile(const std::string &fileName) override {
fileIsOpen = true;
openFileName = fileName;
}
void closeFile() override {
fileIsOpen = false;
openFileName = "";
}
bool isFileOpen() const override {
return fileIsOpen;
}
const std::string getFileName() override {
return openFileName;
}
bool fileIsOpen = false;
std::string openFileName = "";
MOCK_METHOD(bool, addPatchInfoComments, (), (override));
using CommandStreamReceiverHw<GfxFamily>::localMemoryEnabled;
};
struct AubExecutionEnvironment {
std::unique_ptr<ExecutionEnvironment> executionEnvironment;
GraphicsAllocation *commandBuffer = nullptr;
std::unique_ptr<CommandStreamReceiver> commandStreamReceiver;
template <typename CsrType>
CsrType *getCsr() {
return static_cast<CsrType *>(commandStreamReceiver.get());
}
~AubExecutionEnvironment() {
if (commandBuffer) {
executionEnvironment->memoryManager->freeGraphicsMemory(commandBuffer);
}
}
};
template <typename CsrType>
std::unique_ptr<AubExecutionEnvironment> getEnvironment(bool createTagAllocation, bool allocateCommandBuffer, bool standalone) {
std::unique_ptr<ExecutionEnvironment> executionEnvironment(new ExecutionEnvironment);
DeviceBitfield deviceBitfield(1);
executionEnvironment->prepareRootDeviceEnvironments(1);
uint32_t rootDeviceIndex = 0u;
executionEnvironment->rootDeviceEnvironments[rootDeviceIndex]->setHwInfo(defaultHwInfo.get());
executionEnvironment->rootDeviceEnvironments[rootDeviceIndex]->aubCenter.reset(new AubCenter());
executionEnvironment->initializeMemoryManager();
auto commandStreamReceiver = std::make_unique<CsrType>("", standalone, *executionEnvironment, rootDeviceIndex, deviceBitfield);
auto osContext = executionEnvironment->memoryManager->createAndRegisterOsContext(commandStreamReceiver.get(),
EngineDescriptorHelper::getDefaultDescriptor({getChosenEngineType(*defaultHwInfo), EngineUsage::Regular},
PreemptionHelper::getDefaultPreemptionMode(*defaultHwInfo)));
commandStreamReceiver->setupContext(*osContext);
if (createTagAllocation) {
commandStreamReceiver->initializeTagAllocation();
}
commandStreamReceiver->createGlobalFenceAllocation();
std::unique_ptr<AubExecutionEnvironment> aubExecutionEnvironment(new AubExecutionEnvironment);
if (allocateCommandBuffer) {
aubExecutionEnvironment->commandBuffer = executionEnvironment->memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{rootDeviceIndex, MemoryConstants::pageSize});
}
aubExecutionEnvironment->executionEnvironment = std::move(executionEnvironment);
aubExecutionEnvironment->commandStreamReceiver = std::move(commandStreamReceiver);
return aubExecutionEnvironment;
}
} // namespace NEO

17
shared/test/common/mocks/mock_builtinslib.h Normal file
View File

@@ -0,0 +1,17 @@
/*
* Copyright (C) 2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "shared/source/built_ins/built_ins.h"
using namespace NEO;
class MockBuiltinsLib : BuiltinsLib {
public:
using BuiltinsLib::allStorages;
using BuiltinsLib::getBuiltinResource;
};

3
shared/test/common/mocks/mock_memory_manager.cpp
View File

@@ -11,8 +11,7 @@
#include "shared/source/gmm_helper/gmm.h"
#include "shared/source/helpers/surface_format_info.h"
#include "shared/source/memory_manager/deferred_deleter.h"
#include "opencl/test/unit_test/mocks/mock_allocation_properties.h"
#include "shared/test/common/mocks/mock_allocation_properties.h"
#include <cstring>

1
shared/test/common/os_interface/windows/CMakeLists.txt
View File

@@ -7,6 +7,7 @@
target_sources(${TARGET_NAME} PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/gdi_dll_fixture.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_wddm_memory_manager.h
${CMAKE_CURRENT_SOURCE_DIR}/wddm_fixture.h
)

86
shared/test/common/os_interface/windows/mock_wddm_memory_manager.h Normal file
View File

@@ -0,0 +1,86 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "shared/source/memory_manager/deferred_deleter.h"
#include "shared/source/os_interface/windows/wddm_memory_manager.h"
#include "shared/test/common/mocks/mock_allocation_properties.h"
#include "shared/test/common/mocks/mock_host_ptr_manager.h"
#include "shared/test/common/mocks/mock_memory_manager.h"
namespace NEO {
class MockWddmMemoryManager : public MemoryManagerCreate<WddmMemoryManager> {
using BaseClass = WddmMemoryManager;
public:
using BaseClass::alignmentSelector;
using BaseClass::allocateGraphicsMemoryForNonSvmHostPtr;
using BaseClass::allocateGraphicsMemoryWithAlignment;
using BaseClass::allocateGraphicsMemoryWithGpuVa;
using BaseClass::allocateGraphicsMemoryWithProperties;
using BaseClass::allocateMemoryByKMD;
using BaseClass::createGraphicsAllocation;
using BaseClass::createWddmAllocation;
using BaseClass::getWddm;
using BaseClass::gfxPartitions;
using BaseClass::localMemorySupported;
using BaseClass::supportsMultiStorageResources;
using MemoryManagerCreate<WddmMemoryManager>::MemoryManagerCreate;
using BaseClass::getHugeGfxMemoryChunkSize;
GraphicsAllocation *allocateGraphicsMemory64kb(const AllocationData &allocationData) override {
allocationGraphicsMemory64kbCreated = true;
return BaseClass::allocateGraphicsMemory64kb(allocationData);
}
GraphicsAllocation *allocateGraphicsMemoryInDevicePool(const AllocationData &allocationData, AllocationStatus &status) override {
if (allocateGraphicsMemoryInNonDevicePool) {
status = AllocationStatus::RetryInNonDevicePool;
return nullptr;
}
return BaseClass::allocateGraphicsMemoryInDevicePool(allocationData, status);
}
size_t hugeGfxMemoryChunkSize = BaseClass::getHugeGfxMemoryChunkSize(preferredAllocationMethod);
size_t getHugeGfxMemoryChunkSize(GfxMemoryAllocationMethod allocationMethod) const override { return hugeGfxMemoryChunkSize; }
MockWddmMemoryManager(ExecutionEnvironment &executionEnvironment) : MemoryManagerCreate(false, false, executionEnvironment) {
hostPtrManager.reset(new MockHostPtrManager);
};
void setDeferredDeleter(DeferredDeleter *deleter) {
this->deferredDeleter.reset(deleter);
}
void setForce32bitAllocations(bool newValue) {
this->force32bitAllocations = newValue;
}
bool validateAllocationMock(WddmAllocation *graphicsAllocation) {
return this->validateAllocation(graphicsAllocation);
}
GraphicsAllocation *allocate32BitGraphicsMemory(uint32_t rootDeviceIndex, size_t size, const void *ptr, GraphicsAllocation::AllocationType allocationType) {
bool allocateMemory = ptr == nullptr;
AllocationData allocationData;
MockAllocationProperties properties(rootDeviceIndex, allocateMemory, size, allocationType);
getAllocationData(allocationData, properties, ptr, createStorageInfoFromProperties(properties));
bool useLocalMemory = !allocationData.flags.useSystemMemory && this->localMemorySupported[rootDeviceIndex];
return allocate32BitGraphicsMemoryImpl(allocationData, useLocalMemory);
}
void freeGraphicsMemoryImpl(GraphicsAllocation *gfxAllocation) override {
freeGraphicsMemoryImplCalled++;
BaseClass::freeGraphicsMemoryImpl(gfxAllocation);
}
GraphicsAllocation *allocateHugeGraphicsMemory(const AllocationData &allocationData, bool sharedVirtualAddress) override {
allocateHugeGraphicsMemoryCalled = true;
return BaseClass::allocateHugeGraphicsMemory(allocationData, sharedVirtualAddress);
}
uint32_t freeGraphicsMemoryImplCalled = 0u;
bool allocationGraphicsMemory64kbCreated = false;
bool allocateGraphicsMemoryInNonDevicePool = false;
bool allocateHugeGraphicsMemoryCalled = false;
};
} // namespace NEO

4
shared/test/common/xe_hp_core/xehp/test_preamble_xehp.cpp
View File

@@ -7,11 +7,11 @@
#include "shared/source/command_stream/preemption.h"
#include "shared/source/command_stream/stream_properties.h"
#include "shared/source/helpers/preamble.h"
#include "shared/test/common/cmd_parse/hw_parse.h"
#include "shared/test/common/mocks/mock_device.h"
#include "shared/test/common/mocks/mock_graphics_allocation.h"
#include "opencl/source/helpers/hardware_commands_helper.h"
#include "test.h"
using namespace NEO;
@@ -25,7 +25,7 @@ struct XeHPSlm : HardwareParse, ::testing::Test {
HardwareParse::TearDown();
}
uint32_t cmdBuffer[1024];
uint32_t cmdBuffer[1024]{};
MockGraphicsAllocation gfxAllocation{cmdBuffer, sizeof(cmdBuffer)};
LinearStream linearStream{&gfxAllocation};
};

2
shared/test/unit_test/memory_manager/deferrable_allocation_deletion_tests.cpp
View File

@@ -11,10 +11,10 @@
#include "shared/source/memory_manager/deferred_deleter.h"
#include "shared/source/os_interface/os_context.h"
#include "shared/test/common/libult/ult_command_stream_receiver.h"
#include "shared/test/common/mocks/mock_allocation_properties.h"
#include "shared/test/common/mocks/mock_device.h"
#include "shared/test/common/mocks/mock_memory_manager.h"
#include "opencl/test/unit_test/mocks/mock_allocation_properties.h"
#include "test.h"
using namespace NEO;

2
shared/test/unit_test/memory_manager/graphics_allocation_tests.cpp
View File

@@ -5,10 +5,10 @@
*
*/
#include "shared/test/common/mocks/mock_aub_csr.h"
#include "shared/test/common/mocks/mock_execution_environment.h"
#include "shared/test/common/mocks/mock_graphics_allocation.h"
#include "opencl/test/unit_test/mocks/mock_aub_csr.h"
#include "test.h"
using namespace NEO;

2
shared/test/unit_test/os_interface/windows/wddm_special_heap_test.cpp
View File

@@ -12,8 +12,8 @@
#include "shared/test/common/fixtures/device_fixture.h"
#include "shared/test/common/helpers/debug_manager_state_restore.h"
#include "shared/test/common/mocks/mock_wddm.h"
#include "shared/test/common/os_interface/windows/mock_wddm_memory_manager.h"
#include "opencl/test/unit_test/os_interface/windows/mock_wddm_memory_manager.h"
#include "test.h"
namespace NEO {

2
shared/test/unit_test/preamble/preamble_fixture.h
View File

@@ -9,8 +9,8 @@
#include "shared/source/helpers/preamble.h"
#include "shared/test/common/cmd_parse/hw_parse.h"
#include "shared/test/common/fixtures/device_fixture.h"
#include "shared/test/common/fixtures/linear_stream_fixture.h"
#include "opencl/test/unit_test/command_stream/linear_stream_fixture.h"
#include "test.h"
using namespace NEO;