diff --git a/runtime/built_ins/sip.cpp b/runtime/built_ins/sip.cpp index 67432cb319..81f8a4f78e 100644 --- a/runtime/built_ins/sip.cpp +++ b/runtime/built_ins/sip.cpp @@ -80,10 +80,6 @@ const char *getSipLlSrc(const Device &device) { SipKernel::SipKernel(SipKernelType type, Program *sipProgram) : type(type) { program.reset(sipProgram); - if (type == SipKernelType::DbgCsr || type == SipKernelType::DbgCsrLocal) { - debugSurfaceBti = 0; - debugSurfaceSize = SipKernel::maxDbgSurfaceSize; - } } GraphicsAllocation *SipKernel::getSipAllocation() const { diff --git a/runtime/built_ins/sip.h b/runtime/built_ins/sip.h index 38d95cdc2a..01d19d706d 100644 --- a/runtime/built_ins/sip.h +++ b/runtime/built_ins/sip.h @@ -58,14 +58,6 @@ class SipKernel { return type; } - int32_t getDebugSurfaceBti() const { - return debugSurfaceBti; - } - - size_t getDebugSurfaceSize() const { - return debugSurfaceSize; - } - static const size_t maxDbgSurfaceSize; GraphicsAllocation *getSipAllocation() const; @@ -73,7 +65,5 @@ class SipKernel { protected: SipKernelType type = SipKernelType::COUNT; std::unique_ptr program; - int32_t debugSurfaceBti = -1; - size_t debugSurfaceSize = 0; }; -} +} // namespace OCLRT diff --git a/runtime/kernel/kernel.h b/runtime/kernel/kernel.h index 90ac7cbd00..ad2954f355 100644 --- a/runtime/kernel/kernel.h +++ b/runtime/kernel/kernel.h @@ -350,6 +350,20 @@ class Kernel : public BaseObject<_cl_kernel> { return isParentKernel && getProgram()->getBlockKernelManager()->getIfBlockUsesPrintf(); } + int32_t getDebugSurfaceBti() const { + if (kernelInfo.patchInfo.pAllocateSystemThreadSurface) { + return kernelInfo.patchInfo.pAllocateSystemThreadSurface->BTI; + } + return -1; + } + + size_t getPerThreadSystemThreadSurfaceSize() const { + if (kernelInfo.patchInfo.pAllocateSystemThreadSurface) { + return kernelInfo.patchInfo.pAllocateSystemThreadSurface->PerThreadSystemThreadSurfaceSize; + } + return 0; + } + protected: struct ObjectCounts { uint32_t imageCount; diff --git a/unit_tests/built_ins/sip_tests.cpp b/unit_tests/built_ins/sip_tests.cpp index e8b257abc1..3de3d97597 100644 --- a/unit_tests/built_ins/sip_tests.cpp +++ b/unit_tests/built_ins/sip_tests.cpp @@ -110,16 +110,6 @@ TEST(Sip, getType) { EXPECT_EQ(SipKernelType::COUNT, undefined.getType()); } -TEST(Sip, givenCsrTypeSipKernelWhenGetDebugSurfaceBtiIsCalledThenInvalidValueIsReturned) { - SipKernel csr{SipKernelType::Csr, getSipProgramWithCustomBinary()}; - EXPECT_EQ(-1, csr.getDebugSurfaceBti()); -} - -TEST(Sip, givenCsrTypeSipKernelWhenGetDebugSurfaceSizeIsCalledThenZeroIsReturned) { - SipKernel csr{SipKernelType::Csr, getSipProgramWithCustomBinary()}; - EXPECT_EQ(0u, csr.getDebugSurfaceSize()); -} - TEST(Sip, givenSipKernelClassWhenAskedForMaxDebugSurfaceSizeThenCorrectValueIsReturned) { EXPECT_EQ(0x49c000u, SipKernel::maxDbgSurfaceSize); } @@ -136,7 +126,7 @@ TEST(DebugSip, WhenRequestingDbgCsrWithLocalMemorySipKernelThenProperCompilerInt EXPECT_STREQ("-cl-include-sip-kernel-local-debug -cl-include-sip-csr -cl-set-bti:0", opt); } -TEST(DebugSip, DISABLED_givenDebugCsrSipKernelWhenAskedForDebugSurfaceBtiAndSizeThenBtiIsZeroAndSizeGreaterThanZero) { +TEST(DebugSip, DISABLED_givenBuiltInsWhenDbgCsrSipIsRequestedThanCorrectSipKernelIsReturned) { auto mockDevice = std::unique_ptr(Device::create(nullptr)); EXPECT_NE(nullptr, mockDevice); MockCompilerDebugVars igcDebugVars; @@ -153,29 +143,9 @@ TEST(DebugSip, DISABLED_givenDebugCsrSipKernelWhenAskedForDebugSurfaceBtiAndSize auto &builtins = BuiltIns::getInstance(); auto &sipKernel = builtins.getSipKernel(SipKernelType::DbgCsr, *mockDevice); - EXPECT_EQ((int32_t)0, sipKernel.getDebugSurfaceBti()); - EXPECT_EQ(SipKernel::maxDbgSurfaceSize, sipKernel.getDebugSurfaceSize()); - + EXPECT_NE(nullptr, &sipKernel); + EXPECT_EQ(SipKernelType::DbgCsr, sipKernel.getType()); gEnvironment->igcPopDebugVars(); } -TEST(DebugSip, givenDbgCsrTypeSipKernelWhenGetDebugSurfaceBtiIsCalledThenInvalidValueIsReturned) { - SipKernel csr{SipKernelType::DbgCsr, getSipProgramWithCustomBinary()}; - EXPECT_EQ(0, csr.getDebugSurfaceBti()); -} - -TEST(DebugSip, givenDbgCsrTypeSipKernelWhenGetDebugSurfaceSizeIsCalledThenNonZeroIsReturned) { - SipKernel csr{SipKernelType::DbgCsr, getSipProgramWithCustomBinary()}; - EXPECT_NE(0u, csr.getDebugSurfaceSize()); -} - -TEST(DebugSip, givenDbgCsrLocalTypeSipKernelWhenGetDebugSurfaceBtiIsCalledThenInvalidValueIsReturned) { - SipKernel csr{SipKernelType::DbgCsrLocal, getSipProgramWithCustomBinary()}; - EXPECT_EQ(0, csr.getDebugSurfaceBti()); -} - -TEST(DebugSip, givenDbgCsrLocalTypeSipKernelWhenGetDebugSurfaceSizeIsCalledThenNonZeroIsReturned) { - SipKernel csr{SipKernelType::DbgCsrLocal, getSipProgramWithCustomBinary()}; - EXPECT_NE(0u, csr.getDebugSurfaceSize()); -} -} // namespace SipKernelTests \ No newline at end of file +} // namespace SipKernelTests diff --git a/unit_tests/gen9/sip_tests.cpp b/unit_tests/gen9/sip_tests.cpp index fd27ea22da..e0fd98438a 100644 --- a/unit_tests/gen9/sip_tests.cpp +++ b/unit_tests/gen9/sip_tests.cpp @@ -1,5 +1,5 @@ /* -* Copyright (c) 2017, Intel Corporation +* Copyright (c) 2017 - 2018, Intel Corporation * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), @@ -53,8 +53,8 @@ GEN9TEST_F(gen9SipTests, DISABLED_givenDebugCsrSipKernelWithLocalMemoryWhenAsked auto &builtins = BuiltIns::getInstance(); auto &sipKernel = builtins.getSipKernel(SipKernelType::DbgCsrLocal, *mockDevice); - EXPECT_EQ((int32_t)0, sipKernel.getDebugSurfaceBti()); - EXPECT_EQ(SipKernel::maxDbgSurfaceSize, sipKernel.getDebugSurfaceSize()); + EXPECT_NE(nullptr, &sipKernel); + EXPECT_EQ(SipKernelType::DbgCsrLocal, sipKernel.getType()); gEnvironment->igcPopDebugVars(); } diff --git a/unit_tests/kernel/CMakeLists.txt b/unit_tests/kernel/CMakeLists.txt index 459a5d0e5a..04760dd1d3 100644 --- a/unit_tests/kernel/CMakeLists.txt +++ b/unit_tests/kernel/CMakeLists.txt @@ -36,6 +36,7 @@ set(IGDRCL_SRCS_tests_kernel ${CMAKE_CURRENT_SOURCE_DIR}/kernel_slm_arg_tests.cpp ${CMAKE_CURRENT_SOURCE_DIR}/kernel_slm_tests.cpp ${CMAKE_CURRENT_SOURCE_DIR}/kernel_tests.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/debug_kernel_tests.cpp ${CMAKE_CURRENT_SOURCE_DIR}/parent_kernel_tests.cpp ) target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_kernel}) diff --git a/unit_tests/kernel/debug_kernel_tests.cpp b/unit_tests/kernel/debug_kernel_tests.cpp new file mode 100644 index 0000000000..b6c0c1662d --- /dev/null +++ b/unit_tests/kernel/debug_kernel_tests.cpp @@ -0,0 +1,96 @@ +/* + * Copyright (c) 2018, Intel Corporation + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR + * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + */ + +#include "unit_tests/fixtures/execution_model_kernel_fixture.h" +#include "unit_tests/mocks/mock_device.h" +#include "unit_tests/mocks/mock_kernel.h" +#include "unit_tests/mocks/mock_program.h" +#include "test.h" + +#include + +using namespace OCLRT; + +class MockDebugKernel : public MockKernel { + public: + MockDebugKernel(Program *program, KernelInfo &kernelInfo, const Device &device) : MockKernel(program, kernelInfo, device) { + if (!kernelInfo.patchInfo.pAllocateSystemThreadSurface) { + SPatchAllocateSystemThreadSurface *patchToken = new SPatchAllocateSystemThreadSurface; + + patchToken->BTI = 0; + patchToken->Offset = 0; + patchToken->PerThreadSystemThreadSurfaceSize = MockDebugKernel::perThreadSystemThreadSurfaceSize; + patchToken->Size = sizeof(SPatchAllocateSystemThreadSurface); + patchToken->Token = iOpenCL::PATCH_TOKEN_ALLOCATE_SIP_SURFACE; + + kernelInfo.patchInfo.pAllocateSystemThreadSurface = patchToken; + + systemThreadSurfaceAllocated = true; + } + } + + ~MockDebugKernel() override { + if (systemThreadSurfaceAllocated) { + delete kernelInfo.patchInfo.pAllocateSystemThreadSurface; + } + } + static const uint32_t perThreadSystemThreadSurfaceSize; + bool systemThreadSurfaceAllocated = false; +}; + +const uint32_t MockDebugKernel::perThreadSystemThreadSurfaceSize = 0x100; + +TEST(DebugKernelTest, givenKernelCompiledForDebuggingWhenGetDebugSurfaceBtiIsCalledThenCorrectValueIsReturned) { + std::unique_ptr device(new MockDevice(*platformDevices[0])); + MockProgram program; + program.enableKernelDebug(); + std::unique_ptr kernel(MockKernel::create(*device.get(), &program)); + + EXPECT_EQ(0, kernel->getDebugSurfaceBti()); +} + +TEST(DebugKernelTest, givenKernelCompiledForDebuggingWhenGetPerThreadSystemThreadSurfaceSizeIsCalledThenCorrectValueIsReturned) { + std::unique_ptr device(new MockDevice(*platformDevices[0])); + MockProgram program; + program.enableKernelDebug(); + std::unique_ptr kernel(MockKernel::create(*device.get(), &program)); + + EXPECT_EQ(MockDebugKernel::perThreadSystemThreadSurfaceSize, kernel->getPerThreadSystemThreadSurfaceSize()); +} + +TEST(DebugKernelTest, givenKernelWithoutDebugFlagWhenGetDebugSurfaceBtiIsCalledThenInvalidIndexValueIsReturned) { + std::unique_ptr device(new MockDevice(*platformDevices[0])); + MockProgram program; + program.enableKernelDebug(); + std::unique_ptr kernel(MockKernel::create(*device.get(), &program)); + + EXPECT_EQ(-1, kernel->getDebugSurfaceBti()); +} + +TEST(DebugKernelTest, givenKernelWithoutDebugFlagWhenGetPerThreadSystemThreadSurfaceSizeIsCalledThenZeroIsReturned) { + std::unique_ptr device(new MockDevice(*platformDevices[0])); + MockProgram program; + program.enableKernelDebug(); + std::unique_ptr kernel(MockKernel::create(*device.get(), &program)); + + EXPECT_EQ(0u, kernel->getPerThreadSystemThreadSurfaceSize()); +} diff --git a/unit_tests/mocks/mock_kernel.cpp b/unit_tests/mocks/mock_kernel.cpp index 198c927bc9..bea0468f27 100644 --- a/unit_tests/mocks/mock_kernel.cpp +++ b/unit_tests/mocks/mock_kernel.cpp @@ -62,5 +62,4 @@ void MockKernel::getResidency(std::vector &dst) { getResidencyCalls++; Kernel::getResidency(dst); } - } // namespace OCLRT diff --git a/unit_tests/mocks/mock_kernel.h b/unit_tests/mocks/mock_kernel.h index fc4e80b180..474422dbda 100644 --- a/unit_tests/mocks/mock_kernel.h +++ b/unit_tests/mocks/mock_kernel.h @@ -97,6 +97,52 @@ class MockKernel : public Kernel { if (Kernel::pSshLocal == mockSshLocal.data()) { Kernel::pSshLocal = nullptr; } + + if (kernelInfoAllocated) { + delete kernelInfoAllocated->heapInfo.pKernelHeader; + delete kernelInfoAllocated->patchInfo.executionEnvironment; + delete kernelInfoAllocated->patchInfo.threadPayload; + delete kernelInfoAllocated; + } + } + + template + static KernelType *create(Device &device, Program *program) { + KernelInfo *info = new KernelInfo(); + const size_t crossThreadSize = 160; + + SKernelBinaryHeaderCommon *header = new SKernelBinaryHeaderCommon; + header->DynamicStateHeapSize = 0; + header->GeneralStateHeapSize = 0; + header->KernelHeapSize = 0; + header->KernelNameSize = 0; + header->PatchListSize = 0; + header->SurfaceStateHeapSize = 0; + info->heapInfo.pKernelHeader = header; + + SPatchThreadPayload *threadPayload = new SPatchThreadPayload; + threadPayload->LocalIDXPresent = 0; + threadPayload->LocalIDYPresent = 0; + threadPayload->LocalIDZPresent = 0; + threadPayload->HeaderPresent = 0; + threadPayload->Size = 128; + + info->patchInfo.threadPayload = threadPayload; + + SPatchExecutionEnvironment *executionEnvironment = new SPatchExecutionEnvironment; + executionEnvironment->HasDeviceEnqueue = 1; + info->patchInfo.executionEnvironment = executionEnvironment; + + info->crossThreadData = new char[crossThreadSize]; + + auto kernel = new KernelType(program, *info, device); + kernel->crossThreadData = new char[crossThreadSize]; + memset(kernel->crossThreadData, 0, crossThreadSize); + kernel->crossThreadDataSize = crossThreadSize; + + kernel->kernelInfoAllocated = info; + + return kernel; } uint32_t getPatchedArgumentsNum() const { return patchedArgumentsNum; } @@ -188,6 +234,9 @@ class MockKernel : public Kernel { uint32_t makeResidentCalls = 0; uint32_t getResidencyCalls = 0; + + protected: + KernelInfo *kernelInfoAllocated = nullptr; }; //class below have enough internals to service Enqueue operation.