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

fix: Remove unneeded cast from clCloneKernel API call

Browse Source 
Related-To: NEO-8330
Signed-off-by: Kacper Nowak <kacper.nowak@intel.com>
This commit is contained in:
Kacper Nowak
2023-09-07 20:32:49 +00:00
committed by Compute-Runtime-Automation
parent ac97b1c493
commit 66c030b5a0
2 changed files with 73 additions and 9 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
opencl/source/api/api.cpp
View File

@@ -5737,30 +5737,31 @@ cl_kernel CL_API_CALL clCloneKernel(cl_kernel sourceKernel,
cl_int *errcodeRet) { cl_int *errcodeRet) {
TRACING_ENTER(ClCloneKernel, &sourceKernel, &errcodeRet); TRACING_ENTER(ClCloneKernel, &sourceKernel, &errcodeRet);
MultiDeviceKernel *pSourceMultiDeviceKernel = nullptr; MultiDeviceKernel *pSourceMultiDeviceKernel = nullptr;
MultiDeviceKernel *pClonedMultiDeviceKernel = nullptr; cl_kernel clonedMultiDeviceKernel = nullptr;
auto retVal = validateObjects(withCastToInternal(sourceKernel, &pSourceMultiDeviceKernel)); auto retVal = validateObjects(withCastToInternal(sourceKernel, &pSourceMultiDeviceKernel));
API_ENTER(&retVal); API_ENTER(&retVal);
DBG_LOG_INPUTS("sourceKernel", sourceKernel); DBG_LOG_INPUTS("sourceKernel", sourceKernel);
if (CL_SUCCESS == retVal) { if (CL_SUCCESS == retVal) {
pClonedMultiDeviceKernel = MultiDeviceKernel::create(pSourceMultiDeviceKernel->getProgram(), clonedMultiDeviceKernel = MultiDeviceKernel::create(pSourceMultiDeviceKernel->getProgram(),
pSourceMultiDeviceKernel->getKernelInfos(), pSourceMultiDeviceKernel->getKernelInfos(),
retVal); retVal);
UNRECOVERABLE_IF((pClonedMultiDeviceKernel == nullptr) || (retVal != CL_SUCCESS)); UNRECOVERABLE_IF((clonedMultiDeviceKernel == nullptr) || (retVal != CL_SUCCESS));
auto pClonedMultiDeviceKernel = castToObject<MultiDeviceKernel>(clonedMultiDeviceKernel);
retVal = pClonedMultiDeviceKernel->cloneKernel(pSourceMultiDeviceKernel); retVal = pClonedMultiDeviceKernel->cloneKernel(pSourceMultiDeviceKernel);
} }
if (errcodeRet) { if (errcodeRet) {
*errcodeRet = retVal; *errcodeRet = retVal;
} }
if (pClonedMultiDeviceKernel != nullptr) { if (clonedMultiDeviceKernel != nullptr) {
gtpinNotifyKernelCreate(pClonedMultiDeviceKernel); gtpinNotifyKernelCreate(clonedMultiDeviceKernel);
} }
TRACING_EXIT(ClCloneKernel, (cl_kernel *)&pClonedMultiDeviceKernel); TRACING_EXIT(ClCloneKernel, &clonedMultiDeviceKernel);
return pClonedMultiDeviceKernel; return clonedMultiDeviceKernel;
} }
CL_API_ENTRY cl_int CL_API_CALL clEnqueueVerifyMemoryINTEL(cl_command_queue commandQueue, CL_API_ENTRY cl_int CL_API_CALL clEnqueueVerifyMemoryINTEL(cl_command_queue commandQueue,

63
opencl/test/unit_test/api/cl_intel_tracing_tests.inl
View File

@@ -1063,4 +1063,67 @@ TEST_F(IntelClLinkProgramTracingTest, givenLinkProgramCallTracingWhenInvokingCal
clReleaseProgram(programReturned); clReleaseProgram(programReturned);
} }
struct IntelClCloneKernelTracingTest : public IntelTracingTest, PlatformFixture {
public:
void SetUp() override {
PlatformFixture::setUp();
IntelTracingTest::setUp();
status = clCreateTracingHandleINTEL(devices[0], callback, this, &handle);
ASSERT_NE(nullptr, handle);
ASSERT_EQ(CL_SUCCESS, status);
status = clSetTracingPointINTEL(handle, CL_FUNCTION_clCloneKernel, CL_TRUE);
ASSERT_EQ(CL_SUCCESS, status);
status = clEnableTracingINTEL(handle);
ASSERT_EQ(CL_SUCCESS, status);
const auto &gfxHelper = pDevice->getGfxCoreHelper();
const_cast<KernelDescriptor &>(pKernel->getKernelInfo().kernelDescriptor).kernelAttributes.simdSize = gfxHelper.getMinimalSIMDSize();
}
void TearDown() override {
status = clDisableTracingINTEL(handle);
ASSERT_EQ(CL_SUCCESS, status);
status = clDestroyTracingHandleINTEL(handle);
ASSERT_EQ(CL_SUCCESS, status);
IntelTracingTest::tearDown();
PlatformFixture::tearDown();
}
protected:
void call() {
cl_kernel sourceKernel = pMultiDeviceKernel;
clonedKernel = clCloneKernel(sourceKernel, &retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
}
void vcallback(cl_function_id fid, cl_callback_data *callbackData, void *userData) override {
ASSERT_EQ(CL_FUNCTION_clCloneKernel, fid);
if (callbackData->site == CL_CALLBACK_SITE_ENTER) {
++enterCount;
} else if (callbackData->site == CL_CALLBACK_SITE_EXIT) {
obtainedClonedKernelCallback = *reinterpret_cast<cl_kernel *>(callbackData->functionReturnValue);
++exitCount;
}
}
cl_kernel clonedKernel = nullptr;
cl_kernel obtainedClonedKernelCallback = nullptr;
uint16_t enterCount = 0;
uint16_t exitCount = 0;
};
TEST_F(IntelClCloneKernelTracingTest, givenCloneKernelCallTracingWhenInvokingCallbackThenPointersFromCallAndCallbackPointToTheSameAddress) {
call();
EXPECT_EQ(1u, enterCount);
EXPECT_EQ(1u, exitCount);
EXPECT_NE(nullptr, clonedKernel);
EXPECT_NE(nullptr, obtainedClonedKernelCallback);
EXPECT_EQ(clonedKernel, obtainedClonedKernelCallback);
clReleaseKernel(clonedKernel);
}
} // namespace ULT } // namespace ULT