Skip to content
This repository was archived by the owner on Mar 28, 2023. It is now read-only.

[SYCL] Remove deprecated buffer interop case after removal #1175

Merged
merged 1 commit into from
Aug 24, 2022
Merged

[SYCL] Remove deprecated buffer interop case after removal #1175

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
205 changes: 0 additions & 205 deletions SYCL/DeprecatedFeatures/buffer_interop.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -22,211 +22,6 @@ using namespace sycl;

int main() {
bool Failed = false;
{
sycl::context Ctx;
cl_context OCLCtx = Ctx.get();

cl_int Error = CL_SUCCESS;
cl_mem OCLBuf =
clCreateBuffer(OCLCtx, CL_MEM_READ_WRITE, sizeof(int), nullptr, &Error);
assert(Error == CL_SUCCESS);
Error = clReleaseContext(OCLCtx);
assert(Error == CL_SUCCESS);

sycl::buffer<int, 1> Buf{OCLBuf, Ctx};

sycl::queue Q;

if (Ctx == Q.get_context()) {
std::cerr << "Expected different contexts" << std::endl;
Failed = true;
}

Q.submit([&](sycl::handler &CGH) {
auto Acc = Buf.get_access<access::mode::write>(CGH);
CGH.single_task<class BufferInterop_DifferentContext>(
[=]() { Acc[0] = 42; });
});

auto Acc = Buf.get_access<sycl::access::mode::read>();
if (Acc[0] != 42) {
std::cerr << "Result is incorrect" << std::endl;
Failed = true;
}
}
{
constexpr size_t Size = 32;
int Init[Size] = {5};
cl_int Error = CL_SUCCESS;
sycl::range<1> InteropRange{Size};
size_t InteropSize = Size * sizeof(int);

queue MyQueue;

cl_context OCLCtx = MyQueue.get_context().get();

cl_mem OpenCLBuffer =
clCreateBuffer(OCLCtx, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR,
Size * sizeof(int), Init, &Error);
assert(Error == CL_SUCCESS);
buffer<int, 1> Buffer{OpenCLBuffer, MyQueue.get_context()};

if (Buffer.get_range() != InteropRange) {
assert(false);
Failed = true;
}
if (Buffer.get_size() != InteropSize) {
assert(false);
Failed = true;
}
if (Buffer.get_count() != Size) {
assert(false);
Failed = true;
}

MyQueue.submit([&](handler &CGH) {
auto B = Buffer.get_access<access::mode::write>(CGH);
CGH.parallel_for<class BufferInterop>(
range<1>{Size}, [=](id<1> Index) { B[Index] = 10; });
});

int Data[Size] = {10};
std::vector<int> Result(Size, 0);
{
buffer<int, 1> BufferData{
Data, range<1>{Size}, {property::buffer::use_host_ptr()}};
BufferData.set_final_data(Result.begin());
MyQueue.submit([&](handler &CGH) {
auto Data = BufferData.get_access<access::mode::write>(CGH);
auto CLData = Buffer.get_access<access::mode::read>(CGH);
CGH.parallel_for<class UseMemContent>(range<1>{Size}, [=](id<1> Index) {
Data[Index] = 2 * CLData[Index];
});
});
}

Error = clReleaseMemObject(OpenCLBuffer);
assert(Error == CL_SUCCESS);

for (size_t i = 0; i < Size; ++i) {
if (Result[i] != 20) {
std::cout << " array[" << i << "] is " << Result[i] << " expected "
<< 20 << std::endl;
assert(false);
Failed = true;
}
}
Error = clReleaseContext(OCLCtx);
assert(Error == CL_SUCCESS);
}
// Check set_final_data
{
constexpr size_t Size = 32;
int Init[Size] = {5};
int Result[Size] = {5};
cl_int Error = CL_SUCCESS;

queue MyQueue;
cl_context OCLCtx = MyQueue.get_context().get();

cl_mem OpenCLBuffer =
clCreateBuffer(OCLCtx, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR,
Size * sizeof(int), Init, &Error);
assert(Error == CL_SUCCESS);
{
buffer<int, 1> Buffer{OpenCLBuffer, MyQueue.get_context()};
Buffer.set_final_data(Result);

MyQueue.submit([&](handler &CGH) {
auto B = Buffer.get_access<access::mode::write>(CGH);
CGH.parallel_for<class FinalData>(range<1>{Size},
[=](id<1> Index) { B[Index] = 10; });
});
}
Error = clReleaseMemObject(OpenCLBuffer);
assert(Error == CL_SUCCESS);
for (size_t i = 0; i < Size; ++i) {
if (Result[i] != 10) {
std::cout << " array[" << i << "] is " << Result[i] << " expected "
<< 10 << std::endl;
assert(false);
Failed = true;
}
}
Error = clReleaseContext(OCLCtx);
assert(Error == CL_SUCCESS);
}
// Check host accessor
{
constexpr size_t Size = 32;
int Init[Size] = {5};
cl_int Error = CL_SUCCESS;

queue MyQueue;
cl_context OCLCtx = MyQueue.get_context().get();

cl_mem OpenCLBuffer =
clCreateBuffer(OCLCtx, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR,
Size * sizeof(int), Init, &Error);
assert(Error == CL_SUCCESS);
buffer<int, 1> Buffer{OpenCLBuffer, MyQueue.get_context()};

MyQueue.submit([&](handler &CGH) {
auto B = Buffer.get_access<access::mode::write>(CGH);
CGH.parallel_for<class HostAccess>(range<1>{Size},
[=](id<1> Index) { B[Index] = 10; });
});
auto Acc = Buffer.get_access<sycl::access::mode::read>();
for (size_t i = 0; i < Size; ++i) {
if (Acc[i] != 10) {
std::cout << " array[" << i << "] is " << Acc[i] << " expected " << 10
<< std::endl;
assert(false);
Failed = true;
}
}
Error = clReleaseMemObject(OpenCLBuffer);
assert(Error == CL_SUCCESS);
Error = clReleaseContext(OCLCtx);
assert(Error == CL_SUCCESS);
}
// Check interop constructor event
{
// Checks that the cl_event is not deleted on memory object destruction
queue MyQueue;
cl_context OpenCLContext = MyQueue.get_context().get();

int Val;
cl_int Error = CL_SUCCESS;
cl_mem OpenCLBuffer =
clCreateBuffer(OpenCLContext, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR,
sizeof(int), &Val, &Error);
assert(Error == CL_SUCCESS);
cl_event OpenCLEvent = clCreateUserEvent(OpenCLContext, &Error);
assert(Error == CL_SUCCESS);
assert(clSetUserEventStatus(OpenCLEvent, CL_COMPLETE) == CL_SUCCESS);

{
event Event(OpenCLEvent, OpenCLContext);
buffer<int, 1> Buffer{OpenCLBuffer, MyQueue.get_context(), Event};

MyQueue.submit([&](handler &Cgh) {
auto Acc = Buffer.get_access<access::mode::write>(Cgh);
Cgh.single_task<class TestEvent>([=]() { Acc[0] = 42; });
});

auto Acc = Buffer.get_access<access::mode::read>();
if (42 != Acc[0]) {
assert(false);
Failed = true;
}
}

assert(clReleaseMemObject(OpenCLBuffer) == CL_SUCCESS);
assert(clReleaseContext(OpenCLContext) == CL_SUCCESS);
assert(clReleaseEvent(OpenCLEvent) == CL_SUCCESS);
}

{
queue Queue;
if (!Queue.is_host()) {
Expand Down