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

Change DevicesBitfield type to struct

Browse Source 
Change-Id: I7a005b07737cdd21efc174a2ee2be0f6b7f9068d
Signed-off-by: Jablonski, Mateusz <mateusz.jablonski@intel.com>
This commit is contained in:
Jablonski, Mateusz
2019-02-15 11:31:47 +01:00
parent 7ff379f8f3
commit 05d02a6fe7
24 changed files with 91 additions and 84 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
CMakeLists.txt
View File

@@ -611,6 +611,7 @@ include_directories(${IGDRCL_SOURCE_DIR}/runtime/gmm_helper/${BRANCH_DIR_SUFFIX}
include_directories(${IGDRCL_SOURCE_DIR}/runtime/gmm_helper/client_context${BRANCH_DIR_SUFFIX}) include_directories(${IGDRCL_SOURCE_DIR}/runtime/gmm_helper/client_context${BRANCH_DIR_SUFFIX})
include_directories(${IGDRCL_SOURCE_DIR}/runtime/gmm_helper/gmm_memory${BRANCH_DIR_SUFFIX}) include_directories(${IGDRCL_SOURCE_DIR}/runtime/gmm_helper/gmm_memory${BRANCH_DIR_SUFFIX})
include_directories(${IGDRCL_SOURCE_DIR}/runtime/mem_obj/definitions${BRANCH_DIR_SUFFIX}) include_directories(${IGDRCL_SOURCE_DIR}/runtime/mem_obj/definitions${BRANCH_DIR_SUFFIX})
include_directories(${IGDRCL_SOURCE_DIR}/runtime/memory_manager/definitions${BRANCH_DIR_SUFFIX})
set(HW_SRC_INCLUDE_PATH ${IGDRCL_SOURCE_DIR}/runtime/gen_common) set(HW_SRC_INCLUDE_PATH ${IGDRCL_SOURCE_DIR}/runtime/gen_common)

2
runtime/command_stream/aub_command_stream_receiver_hw.h
View File

@@ -50,7 +50,7 @@ class AUBCommandStreamReceiverHw : public CommandStreamReceiverSimulatedHw<GfxFa
return static_cast<AubMemDump::AubFileStream *>(this->stream); return static_cast<AubMemDump::AubFileStream *>(this->stream);
} }
void writeMemory(uint64_t gpuAddress, void *cpuAddress, size_t size, uint32_t memoryBank, uint64_t entryBits, DevicesBitfield devicesBitfield) override; void writeMemory(uint64_t gpuAddress, void *cpuAddress, size_t size, uint32_t memoryBank, uint64_t entryBits) override;
bool writeMemory(GraphicsAllocation &gfxAllocation) override; bool writeMemory(GraphicsAllocation &gfxAllocation) override;
MOCKABLE_VIRTUAL bool writeMemory(AllocationView &allocationView); MOCKABLE_VIRTUAL bool writeMemory(AllocationView &allocationView);
void expectMMIO(uint32_t mmioRegister, uint32_t expectedValue); void expectMMIO(uint32_t mmioRegister, uint32_t expectedValue);

6
runtime/command_stream/aub_command_stream_receiver_hw.inl
View File

