Skip to content

Commit 2acc0fb

Browse files
jimsnow-intelCompute-Runtime-Automation
jimsnow-intel
authored and
Compute-Runtime-Automation
committed
Add memory backed buffer allocation for L0 ray tracing.
This allocates the buffer on a per-device basis and enables ray tracing on devices that support it when given a kernel with ray tracing calls. Signed-off-by: Jim Snow <jim.m.snow@intel.com>
1 parent 135ac74 commit 2acc0fb

35 files changed

+308
-17
lines changed

‎level_zero/core/source/cmdlist/cmdlist_hw_base.inl‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -12,6 +12,7 @@
1212
#include "shared/source/command_stream/preemption.h"
1313
#include "shared/source/helpers/register_offsets.h"
1414
#include "shared/source/helpers/simd_helper.h"
15+
#include "shared/source/memory_manager/graphics_allocation.h"
1516
#include "shared/source/memory_manager/memory_manager.h"
1617
#include "shared/source/memory_manager/residency_container.h"
1718
#include "shared/source/unified_memory/unified_memory.h"

‎level_zero/core/source/cmdlist/cmdlist_hw_xehp_plus.inl‎

Lines changed: 10 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -214,6 +214,16 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendLaunchKernelWithParams(z
214214
}
215215
}
216216

217+
if (kernelImp->usesRayTracing()) {
218+
NEO::GraphicsAllocation *memoryBackedBuffer = device->getNEODevice()->getRTMemoryBackedBuffer();
219+
if (memoryBackedBuffer == nullptr) {
220+
return ZE_RESULT_ERROR_UNINITIALIZED;
221+
} else {
222+
NEO::LinearStream *linearStream = commandContainer.getCommandStream();
223+
NEO::EncodeEnableRayTracing<GfxFamily>::programEnableRayTracing(*linearStream, *memoryBackedBuffer);
224+
}
225+
}
226+
217227
return ZE_RESULT_SUCCESS;
218228
}
219229

‎level_zero/core/source/kernel/kernel_imp.cpp‎

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -807,6 +807,11 @@ ze_result_t KernelImp::initialize(const ze_kernel_desc_t *desc) {
807807
kernelImmData->getDescriptor().kernelAttributes.hasNonKernelArgStore ||
808808
kernelImmData->getDescriptor().kernelAttributes.hasNonKernelArgAtomic;
809809

810+
if (this->usesRayTracing()) {
811+
neoDevice->initializeRayTracing();
812+
this->residencyContainer.push_back(neoDevice->getRTMemoryBackedBuffer());
813+
}
814+
810815
return ZE_RESULT_SUCCESS;
811816
}
812817

