Media/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-09-15 13:01:45 +08:00
Code Issues Packages Projects Releases Wiki Activity

Remove unused code

Browse Source 
Change-Id: I342f58dc72a6ed5a9b9d9d30d5c43a109da5ff5b
Signed-off-by: Filip Hazubski <filip.hazubski@intel.com>
This commit is contained in:
Filip Hazubski
2020-09-21 11:42:54 +02:00
parent 9790c2991d
commit d1e0768cf5
6 changed files with 4 additions and 56 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -5389,7 +5389,7 @@ cl_int CL_API_CALL clSetProgramReleaseCallback(cl_program program,
reinterpret_cast<void *>(pfnNotify));
if (retVal == CL_SUCCESS) {
retVal = pProgram->setReleaseCallback(pfnNotify, userData);
retVal = CL_INVALID_OPERATION;
}
return retVal;

1
opencl/source/helpers/destructor_callback.h
View File

@ -28,6 +28,5 @@ class DestructorCallback {
using ContextDestructorCallback = DestructorCallback<cl_context>;
using MemObjDestructorCallback = DestructorCallback<cl_mem>;
using ProgramReleaseCallback = DestructorCallback<cl_program>;
} // namespace NEO

14
opencl/source/program/program.cpp
View File

@ -113,11 +113,6 @@ Program::Program(ExecutionEnvironment &executionEnvironment, Context *context, b
}
Program::~Program() {
for (auto callback : releaseCallbacks) {
callback->invoke(this);
delete callback;
}
cleanCurrentKernelInfo();
freeBlockResources();
@ -271,15 +266,6 @@ cl_int Program::updateSpecializationConstant(cl_uint specId, size_t specSize, co
return CL_INVALID_SPEC_ID;
}
cl_int Program::setReleaseCallback(void(CL_CALLBACK *funcNotify)(cl_program, void *),
void *userData) {
auto cb = new ProgramReleaseCallback(funcNotify, userData);
std::unique_lock<std::mutex> theLock(mtx);
releaseCallbacks.push_front(cb);
return CL_SUCCESS;
}
void Program::setDevice(Device *device) {
this->pDevice = device;
}

5
opencl/source/program/program.h
View File

@ -151,9 +151,6 @@ class Program : public BaseObject<_cl_program> {
cl_int setProgramSpecializationConstant(cl_uint specId, size_t specSize, const void *specValue);
MOCKABLE_VIRTUAL cl_int updateSpecializationConstant(cl_uint specId, size_t specSize, const void *specValue);
cl_int setReleaseCallback(void(CL_CALLBACK *funcNotify)(cl_program, void *),
void *userData);
size_t getNumKernels() const;
const KernelInfo *getKernelInfo(const char *kernelName) const;
const KernelInfo *getKernelInfo(size_t ordinal) const;
@ -351,8 +348,6 @@ class Program : public BaseObject<_cl_program> {
bool isBuiltIn = false;
bool kernelDebugEnabled = false;
std::list<ProgramReleaseCallback *> releaseCallbacks;
};
} // namespace NEO

6
opencl/test/unit_test/api/cl_set_program_release_callback.inl
View File

@ -25,13 +25,13 @@ TEST_F(clSetProgramReleaseCallbackTests, givenPfnNotifyNullptrWhenSettingProgram
void CL_CALLBACK callback(cl_program, void *){};
TEST_F(clSetProgramReleaseCallbackTests, WhenSettingProgramReleaseCallbackThenSucccessIsReturned) {
TEST_F(clSetProgramReleaseCallbackTests, WhenSettingProgramReleaseCallbackThenInvalidOperationErrorIsReturned) {
auto retVal = clSetProgramReleaseCallback(pProgram, callback, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(CL_INVALID_OPERATION, retVal);
auto userData = reinterpret_cast<void *>(0x4321);
retVal = clSetProgramReleaseCallback(pProgram, callback, userData);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(CL_INVALID_OPERATION, retVal);
}
} // namespace ULT

32
opencl/test/unit_test/program/program_tests.cpp
View File

@ -3115,35 +3115,3 @@ TEST(ProgramReplaceDeviceBinary, GivenBinaryZebinThenUseAsBothPackedAndUnpackedB
EXPECT_EQ(0, memcmp(program.packedDeviceBinary.get(), zebin.storage.data(), program.packedDeviceBinarySize));
EXPECT_EQ(0, memcmp(program.unpackedDeviceBinary.get(), zebin.storage.data(), program.unpackedDeviceBinarySize));
}
TEST(Program, WhenSettingProgramReleaseCallbackThenCallOrderIsPreserved) {
struct UserDataType {
cl_program expectedProgram;
std::vector<size_t> &vectorToModify;
size_t valueToAdd;
};
auto callback = [](cl_program program, void *userData) -> void {
auto pUserData = reinterpret_cast<UserDataType *>(userData);
EXPECT_EQ(pUserData->expectedProgram, program);
pUserData->vectorToModify.push_back(pUserData->valueToAdd);
};
MockExecutionEnvironment executionEnvironment;
auto pProgram = new MockProgram{executionEnvironment};
std::vector<size_t> callbacksReturnValues;
UserDataType userDataArray[]{
{pProgram, callbacksReturnValues, 1},
{pProgram, callbacksReturnValues, 2},
{pProgram, callbacksReturnValues, 3}};
for (auto &userData : userDataArray) {
cl_int retVal = clSetProgramReleaseCallback(pProgram, callback, &userData);
ASSERT_EQ(CL_SUCCESS, retVal);
}
delete pProgram;
ASSERT_EQ(3u, callbacksReturnValues.size());
EXPECT_EQ(3u, callbacksReturnValues[0]);
EXPECT_EQ(2u, callbacksReturnValues[1]);
EXPECT_EQ(1u, callbacksReturnValues[2]);
}