@@ -614,10 +614,10 @@ void AUBCommandStreamReceiverHw<GfxFamily>::makeNonResidentExternal(uint64_t gpu
} }
template <typename GfxFamily> template <typename GfxFamily>
void AUBCommandStreamReceiverHw<GfxFamily>::writeMemory(uint64_t gpuAddress, void *cpuAddress, size_t size, uint32_t memoryBank, uint64_t entryBits, DevicesBitfield devicesBitfield) { void AUBCommandStreamReceiverHw<GfxFamily>::writeMemory(uint64_t gpuAddress, void *cpuAddress, size_t size, uint32_t memoryBank, uint64_t entryBits) {
{ {
std::ostringstream str; std::ostringstream str;
str << "ppgtt: " << std::hex << std::showbase << gpuAddress << " end address: " << gpuAddress + size << " cpu address: " << cpuAddress << " device mask: " << devicesBitfield << " size: " << std::dec << size; str << "ppgtt: " << std::hex << std::showbase << gpuAddress << " end address: " << gpuAddress + size << " cpu address: " << cpuAddress << " size: " << std::dec << size;
getAubStream()->addComment(str.str().c_str()); getAubStream()->addComment(str.str().c_str());
} }
@@ -643,7 +643,7 @@ bool AUBCommandStreamReceiverHw<GfxFamily>::writeMemory(GraphicsAllocation &gfxA
if (aubManager) { if (aubManager) {
this->writeMemoryWithAubManager(gfxAllocation); this->writeMemoryWithAubManager(gfxAllocation);
} else { } else {
writeMemory(gpuAddress, cpuAddress, size, this->getMemoryBank(&gfxAllocation), this->getPPGTTAdditionalBits(&gfxAllocation), gfxAllocation.devicesBitfield); writeMemory(gpuAddress, cpuAddress, size, this->getMemoryBank(&gfxAllocation), this->getPPGTTAdditionalBits(&gfxAllocation));
} }
if (gfxAllocation.isLocked()) { if (gfxAllocation.isLocked()) {

2
runtime/command_stream/command_stream_receiver_simulated_common_hw.h
View File

@@ -51,7 +51,7 @@ class CommandStreamReceiverSimulatedCommonHw : public CommandStreamReceiverHw<Gf
virtual void pollForCompletion() = 0; virtual void pollForCompletion() = 0;
virtual void pollForCompletionImpl(){}; virtual void pollForCompletionImpl(){};
virtual bool writeMemory(GraphicsAllocation &gfxAllocation) = 0; virtual bool writeMemory(GraphicsAllocation &gfxAllocation) = 0;
virtual void writeMemory(uint64_t gpuAddress, void *cpuAddress, size_t size, uint32_t memoryBank, uint64_t entryBits, DevicesBitfield devicesBitfield) = 0; virtual void writeMemory(uint64_t gpuAddress, void *cpuAddress, size_t size, uint32_t memoryBank, uint64_t entryBits) = 0;
virtual void writeMemoryWithAubManager(GraphicsAllocation &graphicsAllocation) = 0; virtual void writeMemoryWithAubManager(GraphicsAllocation &graphicsAllocation) = 0;
aub_stream::AubManager *aubManager = nullptr; aub_stream::AubManager *aubManager = nullptr;

2
runtime/command_stream/tbx_command_stream_receiver_hw.h
View File

@@ -49,7 +49,7 @@ class TbxCommandStreamReceiverHw : public CommandStreamReceiverSimulatedHw<GfxFa
void processResidency(ResidencyContainer &allocationsForResidency) override; void processResidency(ResidencyContainer &allocationsForResidency) override;
void waitBeforeMakingNonResidentWhenRequired() override; void waitBeforeMakingNonResidentWhenRequired() override;
void writeMemory(uint64_t gpuAddress, void *cpuAddress, size_t size, uint32_t memoryBank, uint64_t entryBits, DevicesBitfield devicesBitfield) override; void writeMemory(uint64_t gpuAddress, void *cpuAddress, size_t size, uint32_t memoryBank, uint64_t entryBits) override;
bool writeMemory(GraphicsAllocation &gfxAllocation) override; bool writeMemory(GraphicsAllocation &gfxAllocation) override;
// Family specific version // Family specific version

4
runtime/command_stream/tbx_command_stream_receiver_hw.inl
View File

@@ -367,7 +367,7 @@ void TbxCommandStreamReceiverHw<GfxFamily>::pollForCompletion() {
} }
template <typename GfxFamily> template <typename GfxFamily>
void TbxCommandStreamReceiverHw<GfxFamily>::writeMemory(uint64_t gpuAddress, void *cpuAddress, size_t size, uint32_t memoryBank, uint64_t entryBits, DevicesBitfield devicesBitfield) { void TbxCommandStreamReceiverHw<GfxFamily>::writeMemory(uint64_t gpuAddress, void *cpuAddress, size_t size, uint32_t memoryBank, uint64_t entryBits) {
AubHelperHw<GfxFamily> aubHelperHw(this->localMemoryEnabled); AubHelperHw<GfxFamily> aubHelperHw(this->localMemoryEnabled);
@@ -391,7 +391,7 @@ bool TbxCommandStreamReceiverHw<GfxFamily>::writeMemory(GraphicsAllocation &gfxA
if (aubManager) { if (aubManager) {
this->writeMemoryWithAubManager(gfxAllocation); this->writeMemoryWithAubManager(gfxAllocation);
} else { } else {
writeMemory(gpuAddress, cpuAddress, size, this->getMemoryBank(&gfxAllocation), this->getPPGTTAdditionalBits(&gfxAllocation), gfxAllocation.devicesBitfield); writeMemory(gpuAddress, cpuAddress, size, this->getMemoryBank(&gfxAllocation), this->getPPGTTAdditionalBits(&gfxAllocation));
} }
return true; return true;

4
runtime/gmm_helper/gmm.cpp
View File

@@ -16,9 +16,9 @@
#include "runtime/helpers/surface_formats.h" #include "runtime/helpers/surface_formats.h"
namespace OCLRT { namespace OCLRT {
Gmm::Gmm(const void *alignedPtr, size_t alignedSize, bool uncacheable) : Gmm(alignedPtr, alignedSize, uncacheable, false, true, 0) {} Gmm::Gmm(const void *alignedPtr, size_t alignedSize, bool uncacheable) : Gmm(alignedPtr, alignedSize, uncacheable, false, true, {}) {}
Gmm::Gmm(const void *alignedPtr, size_t alignedSize, bool uncacheable, bool preferRenderCompressed, bool systemMemoryPool, uint32_t devicesBitfield) { Gmm::Gmm(const void *alignedPtr, size_t alignedSize, bool uncacheable, bool preferRenderCompressed, bool systemMemoryPool, DevicesBitfield devicesBitfield) {
resourceParams.Type = RESOURCE_BUFFER; resourceParams.Type = RESOURCE_BUFFER;
resourceParams.Format = GMM_FORMAT_GENERIC_8BIT; resourceParams.Format = GMM_FORMAT_GENERIC_8BIT;
resourceParams.BaseWidth64 = static_cast<uint64_t>(alignedSize); resourceParams.BaseWidth64 = static_cast<uint64_t>(alignedSize);

3
runtime/gmm_helper/gmm.h
View File

@@ -6,6 +6,7 @@
*/ */
#pragma once #pragma once
#include "devices_bitfield.h"
#include "runtime/api/cl_types.h" #include "runtime/api/cl_types.h"
#include "runtime/gmm_helper/gmm_lib.h" #include "runtime/gmm_helper/gmm_lib.h"
#include <cstdint> #include <cstdint>
@@ -24,7 +25,7 @@ class Gmm {
Gmm() = delete; Gmm() = delete;
Gmm(ImageInfo &inputOutputImgInfo); Gmm(ImageInfo &inputOutputImgInfo);
Gmm(const void *alignedPtr, size_t alignedSize, bool uncacheable); Gmm(const void *alignedPtr, size_t alignedSize, bool uncacheable);
Gmm(const void *alignedPtr, size_t alignedSize, bool uncacheable, bool preferRenderCompressed, bool systemMemoryPool, uint32_t devicesBitfield); Gmm(const void *alignedPtr, size_t alignedSize, bool uncacheable, bool preferRenderCompressed, bool systemMemoryPool, DevicesBitfield devicesBitfield);
Gmm(GMM_RESOURCE_INFO *inputGmm); Gmm(GMM_RESOURCE_INFO *inputGmm);
void queryImageParams(ImageInfo &inputOutputImgInfo); void queryImageParams(ImageInfo &inputOutputImgInfo);

2
runtime/mem_obj/mem_obj_helper.cpp
View File

@@ -42,7 +42,7 @@ AllocationProperties MemObjHelper::getAllocationProperties(ImageInfo *imgInfo, b
} }
DevicesBitfield MemObjHelper::getDevicesBitfield(const MemoryProperties &properties) { DevicesBitfield MemObjHelper::getDevicesBitfield(const MemoryProperties &properties) {
return DevicesBitfield(0); return {};
} }
bool MemObjHelper::isSuitableForRenderCompression(bool renderCompressedBuffers, const MemoryProperties &properties, ContextType contextType) { bool MemObjHelper::isSuitableForRenderCompression(bool renderCompressedBuffers, const MemoryProperties &properties, ContextType contextType) {

3
runtime/memory_manager/CMakeLists.txt
View File

@@ -1,5 +1,5 @@
# #
# Copyright (C) 2018 Intel Corporation # Copyright (C) 2018-2019 Intel Corporation
# #
# SPDX-License-Identifier: MIT # SPDX-License-Identifier: MIT
# #
@@ -14,6 +14,7 @@ set(RUNTIME_SRCS_MEMORY_MANAGER
${CMAKE_CURRENT_SOURCE_DIR}/deferrable_deletion.h ${CMAKE_CURRENT_SOURCE_DIR}/deferrable_deletion.h
${CMAKE_CURRENT_SOURCE_DIR}/deferred_deleter.cpp ${CMAKE_CURRENT_SOURCE_DIR}/deferred_deleter.cpp
${CMAKE_CURRENT_SOURCE_DIR}/deferred_deleter.h ${CMAKE_CURRENT_SOURCE_DIR}/deferred_deleter.h
${CMAKE_CURRENT_SOURCE_DIR}/definitions${BRANCH_DIR_SUFFIX}/devices_bitfield.h
${CMAKE_CURRENT_SOURCE_DIR}/graphics_allocation.cpp ${CMAKE_CURRENT_SOURCE_DIR}/graphics_allocation.cpp
${CMAKE_CURRENT_SOURCE_DIR}/graphics_allocation.h ${CMAKE_CURRENT_SOURCE_DIR}/graphics_allocation.h
${CMAKE_CURRENT_SOURCE_DIR}/host_ptr_defines.h ${CMAKE_CURRENT_SOURCE_DIR}/host_ptr_defines.h

12
runtime/memory_manager/definitions/devices_bitfield.h Normal file
View File

@@ -0,0 +1,12 @@
/*
* Copyright (C) 2019 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
namespace OCLRT {
struct DevicesBitfield {
};
} // namespace OCLRT

4
runtime/memory_manager/graphics_allocation.h
View File

@@ -7,6 +7,7 @@
#pragma once #pragma once
#include "devices_bitfield.h"
#include "runtime/helpers/debug_helpers.h" #include "runtime/helpers/debug_helpers.h"
#include "runtime/helpers/ptr_math.h" #include "runtime/helpers/ptr_math.h"
#include "runtime/memory_manager/host_ptr_defines.h" #include "runtime/memory_manager/host_ptr_defines.h"
@@ -24,7 +25,6 @@
namespace OCLRT { namespace OCLRT {
using osHandle = unsigned int; using osHandle = unsigned int;
using DevicesBitfield = uint32_t;
enum class AllocationOrigin { enum class AllocationOrigin {
EXTERNAL_ALLOCATION, EXTERNAL_ALLOCATION,
@@ -58,7 +58,7 @@ class GraphicsAllocation : public IDNode<GraphicsAllocation> {
Gmm *gmm = nullptr; Gmm *gmm = nullptr;
uint64_t allocationOffset = 0u; uint64_t allocationOffset = 0u;
void *driverAllocatedCpuPointer = nullptr; void *driverAllocatedCpuPointer = nullptr;
DevicesBitfield devicesBitfield = 0; DevicesBitfield devicesBitfield = {};
bool flushL3Required = false; bool flushL3Required = false;
AllocationOrigin origin = AllocationOrigin::EXTERNAL_ALLOCATION; AllocationOrigin origin = AllocationOrigin::EXTERNAL_ALLOCATION;

6
runtime/memory_manager/memory_manager.h
View File

@@ -92,11 +92,11 @@ class MemoryManager {
virtual void removeAllocationFromHostPtrManager(GraphicsAllocation *memory) = 0; virtual void removeAllocationFromHostPtrManager(GraphicsAllocation *memory) = 0;
MOCKABLE_VIRTUAL GraphicsAllocation *allocateGraphicsMemoryWithProperties(const AllocationProperties &properties) { MOCKABLE_VIRTUAL GraphicsAllocation *allocateGraphicsMemoryWithProperties(const AllocationProperties &properties) {
return allocateGraphicsMemoryInPreferredPool(properties, 0u, nullptr); return allocateGraphicsMemoryInPreferredPool(properties, {}, nullptr);
} }
virtual GraphicsAllocation *allocateGraphicsMemory(const AllocationProperties &properties, const void *ptr) { virtual GraphicsAllocation *allocateGraphicsMemory(const AllocationProperties &properties, const void *ptr) {
return allocateGraphicsMemoryInPreferredPool(properties, 0u, ptr); return allocateGraphicsMemoryInPreferredPool(properties, {}, ptr);
} }
GraphicsAllocation *allocateGraphicsMemoryForHostPtr(size_t size, void *ptr, bool fullRangeSvm, bool requiresL3Flush) { GraphicsAllocation *allocateGraphicsMemoryForHostPtr(size_t size, void *ptr, bool fullRangeSvm, bool requiresL3Flush) {
@@ -209,7 +209,7 @@ class MemoryManager {
const void *hostPtr = nullptr; const void *hostPtr = nullptr;
size_t size = 0; size_t size = 0;
size_t alignment = 0; size_t alignment = 0;
DevicesBitfield devicesBitfield = 0; DevicesBitfield devicesBitfield = {};
ImageInfo *imgInfo = nullptr; ImageInfo *imgInfo = nullptr;
}; };

2
runtime/os_interface/windows/wddm_memory_manager.cpp
View File

@@ -64,7 +64,7 @@ GraphicsAllocation *WddmMemoryManager::allocateGraphicsMemory64kb(AllocationData
auto wddmAllocation = std::make_unique<WddmAllocation>(nullptr, sizeAligned, nullptr, MemoryPool::System64KBPages, !!allocationData.flags.multiOsContextCapable); auto wddmAllocation = std::make_unique<WddmAllocation>(nullptr, sizeAligned, nullptr, MemoryPool::System64KBPages, !!allocationData.flags.multiOsContextCapable);
gmm = new Gmm(nullptr, sizeAligned, false, allocationData.flags.preferRenderCompressed, true, 0); gmm = new Gmm(nullptr, sizeAligned, false, allocationData.flags.preferRenderCompressed, true, {});
wddmAllocation->gmm = gmm; wddmAllocation->gmm = gmm;
if (!wddm->createAllocation64k(wddmAllocation.get())) { if (!wddm->createAllocation64k(wddmAllocation.get())) {

4
runtime/sharings/d3d/d3d_surface.cpp
View File

@@ -92,9 +92,9 @@ Image *D3DSurface::create(Context *context, cl_dx9_surface_info_khr *surfaceInfo
AllocationProperties allocProperties = MemObjHelper::getAllocationProperties(&imgInfo, true); AllocationProperties allocProperties = MemObjHelper::getAllocationProperties(&imgInfo, true);
allocProperties.allocationType = GraphicsAllocation::AllocationType::SHARED_RESOURCE_COPY; allocProperties.allocationType = GraphicsAllocation::AllocationType::SHARED_RESOURCE_COPY;
DevicesBitfield devices = 0; DevicesBitfield devicesBitfield = {};
alloc = context->getMemoryManager()->allocateGraphicsMemoryInPreferredPool(allocProperties, devices, nullptr); alloc = context->getMemoryManager()->allocateGraphicsMemoryInPreferredPool(allocProperties, devicesBitfield, nullptr);
imgDesc.image_row_pitch = imgInfo.rowPitch; imgDesc.image_row_pitch = imgInfo.rowPitch;
imgDesc.image_slice_pitch = imgInfo.slicePitch; imgDesc.image_slice_pitch = imgInfo.slicePitch;

4
unit_tests/command_stream/aub_command_stream_receiver_2_tests.cpp
View File

@@ -487,9 +487,9 @@ HWTEST_F(AubCommandStreamReceiverNoHostPtrTests, givenAubCommandStreamReceiverWh
auto imgInfo = MockGmm::initImgInfo(imgDesc, 0, nullptr); auto imgInfo = MockGmm::initImgInfo(imgDesc, 0, nullptr);
AllocationProperties allocProperties = MemObjHelper::getAllocationProperties(&imgInfo, true); AllocationProperties allocProperties = MemObjHelper::getAllocationProperties(&imgInfo, true);
DevicesBitfield devices = 0; DevicesBitfield devicesBitfield = {};
auto imageAllocation = memoryManager->allocateGraphicsMemoryInPreferredPool(allocProperties, devices, nullptr); auto imageAllocation = memoryManager->allocateGraphicsMemoryInPreferredPool(allocProperties, devicesBitfield, nullptr);
ASSERT_NE(nullptr, imageAllocation); ASSERT_NE(nullptr, imageAllocation);
EXPECT_TRUE(aubCsr->writeMemory(*imageAllocation)); EXPECT_TRUE(aubCsr->writeMemory(*imageAllocation));

8
unit_tests/mem_obj/image_tests.cpp
View File

@@ -1460,9 +1460,9 @@ HWTEST_F(HwImageTest, givenImageHwWhenSettingCCSParamsThenSetClearColorParamsIsC
auto imgInfo = MockGmm::initImgInfo(imgDesc, 0, nullptr); auto imgInfo = MockGmm::initImgInfo(imgDesc, 0, nullptr);
AllocationProperties allocProperties = MemObjHelper::getAllocationProperties(&imgInfo, true); AllocationProperties allocProperties = MemObjHelper::getAllocationProperties(&imgInfo, true);
DevicesBitfield devices = 0; DevicesBitfield devicesBitfield = {};
auto graphicsAllocation = memoryManager.allocateGraphicsMemoryInPreferredPool(allocProperties, devices, nullptr); auto graphicsAllocation = memoryManager.allocateGraphicsMemoryInPreferredPool(allocProperties, devicesBitfield, nullptr);
SurfaceFormatInfo formatInfo = {}; SurfaceFormatInfo formatInfo = {};
std::unique_ptr<MockImageHw<FamilyType>> mockImage(new MockImageHw<FamilyType>(&context, format, imgDesc, formatInfo, graphicsAllocation)); std::unique_ptr<MockImageHw<FamilyType>> mockImage(new MockImageHw<FamilyType>(&context, format, imgDesc, formatInfo, graphicsAllocation));
@@ -1488,9 +1488,9 @@ HWTEST_F(HwImageTest, givenImageHwWithUnifiedSurfaceAndMcsWhenSettingParamsForMu
auto imgInfo = MockGmm::initImgInfo(imgDesc, 0, nullptr); auto imgInfo = MockGmm::initImgInfo(imgDesc, 0, nullptr);
AllocationProperties allocProperties = MemObjHelper::getAllocationProperties(&imgInfo, true); AllocationProperties allocProperties = MemObjHelper::getAllocationProperties(&imgInfo, true);
DevicesBitfield devices = 0; DevicesBitfield devicesBitfield = {};
auto graphicsAllocation = memoryManager.allocateGraphicsMemoryInPreferredPool(allocProperties, devices, nullptr); auto graphicsAllocation = memoryManager.allocateGraphicsMemoryInPreferredPool(allocProperties, devicesBitfield, nullptr);
SurfaceFormatInfo formatInfo = {}; SurfaceFormatInfo formatInfo = {};
std::unique_ptr<MockImageHw<FamilyType>> mockImage(new MockImageHw<FamilyType>(&context, format, imgDesc, formatInfo, graphicsAllocation)); std::unique_ptr<MockImageHw<FamilyType>> mockImage(new MockImageHw<FamilyType>(&context, format, imgDesc, formatInfo, graphicsAllocation));

72
unit_tests/memory_manager/memory_manager_allocate_in_preferred_pool_tests.inl
View File

@@ -23,7 +23,7 @@ class MemoryManagerGetAlloctionDataTest : public testing::TestWithParam<Graphics
TEST(MemoryManagerGetAlloctionDataTest, givenHostMemoryAllocationTypeAndAllocateMemoryFlagAndNullptrWhenAllocationDataIsQueriedThenCorrectFlagsAndSizeAreSet) { TEST(MemoryManagerGetAlloctionDataTest, givenHostMemoryAllocationTypeAndAllocateMemoryFlagAndNullptrWhenAllocationDataIsQueriedThenCorrectFlagsAndSizeAreSet) {
AllocationData allocData; AllocationData allocData;
AllocationProperties properties(true, 10, GraphicsAllocation::AllocationType::BUFFER_HOST_MEMORY); AllocationProperties properties(true, 10, GraphicsAllocation::AllocationType::BUFFER_HOST_MEMORY);
MockMemoryManager::getAllocationData(allocData, properties, 0, nullptr); MockMemoryManager::getAllocationData(allocData, properties, {}, nullptr);
EXPECT_TRUE(allocData.flags.mustBeZeroCopy); EXPECT_TRUE(allocData.flags.mustBeZeroCopy);
EXPECT_TRUE(allocData.flags.useSystemMemory); EXPECT_TRUE(allocData.flags.useSystemMemory);
@@ -35,7 +35,7 @@ TEST(MemoryManagerGetAlloctionDataTest, givenNonHostMemoryAllocatoinTypeWhenAllo
AllocationData allocData; AllocationData allocData;
AllocationProperties properties(true, 10, GraphicsAllocation::AllocationType::BUFFER); AllocationProperties properties(true, 10, GraphicsAllocation::AllocationType::BUFFER);
MockMemoryManager::getAllocationData(allocData, properties, 0, nullptr); MockMemoryManager::getAllocationData(allocData, properties, {}, nullptr);
EXPECT_FALSE(allocData.flags.mustBeZeroCopy); EXPECT_FALSE(allocData.flags.mustBeZeroCopy);
EXPECT_FALSE(allocData.flags.useSystemMemory); EXPECT_FALSE(allocData.flags.useSystemMemory);
@@ -48,7 +48,7 @@ TEST(MemoryManagerGetAlloctionDataTest, givenAllocateMemoryFlagTrueWhenHostPtrIs
char memory = 0; char memory = 0;
AllocationProperties properties(true, sizeof(memory), GraphicsAllocation::AllocationType::BUFFER); AllocationProperties properties(true, sizeof(memory), GraphicsAllocation::AllocationType::BUFFER);
MockMemoryManager::getAllocationData(allocData, properties, 0, &memory); MockMemoryManager::getAllocationData(allocData, properties, {}, &memory);
EXPECT_EQ(sizeof(memory), allocData.size); EXPECT_EQ(sizeof(memory), allocData.size);
EXPECT_EQ(nullptr, allocData.hostPtr); EXPECT_EQ(nullptr, allocData.hostPtr);
@@ -58,7 +58,7 @@ TEST(MemoryManagerGetAlloctionDataTest, givenBufferTypeWhenAllocationDataIsQueri
AllocationData allocData; AllocationData allocData;
AllocationProperties properties(true, 10, GraphicsAllocation::AllocationType::BUFFER); AllocationProperties properties(true, 10, GraphicsAllocation::AllocationType::BUFFER);
MockMemoryManager::getAllocationData(allocData, properties, 0, nullptr); MockMemoryManager::getAllocationData(allocData, properties, {}, nullptr);
EXPECT_TRUE(allocData.flags.forcePin); EXPECT_TRUE(allocData.flags.forcePin);
} }
@@ -67,7 +67,7 @@ TEST(MemoryManagerGetAlloctionDataTest, givenBufferHostMemoryTypeWhenAllocationD
AllocationData allocData; AllocationData allocData;
AllocationProperties properties(true, 10, GraphicsAllocation::AllocationType::BUFFER_HOST_MEMORY); AllocationProperties properties(true, 10, GraphicsAllocation::AllocationType::BUFFER_HOST_MEMORY);
MockMemoryManager::getAllocationData(allocData, properties, 0, nullptr); MockMemoryManager::getAllocationData(allocData, properties, {}, nullptr);
EXPECT_TRUE(allocData.flags.forcePin); EXPECT_TRUE(allocData.flags.forcePin);
} }
@@ -76,7 +76,7 @@ TEST(MemoryManagerGetAlloctionDataTest, givenBufferCompressedTypeWhenAllocationD
AllocationData allocData; AllocationData allocData;
AllocationProperties properties(true, 10, GraphicsAllocation::AllocationType::BUFFER_COMPRESSED); AllocationProperties properties(true, 10, GraphicsAllocation::AllocationType::BUFFER_COMPRESSED);
MockMemoryManager::getAllocationData(allocData, properties, 0, nullptr); MockMemoryManager::getAllocationData(allocData, properties, {}, nullptr);
EXPECT_TRUE(allocData.flags.forcePin); EXPECT_TRUE(allocData.flags.forcePin);
} }
@@ -85,19 +85,11 @@ TEST(MemoryManagerGetAlloctionDataTest, givenDefaultAllocationFlagsWhenAllocatio
AllocationData allocData; AllocationData allocData;
AllocationProperties properties(false, 0, GraphicsAllocation::AllocationType::BUFFER_COMPRESSED); AllocationProperties properties(false, 0, GraphicsAllocation::AllocationType::BUFFER_COMPRESSED);
char memory; char memory;
MockMemoryManager::getAllocationData(allocData, properties, 0, &memory); MockMemoryManager::getAllocationData(allocData, properties, {}, &memory);
EXPECT_FALSE(allocData.flags.allocateMemory); EXPECT_FALSE(allocData.flags.allocateMemory);
} }
TEST(MemoryManagerGetAlloctionDataTest, givenSpecificDeviceWhenAllocationDataIsQueriedThenDeviceIsPropagatedToAllocationData) {
AllocationData allocData;
AllocationProperties properties(true, 0, GraphicsAllocation::AllocationType::BUFFER_COMPRESSED);
MockMemoryManager::getAllocationData(allocData, properties, 3u, nullptr);
EXPECT_EQ(3u, allocData.devicesBitfield);
}
typedef MemoryManagerGetAlloctionDataTest MemoryManagerGetAlloctionData32BitAnd64kbPagesAllowedTest; typedef MemoryManagerGetAlloctionDataTest MemoryManagerGetAlloctionData32BitAnd64kbPagesAllowedTest;
TEST_P(MemoryManagerGetAlloctionData32BitAnd64kbPagesAllowedTest, givenAllocationTypesWith32BitAnd64kbPagesAllowedWhenAllocationDataIsQueriedThenProperFlagsAreSet) { TEST_P(MemoryManagerGetAlloctionData32BitAnd64kbPagesAllowedTest, givenAllocationTypesWith32BitAnd64kbPagesAllowedWhenAllocationDataIsQueriedThenProperFlagsAreSet) {
@@ -105,7 +97,7 @@ TEST_P(MemoryManagerGetAlloctionData32BitAnd64kbPagesAllowedTest, givenAllocatio
auto allocType = GetParam(); auto allocType = GetParam();
AllocationProperties properties(true, 0, allocType); AllocationProperties properties(true, 0, allocType);
MockMemoryManager::getAllocationData(allocData, properties, 0, nullptr); MockMemoryManager::getAllocationData(allocData, properties, {}, nullptr);
EXPECT_TRUE(allocData.flags.allow32Bit); EXPECT_TRUE(allocData.flags.allow32Bit);
EXPECT_TRUE(allocData.flags.allow64kbPages); EXPECT_TRUE(allocData.flags.allow64kbPages);
@@ -117,7 +109,7 @@ TEST_P(MemoryManagerGetAlloctionData32BitAnd64kbPagesAllowedTest, given64kbAllow
AllocationData allocData; AllocationData allocData;
AllocationProperties properties(true, 10, allocType); AllocationProperties properties(true, 10, allocType);
MockMemoryManager::getAllocationData(allocData, properties, 0, nullptr); MockMemoryManager::getAllocationData(allocData, properties, {}, nullptr);
bool bufferCompressedType = (allocType == GraphicsAllocation::AllocationType::BUFFER_COMPRESSED); bool bufferCompressedType = (allocType == GraphicsAllocation::AllocationType::BUFFER_COMPRESSED);
EXPECT_TRUE(allocData.flags.allow64kbPages); EXPECT_TRUE(allocData.flags.allow64kbPages);
MockMemoryManager mockMemoryManager(true, false); MockMemoryManager mockMemoryManager(true, false);
@@ -136,7 +128,7 @@ TEST_P(MemoryManagerGetAlloctionData32BitAnd64kbPagesNotAllowedTest, givenAlloca
auto allocType = GetParam(); auto allocType = GetParam();
AllocationProperties properties(true, 0, allocType); AllocationProperties properties(true, 0, allocType);
MockMemoryManager::getAllocationData(allocData, properties, 0, nullptr); MockMemoryManager::getAllocationData(allocData, properties, {}, nullptr);
EXPECT_FALSE(allocData.flags.allow32Bit); EXPECT_FALSE(allocData.flags.allow32Bit);
EXPECT_FALSE(allocData.flags.allow64kbPages); EXPECT_FALSE(allocData.flags.allow64kbPages);
@@ -177,7 +169,7 @@ TEST(MemoryManagerTest, givenForced32BitSetWhenGraphicsMemoryFor32BitAllowedType
AllocationData allocData; AllocationData allocData;
AllocationProperties properties(true, 10, GraphicsAllocation::AllocationType::BUFFER); AllocationProperties properties(true, 10, GraphicsAllocation::AllocationType::BUFFER);
MockMemoryManager::getAllocationData(allocData, properties, 0, nullptr); MockMemoryManager::getAllocationData(allocData, properties, {}, nullptr);
auto allocation = memoryManager.allocateGraphicsMemory(allocData); auto allocation = memoryManager.allocateGraphicsMemory(allocData);
ASSERT_NE(nullptr, allocation); ASSERT_NE(nullptr, allocation);
@@ -200,7 +192,7 @@ TEST(MemoryManagerTest, givenForced32BitEnabledWhenGraphicsMemoryWihtoutAllow32B
AllocationData allocData; AllocationData allocData;
AllocationProperties properties(true, 10, GraphicsAllocation::AllocationType::BUFFER); AllocationProperties properties(true, 10, GraphicsAllocation::AllocationType::BUFFER);
MockMemoryManager::getAllocationData(allocData, properties, 0, nullptr); MockMemoryManager::getAllocationData(allocData, properties, {}, nullptr);
allocData.flags.allow32Bit = false; allocData.flags.allow32Bit = false;
auto allocation = memoryManager.allocateGraphicsMemory(allocData); auto allocation = memoryManager.allocateGraphicsMemory(allocData);
@@ -218,7 +210,7 @@ TEST(MemoryManagerTest, givenForced32BitDisabledWhenGraphicsMemoryWith32BitFlagF
AllocationData allocData; AllocationData allocData;
AllocationProperties properties(true, 10, GraphicsAllocation::AllocationType::BUFFER); AllocationProperties properties(true, 10, GraphicsAllocation::AllocationType::BUFFER);
MockMemoryManager::getAllocationData(allocData, properties, 0, nullptr); MockMemoryManager::getAllocationData(allocData, properties, {}, nullptr);
auto allocation = memoryManager.allocateGraphicsMemory(allocData); auto allocation = memoryManager.allocateGraphicsMemory(allocData);
ASSERT_NE(nullptr, allocation); ASSERT_NE(nullptr, allocation);
@@ -233,7 +225,7 @@ TEST(MemoryManagerTest, givenEnabled64kbPagesWhenGraphicsMemoryMustBeHostMemoryA
AllocationData allocData; AllocationData allocData;
AllocationProperties properties(true, 10, GraphicsAllocation::AllocationType::BUFFER_HOST_MEMORY); AllocationProperties properties(true, 10, GraphicsAllocation::AllocationType::BUFFER_HOST_MEMORY);
MockMemoryManager::getAllocationData(allocData, properties, 0, nullptr); MockMemoryManager::getAllocationData(allocData, properties, {}, nullptr);
auto allocation = memoryManager.allocateGraphicsMemory(allocData); auto allocation = memoryManager.allocateGraphicsMemory(allocData);
ASSERT_NE(nullptr, allocation); ASSERT_NE(nullptr, allocation);
@@ -250,7 +242,7 @@ TEST(MemoryManagerTest, givenEnabled64kbPagesWhenGraphicsMemoryWithoutAllow64kbP
AllocationData allocData; AllocationData allocData;
AllocationProperties properties(true, 10, GraphicsAllocation::AllocationType::BUFFER); AllocationProperties properties(true, 10, GraphicsAllocation::AllocationType::BUFFER);
MockMemoryManager::getAllocationData(allocData, properties, 0, nullptr); MockMemoryManager::getAllocationData(allocData, properties, {}, nullptr);
allocData.flags.allow64kbPages = false; allocData.flags.allow64kbPages = false;
auto allocation = memoryManager.allocateGraphicsMemory(allocData); auto allocation = memoryManager.allocateGraphicsMemory(allocData);
@@ -266,7 +258,7 @@ TEST(MemoryManagerTest, givenDisabled64kbPagesWhenGraphicsMemoryMustBeHostMemory
AllocationData allocData; AllocationData allocData;
AllocationProperties properties(true, 10, GraphicsAllocation::AllocationType::BUFFER_HOST_MEMORY); AllocationProperties properties(true, 10, GraphicsAllocation::AllocationType::BUFFER_HOST_MEMORY);
MockMemoryManager::getAllocationData(allocData, properties, 0, nullptr); MockMemoryManager::getAllocationData(allocData, properties, {}, nullptr);
auto allocation = memoryManager.allocateGraphicsMemory(allocData); auto allocation = memoryManager.allocateGraphicsMemory(allocData);
ASSERT_NE(nullptr, allocation); ASSERT_NE(nullptr, allocation);
@@ -285,7 +277,7 @@ TEST(MemoryManagerTest, givenForced32BitAndEnabled64kbPagesWhenGraphicsMemoryMus
AllocationData allocData; AllocationData allocData;
AllocationProperties properties(true, 10, GraphicsAllocation::AllocationType::BUFFER_HOST_MEMORY); AllocationProperties properties(true, 10, GraphicsAllocation::AllocationType::BUFFER_HOST_MEMORY);
MockMemoryManager::getAllocationData(allocData, properties, 0, nullptr); MockMemoryManager::getAllocationData(allocData, properties, {}, nullptr);
auto allocation = memoryManager.allocateGraphicsMemory(allocData); auto allocation = memoryManager.allocateGraphicsMemory(allocData);
ASSERT_NE(nullptr, allocation); ASSERT_NE(nullptr, allocation);
@@ -305,7 +297,7 @@ TEST(MemoryManagerTest, givenEnabled64kbPagesWhenGraphicsMemoryIsAllocatedWithHo
AllocationProperties properties(false, 1, GraphicsAllocation::AllocationType::BUFFER_HOST_MEMORY); AllocationProperties properties(false, 1, GraphicsAllocation::AllocationType::BUFFER_HOST_MEMORY);
char memory[1]; char memory[1];
MockMemoryManager::getAllocationData(allocData, properties, 0, &memory); MockMemoryManager::getAllocationData(allocData, properties, {}, &memory);
auto allocation = memoryManager.allocateGraphicsMemory(allocData); auto allocation = memoryManager.allocateGraphicsMemory(allocData);
ASSERT_NE(nullptr, allocation); ASSERT_NE(nullptr, allocation);
@@ -350,47 +342,47 @@ TEST(MemoryManagerTest, givenMemoryManagerWhenBufferTypeIsPassedAndAllocateInDev
TEST(MemoryManagerTest, givenSvmAllocationTypeWhenGetAllocationDataIsCalledThenZeroCopyIsRequested) { TEST(MemoryManagerTest, givenSvmAllocationTypeWhenGetAllocationDataIsCalledThenZeroCopyIsRequested) {
AllocationData allocData; AllocationData allocData;
MockMemoryManager::getAllocationData(allocData, {1, GraphicsAllocation::AllocationType::SVM}, 0, nullptr); MockMemoryManager::getAllocationData(allocData, {1, GraphicsAllocation::AllocationType::SVM}, {}, nullptr);
EXPECT_TRUE(allocData.flags.mustBeZeroCopy); EXPECT_TRUE(allocData.flags.mustBeZeroCopy);
EXPECT_TRUE(allocData.flags.allocateMemory); EXPECT_TRUE(allocData.flags.allocateMemory);
} }
TEST(MemoryManagerTest, givenSvmAllocationTypeWhenGetAllocationDataIsCalledThen64kbPagesAreAllowedAnd32BitAllocationIsDisallowed) { TEST(MemoryManagerTest, givenSvmAllocationTypeWhenGetAllocationDataIsCalledThen64kbPagesAreAllowedAnd32BitAllocationIsDisallowed) {
AllocationData allocData; AllocationData allocData;
MockMemoryManager::getAllocationData(allocData, {1, GraphicsAllocation::AllocationType::SVM}, 0, nullptr); MockMemoryManager::getAllocationData(allocData, {1, GraphicsAllocation::AllocationType::SVM}, {}, nullptr);
EXPECT_TRUE(allocData.flags.allow64kbPages); EXPECT_TRUE(allocData.flags.allow64kbPages);
EXPECT_FALSE(allocData.flags.allow32Bit); EXPECT_FALSE(allocData.flags.allow32Bit);
} }
TEST(MemoryManagerTest, givenUndecidedTypeWhenGetAllocationDataIsCalledThenSystemMemoryIsRequested) { TEST(MemoryManagerTest, givenUndecidedTypeWhenGetAllocationDataIsCalledThenSystemMemoryIsRequested) {
AllocationData allocData; AllocationData allocData;
MockMemoryManager::getAllocationData(allocData, {1, GraphicsAllocation::AllocationType::UNDECIDED}, 0, nullptr); MockMemoryManager::getAllocationData(allocData, {1, GraphicsAllocation::AllocationType::UNDECIDED}, {}, nullptr);
EXPECT_TRUE(allocData.flags.useSystemMemory); EXPECT_TRUE(allocData.flags.useSystemMemory);
} }
TEST(MemoryManagerTest, givenFillPatternTypeWhenGetAllocationDataIsCalledThenSystemMemoryIsRequested) { TEST(MemoryManagerTest, givenFillPatternTypeWhenGetAllocationDataIsCalledThenSystemMemoryIsRequested) {
AllocationData allocData; AllocationData allocData;
MockMemoryManager::getAllocationData(allocData, {1, GraphicsAllocation::AllocationType::FILL_PATTERN}, 0, nullptr); MockMemoryManager::getAllocationData(allocData, {1, GraphicsAllocation::AllocationType::FILL_PATTERN}, {}, nullptr);
EXPECT_TRUE(allocData.flags.useSystemMemory); EXPECT_TRUE(allocData.flags.useSystemMemory);
} }
TEST(MemoryManagerTest, givenLinearStreamTypeWhenGetAllocationDataIsCalledThenSystemMemoryIsNotRequested) { TEST(MemoryManagerTest, givenLinearStreamTypeWhenGetAllocationDataIsCalledThenSystemMemoryIsNotRequested) {
AllocationData allocData; AllocationData allocData;
MockMemoryManager::getAllocationData(allocData, {1, GraphicsAllocation::AllocationType::LINEAR_STREAM}, 0, nullptr); MockMemoryManager::getAllocationData(allocData, {1, GraphicsAllocation::AllocationType::LINEAR_STREAM}, {}, nullptr);
EXPECT_FALSE(allocData.flags.useSystemMemory); EXPECT_FALSE(allocData.flags.useSystemMemory);
EXPECT_TRUE(allocData.flags.requiresCpuAccess); EXPECT_TRUE(allocData.flags.requiresCpuAccess);
} }
TEST(MemoryManagerTest, givenTimestampPacketTagBufferTypeWhenGetAllocationDataIsCalledThenSystemMemoryIsNotRequestedAndRequireCpuAccess) { TEST(MemoryManagerTest, givenTimestampPacketTagBufferTypeWhenGetAllocationDataIsCalledThenSystemMemoryIsNotRequestedAndRequireCpuAccess) {
AllocationData allocData; AllocationData allocData;
MockMemoryManager::getAllocationData(allocData, {1, GraphicsAllocation::AllocationType::TIMESTAMP_PACKET_TAG_BUFFER}, 0, nullptr); MockMemoryManager::getAllocationData(allocData, {1, GraphicsAllocation::AllocationType::TIMESTAMP_PACKET_TAG_BUFFER}, {}, nullptr);
EXPECT_FALSE(allocData.flags.useSystemMemory); EXPECT_FALSE(allocData.flags.useSystemMemory);
EXPECT_TRUE(allocData.flags.requiresCpuAccess); EXPECT_TRUE(allocData.flags.requiresCpuAccess);
} }
TEST(MemoryManagerTest, givenProfilingTagBufferTypeWhenGetAllocationDataIsCalledThenSystemMemoryIsRequested) { TEST(MemoryManagerTest, givenProfilingTagBufferTypeWhenGetAllocationDataIsCalledThenSystemMemoryIsRequested) {
AllocationData allocData; AllocationData allocData;
MockMemoryManager::getAllocationData(allocData, {1, GraphicsAllocation::AllocationType::PROFILING_TAG_BUFFER}, 0, nullptr); MockMemoryManager::getAllocationData(allocData, {1, GraphicsAllocation::AllocationType::PROFILING_TAG_BUFFER}, {}, nullptr);
EXPECT_TRUE(allocData.flags.useSystemMemory); EXPECT_TRUE(allocData.flags.useSystemMemory);
EXPECT_FALSE(allocData.flags.requiresCpuAccess); EXPECT_FALSE(allocData.flags.requiresCpuAccess);
} }
@@ -401,7 +393,7 @@ TEST(MemoryManagerTest, givenAllocationPropertiesWithMultiOsContextCapableFlagEn
properties.flags.multiOsContextCapable = true; properties.flags.multiOsContextCapable = true;
AllocationData allocData; AllocationData allocData;
MockMemoryManager::getAllocationData(allocData, properties, 0, nullptr); MockMemoryManager::getAllocationData(allocData, properties, {}, nullptr);
EXPECT_TRUE(allocData.flags.multiOsContextCapable); EXPECT_TRUE(allocData.flags.multiOsContextCapable);
auto allocation = memoryManager.allocateGraphicsMemoryWithProperties(properties); auto allocation = memoryManager.allocateGraphicsMemoryWithProperties(properties);
@@ -415,7 +407,7 @@ TEST(MemoryManagerTest, givenAllocationPropertiesWithMultiOsContextCapableFlagDi
properties.flags.multiOsContextCapable = false; properties.flags.multiOsContextCapable = false;
AllocationData allocData; AllocationData allocData;
MockMemoryManager::getAllocationData(allocData, properties, 0, nullptr); MockMemoryManager::getAllocationData(allocData, properties, {}, nullptr);
EXPECT_FALSE(allocData.flags.multiOsContextCapable); EXPECT_FALSE(allocData.flags.multiOsContextCapable);
auto allocation = memoryManager.allocateGraphicsMemoryWithProperties(properties); auto allocation = memoryManager.allocateGraphicsMemoryWithProperties(properties);
@@ -425,31 +417,31 @@ TEST(MemoryManagerTest, givenAllocationPropertiesWithMultiOsContextCapableFlagDi
TEST(MemoryManagerTest, givenInternalHeapTypeWhenGetAllocationDataIsCalledThenInternalAllocationIsRequested) { TEST(MemoryManagerTest, givenInternalHeapTypeWhenGetAllocationDataIsCalledThenInternalAllocationIsRequested) {
AllocationData allocData; AllocationData allocData;
MockMemoryManager::getAllocationData(allocData, {1, GraphicsAllocation::AllocationType::INTERNAL_HEAP}, 0, nullptr); MockMemoryManager::getAllocationData(allocData, {1, GraphicsAllocation::AllocationType::INTERNAL_HEAP}, {}, nullptr);
EXPECT_EQ(AllocationOrigin::INTERNAL_ALLOCATION, allocData.allocationOrigin); EXPECT_EQ(AllocationOrigin::INTERNAL_ALLOCATION, allocData.allocationOrigin);
} }
TEST(MemoryManagerTest, givenInternalHeapTypeWhenGetAllocationDataIsCalledThenSystemMemoryIsNotRequested) { TEST(MemoryManagerTest, givenInternalHeapTypeWhenGetAllocationDataIsCalledThenSystemMemoryIsNotRequested) {
AllocationData allocData; AllocationData allocData;
MockMemoryManager::getAllocationData(allocData, {1, GraphicsAllocation::AllocationType::INTERNAL_HEAP}, 0, nullptr); MockMemoryManager::getAllocationData(allocData, {1, GraphicsAllocation::AllocationType::INTERNAL_HEAP}, {}, nullptr);
EXPECT_FALSE(allocData.flags.useSystemMemory); EXPECT_FALSE(allocData.flags.useSystemMemory);
EXPECT_TRUE(allocData.flags.requiresCpuAccess); EXPECT_TRUE(allocData.flags.requiresCpuAccess);
} }
TEST(MemoryManagerTest, givenKernelIsaTypeWhenGetAllocationDataIsCalledThenSystemMemoryIsNotRequested) { TEST(MemoryManagerTest, givenKernelIsaTypeWhenGetAllocationDataIsCalledThenSystemMemoryIsNotRequested) {
AllocationData allocData; AllocationData allocData;
MockMemoryManager::getAllocationData(allocData, {1, GraphicsAllocation::AllocationType::KERNEL_ISA}, 0, nullptr); MockMemoryManager::getAllocationData(allocData, {1, GraphicsAllocation::AllocationType::KERNEL_ISA}, {}, nullptr);
EXPECT_FALSE(allocData.flags.useSystemMemory); EXPECT_FALSE(allocData.flags.useSystemMemory);
EXPECT_TRUE(allocData.flags.requiresCpuAccess); EXPECT_TRUE(allocData.flags.requiresCpuAccess);
} }
TEST(MemoryManagerTest, givenLinearStreamWhenGetAllocationDataIsCalledThenSystemMemoryIsNotRequested) { TEST(MemoryManagerTest, givenLinearStreamWhenGetAllocationDataIsCalledThenSystemMemoryIsNotRequested) {
AllocationData allocData; AllocationData allocData;
MockMemoryManager::getAllocationData(allocData, {1, GraphicsAllocation::AllocationType::LINEAR_STREAM}, 0, nullptr); MockMemoryManager::getAllocationData(allocData, {1, GraphicsAllocation::AllocationType::LINEAR_STREAM}, {}, nullptr);
EXPECT_FALSE(allocData.flags.useSystemMemory); EXPECT_FALSE(allocData.flags.useSystemMemory);
EXPECT_TRUE(allocData.flags.requiresCpuAccess); EXPECT_TRUE(allocData.flags.requiresCpuAccess);
} }
TEST(MemoryManagerTest, givenKernelIsaTypeWhenGetAllocationDataIsCalledThenInternalAllocationIsRequested) { TEST(MemoryManagerTest, givenKernelIsaTypeWhenGetAllocationDataIsCalledThenInternalAllocationIsRequested) {
AllocationData allocData; AllocationData allocData;
MockMemoryManager::getAllocationData(allocData, {1, GraphicsAllocation::AllocationType::KERNEL_ISA}, 0, nullptr); MockMemoryManager::getAllocationData(allocData, {1, GraphicsAllocation::AllocationType::KERNEL_ISA}, {}, nullptr);
EXPECT_EQ(AllocationOrigin::INTERNAL_ALLOCATION, allocData.allocationOrigin); EXPECT_EQ(AllocationOrigin::INTERNAL_ALLOCATION, allocData.allocationOrigin);
} }

4
unit_tests/mocks/linux/mock_drm_memory_manager.h
View File

@@ -92,9 +92,9 @@ class TestedDrmMemoryManager : public DrmMemoryManager {
bool allocateMemory = ptr == nullptr; bool allocateMemory = ptr == nullptr;
AllocationData allocationData; AllocationData allocationData;
if (allocationOrigin == AllocationOrigin::EXTERNAL_ALLOCATION) { if (allocationOrigin == AllocationOrigin::EXTERNAL_ALLOCATION) {
getAllocationData(allocationData, MockAllocationProperties::getPropertiesFor32BitExternalAllocation(size, allocateMemory), 0u, ptr); getAllocationData(allocationData, MockAllocationProperties::getPropertiesFor32BitExternalAllocation(size, allocateMemory), {}, ptr);
} else { } else {
getAllocationData(allocationData, MockAllocationProperties::getPropertiesFor32BitInternalAllocation(size, allocateMemory), 0u, ptr); getAllocationData(allocationData, MockAllocationProperties::getPropertiesFor32BitInternalAllocation(size, allocateMemory), {}, ptr);
} }
return allocate32BitGraphicsMemoryImpl(allocationData); return allocate32BitGraphicsMemoryImpl(allocationData);
} }

4
unit_tests/mocks/mock_aub_csr.h
View File

@@ -81,8 +81,8 @@ struct MockAubCsr : public AUBCommandStreamReceiverHw<GfxFamily> {
AUBCommandStreamReceiverHw<GfxFamily>::initializeEngine(); AUBCommandStreamReceiverHw<GfxFamily>::initializeEngine();
initializeEngineCalled = true; initializeEngineCalled = true;
} }
void writeMemory(uint64_t gpuAddress, void *cpuAddress, size_t size, uint32_t memoryBank, uint64_t entryBits, DevicesBitfield devicesBitfield) override { 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, devicesBitfield); AUBCommandStreamReceiverHw<GfxFamily>::writeMemory(gpuAddress, cpuAddress, size, memoryBank, entryBits);
writeMemoryCalled = true; writeMemoryCalled = true;
} }
void submitBatchBuffer(uint64_t batchBufferGpuAddress, const void *batchBuffer, size_t batchBufferSize, uint32_t memoryBank, uint64_t entryBits) override { void submitBatchBuffer(uint64_t batchBufferGpuAddress, const void *batchBuffer, size_t batchBufferSize, uint32_t memoryBank, uint64_t entryBits) override {

6
unit_tests/mocks/mock_memory_manager.cpp
View File

@@ -51,7 +51,7 @@ GraphicsAllocation *MockMemoryManager::allocateGraphicsMemory64kb(AllocationData
auto allocation = OsAgnosticMemoryManager::allocateGraphicsMemory64kb(allocationData); auto allocation = OsAgnosticMemoryManager::allocateGraphicsMemory64kb(allocationData);
if (allocation) { if (allocation) {
allocation->gmm = new Gmm(allocation->getUnderlyingBuffer(), allocationData.size, false, preferRenderCompressedFlagPassed, true, 0); allocation->gmm = new Gmm(allocation->getUnderlyingBuffer(), allocationData.size, false, preferRenderCompressedFlagPassed, true, {});
allocation->gmm->isRenderCompressed = preferRenderCompressedFlagPassed; allocation->gmm->isRenderCompressed = preferRenderCompressedFlagPassed;
} }
return allocation; return allocation;
@@ -85,9 +85,9 @@ GraphicsAllocation *MockMemoryManager::allocate32BitGraphicsMemory(size_t size,
bool allocateMemory = ptr == nullptr; bool allocateMemory = ptr == nullptr;
AllocationData allocationData; AllocationData allocationData;
if (allocationOrigin == AllocationOrigin::EXTERNAL_ALLOCATION) { if (allocationOrigin == AllocationOrigin::EXTERNAL_ALLOCATION) {
getAllocationData(allocationData, MockAllocationProperties::getPropertiesFor32BitExternalAllocation(size, allocateMemory), 0u, ptr); getAllocationData(allocationData, MockAllocationProperties::getPropertiesFor32BitExternalAllocation(size, allocateMemory), {}, ptr);
} else { } else {
getAllocationData(allocationData, MockAllocationProperties::getPropertiesFor32BitInternalAllocation(size, allocateMemory), 0u, ptr); getAllocationData(allocationData, MockAllocationProperties::getPropertiesFor32BitInternalAllocation(size, allocateMemory), {}, ptr);
} }
return allocate32BitGraphicsMemoryImpl(allocationData); return allocate32BitGraphicsMemoryImpl(allocationData);
} }

4
unit_tests/mocks/mock_tbx_csr.h
View File

@@ -49,8 +49,8 @@ class MockTbxCsr : public TbxCommandStreamReceiverHw<GfxFamily> {
writeMemoryWithAubManagerCalled = true; writeMemoryWithAubManagerCalled = true;
} }
void writeMemory(uint64_t gpuAddress, void *cpuAddress, size_t size, uint32_t memoryBank, uint64_t entryBits, DevicesBitfield devicesBitfield) override { void writeMemory(uint64_t gpuAddress, void *cpuAddress, size_t size, uint32_t memoryBank, uint64_t entryBits) override {
TbxCommandStreamReceiverHw<GfxFamily>::writeMemory(gpuAddress, cpuAddress, size, memoryBank, entryBits, devicesBitfield); TbxCommandStreamReceiverHw<GfxFamily>::writeMemory(gpuAddress, cpuAddress, size, memoryBank, entryBits);
writeMemoryCalled = true; writeMemoryCalled = true;
} }
void submitBatchBuffer(uint64_t batchBufferGpuAddress, const void *batchBuffer, size_t batchBufferSize, uint32_t memoryBank, uint64_t entryBits) override { void submitBatchBuffer(uint64_t batchBufferGpuAddress, const void *batchBuffer, size_t batchBufferSize, uint32_t memoryBank, uint64_t entryBits) override {

4
unit_tests/os_interface/windows/mock_wddm_memory_manager.h
View File

@@ -37,9 +37,9 @@ class MockWddmMemoryManager : public WddmMemoryManager {
bool allocateMemory = ptr == nullptr; bool allocateMemory = ptr == nullptr;
AllocationData allocationData; AllocationData allocationData;
if (allocationOrigin == AllocationOrigin::EXTERNAL_ALLOCATION) { if (allocationOrigin == AllocationOrigin::EXTERNAL_ALLOCATION) {
getAllocationData(allocationData, MockAllocationProperties::getPropertiesFor32BitExternalAllocation(size, allocateMemory), 0u, ptr); getAllocationData(allocationData, MockAllocationProperties::getPropertiesFor32BitExternalAllocation(size, allocateMemory), {}, ptr);
} else { } else {
getAllocationData(allocationData, MockAllocationProperties::getPropertiesFor32BitInternalAllocation(size, allocateMemory), 0u, ptr); getAllocationData(allocationData, MockAllocationProperties::getPropertiesFor32BitInternalAllocation(size, allocateMemory), {}, ptr);
} }
return allocate32BitGraphicsMemoryImpl(allocationData); return allocate32BitGraphicsMemoryImpl(allocationData);
} }

12
unit_tests/os_interface/windows/wddm_memory_manager_tests.cpp
View File

@@ -1094,9 +1094,9 @@ TEST_F(WddmMemoryManagerWithAsyncDeleterTest, givenMemoryManagerWithAsyncDeleter
deleter->expectDrainBlockingValue(true); deleter->expectDrainBlockingValue(true);
AllocationProperties allocProperties = MemObjHelper::getAllocationProperties(&imgInfo, true); AllocationProperties allocProperties = MemObjHelper::getAllocationProperties(&imgInfo, true);
DevicesBitfield devices = 0; DevicesBitfield devicesBitfield = {};
memoryManager->allocateGraphicsMemoryInPreferredPool(allocProperties, devices, nullptr); memoryManager->allocateGraphicsMemoryInPreferredPool(allocProperties, devicesBitfield, nullptr);
EXPECT_EQ(1, deleter->drainCalled); EXPECT_EQ(1, deleter->drainCalled);
EXPECT_EQ(2u, wddm->createAllocationResult.called); EXPECT_EQ(2u, wddm->createAllocationResult.called);
} }
@@ -1114,9 +1114,9 @@ TEST_F(WddmMemoryManagerWithAsyncDeleterTest, givenMemoryManagerWithAsyncDeleter
EXPECT_EQ(0u, wddm->mapGpuVirtualAddressResult.called); EXPECT_EQ(0u, wddm->mapGpuVirtualAddressResult.called);
AllocationProperties allocProperties = MemObjHelper::getAllocationProperties(&imgInfo, true); AllocationProperties allocProperties = MemObjHelper::getAllocationProperties(&imgInfo, true);
DevicesBitfield devices = 0; DevicesBitfield devicesBitfield = {};
auto allocation = memoryManager->allocateGraphicsMemoryInPreferredPool(allocProperties, devices, nullptr); auto allocation = memoryManager->allocateGraphicsMemoryInPreferredPool(allocProperties, devicesBitfield, nullptr);
EXPECT_EQ(0, deleter->drainCalled); EXPECT_EQ(0, deleter->drainCalled);
EXPECT_EQ(1u, wddm->createAllocationResult.called); EXPECT_EQ(1u, wddm->createAllocationResult.called);
EXPECT_EQ(1u, wddm->mapGpuVirtualAddressResult.called); EXPECT_EQ(1u, wddm->mapGpuVirtualAddressResult.called);
@@ -1133,9 +1133,9 @@ TEST_F(WddmMemoryManagerWithAsyncDeleterTest, givenMemoryManagerWithoutAsyncDele
EXPECT_EQ(0u, wddm->createAllocationResult.called); EXPECT_EQ(0u, wddm->createAllocationResult.called);
AllocationProperties allocProperties = MemObjHelper::getAllocationProperties(&imgInfo, true); AllocationProperties allocProperties = MemObjHelper::getAllocationProperties(&imgInfo, true);
DevicesBitfield devices = 0; DevicesBitfield devicesBitfield = {};
memoryManager->allocateGraphicsMemoryInPreferredPool(allocProperties, devices, nullptr); memoryManager->allocateGraphicsMemoryInPreferredPool(allocProperties, devicesBitfield, nullptr);
EXPECT_EQ(1u, wddm->createAllocationResult.called); EXPECT_EQ(1u, wddm->createAllocationResult.called);
} }