‎level_zero/core/source/kernel/kernel_imp.h‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -127,6 +127,9 @@ struct KernelImp : Kernel {
127127
uint32_t patchGlobalOffset() override;
128128

129129
ze_result_t setCacheConfig(ze_cache_config_flags_t flags) override;
130+
bool usesRayTracing() {
131+
return kernelImmData->getDescriptor().hasRTCalls();
132+
}
130133

131134
ze_result_t getProfileInfo(zet_profile_properties_t *pProfileProperties) override {
132135
pProfileProperties->flags = 0;

‎level_zero/core/test/unit_tests/fixtures/module_fixture.h‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -84,6 +84,8 @@ struct ModuleImmutableDataFixture : public DeviceFixture {
8484
};
8585

8686
struct MockModule : public L0::ModuleImp {
87+
using ModuleImp::getKernelImmutableDataVector;
88+
using ModuleImp::maxGroupSize;
8789
using ModuleImp::translationUnit;
8890
using ModuleImp::type;
8991
MockModule(L0::Device *device,

‎level_zero/core/test/unit_tests/sources/kernel/test_kernel.cpp‎

Lines changed: 103 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -570,6 +570,86 @@ HWTEST_F(KernelImmutableDataTests, givenKernelInitializedWithPrivateMemoryThenCo
570570
EXPECT_EQ(sizeContainerWithoutPrivateMemory + 1u, sizeContainerWithPrivateMemory);
571571
}
572572

573+
class KernelDescriptorRTCallsTrue : public NEO::KernelDescriptor {
574+
bool hasRTCalls() const override {
575+
return true;
576+
}
577+
};
578+
579+
class KernelDescriptorRTCallsFalse : public NEO::KernelDescriptor {
580+
bool hasRTCalls() const override {
581+
return false;
582+
}
583+
};
584+
585+
TEST_F(KernelImmutableDataTests, whenHasRTCallsIsTrueThenRayTracingIsInitialized) {
586+
KernelDescriptorRTCallsTrue mockDescriptor = {};
587+
mockDescriptor.kernelMetadata.kernelName = "rt_test";
588+
for (auto i = 0u; i < 3u; i++) {
589+
mockDescriptor.kernelAttributes.requiredWorkgroupSize[i] = 0;
590+
}
591+
592+
std::unique_ptr<MockImmutableData> mockKernelImmutableData =
593+
std::make_unique<MockImmutableData>(32u);
594+
mockKernelImmutableData->kernelDescriptor = &mockDescriptor;
595+
596+
ModuleBuildLog *moduleBuildLog = nullptr;
597+
module = std::make_unique<MockModule>(device,
598+
moduleBuildLog,
599+
ModuleType::User,
600+
32u,
601+
mockKernelImmutableData.get());
602+
module->maxGroupSize = 10;
603+
604+
std::unique_ptr<ModuleImmutableDataFixture::MockKernel> kernel;
605+
kernel = std::make_unique<ModuleImmutableDataFixture::MockKernel>(module.get());
606+
607+
ze_kernel_desc_t kernelDesc = {};
608+
kernelDesc.pKernelName = "rt_test";
609+
610+
auto immDataVector =
611+
const_cast<std::vector<std::unique_ptr<KernelImmutableData>> *>(&module.get()->getKernelImmutableDataVector());
612+
613+
immDataVector->push_back(std::move(mockKernelImmutableData));
614+
615+
EXPECT_EQ(ZE_RESULT_SUCCESS, kernel->initialize(&kernelDesc));
616+
EXPECT_NE(nullptr, module.get()->getDevice()->getNEODevice()->getRTMemoryBackedBuffer());
617+
}
618+
619+
TEST_F(KernelImmutableDataTests, whenHasRTCallsIsFalseThenRayTracingIsNotInitialized) {
620+
KernelDescriptorRTCallsFalse mockDescriptor = {};
621+
mockDescriptor.kernelMetadata.kernelName = "rt_test";
622+
for (auto i = 0u; i < 3u; i++) {
623+
mockDescriptor.kernelAttributes.requiredWorkgroupSize[i] = 0;
624+
}
625+
626+
std::unique_ptr<MockImmutableData> mockKernelImmutableData =
627+
std::make_unique<MockImmutableData>(32u);
628+
mockKernelImmutableData->kernelDescriptor = &mockDescriptor;
629+
630+
ModuleBuildLog *moduleBuildLog = nullptr;
631+
module = std::make_unique<MockModule>(device,
632+
moduleBuildLog,
633+
ModuleType::User,
634+
32u,
635+
mockKernelImmutableData.get());
636+
module->maxGroupSize = 10;
637+
638+
std::unique_ptr<ModuleImmutableDataFixture::MockKernel> kernel;
639+
kernel = std::make_unique<ModuleImmutableDataFixture::MockKernel>(module.get());
640+
641+
ze_kernel_desc_t kernelDesc = {};
642+
kernelDesc.pKernelName = "rt_test";
643+
644+
auto immDataVector =
645+
const_cast<std::vector<std::unique_ptr<KernelImmutableData>> *>(&module.get()->getKernelImmutableDataVector());
646+
647+
immDataVector->push_back(std::move(mockKernelImmutableData));
648+
649+
EXPECT_EQ(ZE_RESULT_SUCCESS, kernel->initialize(&kernelDesc));
650+
EXPECT_EQ(nullptr, module.get()->getDevice()->getNEODevice()->getRTMemoryBackedBuffer());
651+
}
652+
573653
using KernelIndirectPropertiesFromIGCTests = KernelImmutableDataTests;
574654

575655
HWTEST_F(KernelIndirectPropertiesFromIGCTests, whenInitializingKernelWithNoKernelLoadAndNoStoreAndNoAtomicThenHasIndirectAccessIsSetToFalse) {
@@ -847,6 +927,28 @@ HWTEST_F(KernelPropertiesTests, givenValidKernelWithIndirectAccessFlagsAndDisabl
847927
EXPECT_TRUE(unifiedMemoryControls.indirectSharedAllocationsAllowed);
848928
}
849929

930+
HWTEST2_F(KernelPropertiesTests, whenHasRTCallsIsTrueThenUsesRayTracingIsTrue, MatchAny) {
931+
WhiteBoxKernelHw<gfxCoreFamily> mockKernel;
932+
KernelDescriptorRTCallsTrue mockDescriptor = {};
933+
WhiteBox<::L0::KernelImmutableData> mockKernelImmutableData = {};
934+
935+
mockKernelImmutableData.kernelDescriptor = &mockDescriptor;
936+
mockKernel.kernelImmData = &mockKernelImmutableData;
937+
938+
EXPECT_TRUE(mockKernel.usesRayTracing());
939+
}
940+
941+
HWTEST2_F(KernelPropertiesTests, whenHasRTCallsIsFalseThenUsesRayTracingIsFalse, MatchAny) {
942+
WhiteBoxKernelHw<gfxCoreFamily> mockKernel;
943+
KernelDescriptorRTCallsFalse mockDescriptor = {};
944+
WhiteBox<::L0::KernelImmutableData> mockKernelImmutableData = {};
945+
946+
mockKernelImmutableData.kernelDescriptor = &mockDescriptor;
947+
mockKernel.kernelImmData = &mockKernelImmutableData;
948+
949+
EXPECT_FALSE(mockKernel.usesRayTracing());
950+
}
951+
850952
using KernelIndirectPropertiesTests = KernelPropertiesTests;
851953

852954
HWTEST_F(KernelIndirectPropertiesTests, whenCallingSetIndirectAccessWithKernelThatHasIndirectAccessThenIndirectAccessIsSet) {
@@ -1314,6 +1416,7 @@ struct MyMockKernel : public Mock<Kernel> {
13141416
}
13151417
bool setSurfaceStateCalled = false;
13161418
};
1419+
13171420
TEST_F(KernelImpPatchBindlessTest, GivenValidBindlessOffsetWhenSetArgBufferWithAllocThensetBufferSurfaceStateCalled) {
13181421
ze_kernel_desc_t desc = {};
13191422
desc.pKernelName = kernelName.c_str();

‎opencl/test/unit_test/device/device_tests.cpp‎

Lines changed: 9 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -746,4 +746,12 @@ TEST(ClDeviceHelperTest, givenZeroNumberOfTilesWhenPrepareDeviceEnvironmentsCoun
746746

747747
uint32_t devicesCount = HwHelper::getSubDevicesCount(&hwInfo);
748748
EXPECT_EQ(devicesCount, 1u);
749-
}
749+
}
750+
751+
TEST_F(DeviceTest, whenInitializeRayTracingIsCalledAndRtBackedBufferIsNullptrMemoryBackedBufferIsCreated) {
752+
EXPECT_EQ(nullptr, pDevice->getRTMemoryBackedBuffer());
753+
pDevice->initializeRayTracing();
754+
EXPECT_NE(nullptr, pDevice->getRTMemoryBackedBuffer());
755+
pDevice->initializeRayTracing();
756+
EXPECT_NE(nullptr, pDevice->getRTMemoryBackedBuffer());
757+
}

‎opencl/test/unit_test/helpers/CMakeLists.txt‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -29,6 +29,7 @@ set(IGDRCL_SRCS_tests_helpers
2929
${CMAKE_CURRENT_SOURCE_DIR}/per_thread_data_tests.cpp
3030
${CMAKE_CURRENT_SOURCE_DIR}/queue_helpers_tests.cpp
3131
${CMAKE_CURRENT_SOURCE_DIR}/raii_hw_helper.h
32+
${CMAKE_CURRENT_SOURCE_DIR}/ray_tracing_helper_tests.cpp
3233
${CMAKE_CURRENT_SOURCE_DIR}/sampler_helpers_tests.cpp
3334
${CMAKE_CURRENT_SOURCE_DIR}/task_information_tests.cpp
3435
${CMAKE_CURRENT_SOURCE_DIR}/timestamp_packet_1_tests.cpp

‎opencl/test/unit_test/helpers/ray_tracing_helper_tests.cpp‎

Lines changed: 24 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,24 @@
1+
/*
2+
* Copyright (C) 2020-2021 Intel Corporation
3+
*
4+
* SPDX-License-Identifier: MIT
5+
*
6+
*/
7+
8+
#include "shared/source/helpers/constants.h"
9+
#include "shared/source/helpers/ray_tracing_helper.h"
10+
#include "shared/test/common/mocks/mock_device.h"
11+
12+
#include "opencl/test/unit_test/mocks/mock_cl_device.h"
13+
#include "opencl/test/unit_test/mocks/mock_context.h"
14+
#include "test.h"
15+
16+
using namespace NEO;
17+
18+
TEST(RayTracingHelperTests, whenMemoryBackedFifoSizeIsRequestedThenCorrectValueIsReturned) {
19+
MockDevice device;
20+
21+
size_t size = RayTracingHelper::getTotalMemoryBackedFifoSize(device);
22+
size_t expectedSize = device.getHardwareInfo().gtSystemInfo.DualSubSliceCount * RayTracingHelper::memoryBackedFifoSizePerDss;
23+
EXPECT_EQ(expectedSize, size);
24+
}

‎shared/offline_compiler/source/CMakeLists.txt‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -33,6 +33,8 @@ set(CLOC_LIB_SRCS_LIB
3333
${NEO_SHARED_DIRECTORY}/helpers/hw_info.cpp
3434
${NEO_SHARED_DIRECTORY}/helpers/hw_info.h
3535
${NEO_SHARED_DIRECTORY}/helpers${BRANCH_DIR_SUFFIX}/hw_info_extended.cpp
36+
${NEO_SHARED_DIRECTORY}/kernel${BRANCH_DIR_SUFFIX}/kernel_descriptor.cpp
37+
${NEO_SHARED_DIRECTORY}/kernel${BRANCH_DIR_SUFFIX}/kernel_descriptor.h
3638
${NEO_SHARED_DIRECTORY}/os_interface/os_library.h
3739
${NEO_SOURCE_DIR}/opencl/source/platform/extensions.cpp
3840
${NEO_SOURCE_DIR}/opencl/source/platform/extensions.h

0 commit comments

Comments
 (0)