diff --git a/benchmark/CMakeLists.txt b/benchmark/CMakeLists.txt index 8ccc553a8..351d63c64 100644 --- a/benchmark/CMakeLists.txt +++ b/benchmark/CMakeLists.txt @@ -36,3 +36,8 @@ add_executable(benchmark_maximum_projections benchmark_maximum_projections.cpp) target_compile_features(benchmark_maximum_projections PUBLIC cxx_std_17) target_link_libraries(benchmark_maximum_projections benchmark_kernel) set_target_properties(benchmark_maximum_projections PROPERTIES FOLDER "Benchmark") + +add_executable(benchmark_push_pull benchmark_push_pull.cpp) +target_compile_features(benchmark_push_pull PUBLIC cxx_std_17) +target_link_libraries(benchmark_push_pull benchmark_kernel) +set_target_properties(benchmark_push_pull PROPERTIES FOLDER "Benchmark") diff --git a/benchmark/benchmark_push_pull.cpp b/benchmark/benchmark_push_pull.cpp new file mode 100644 index 000000000..2aede9de1 --- /dev/null +++ b/benchmark/benchmark_push_pull.cpp @@ -0,0 +1,62 @@ +#include +#include +#include + +#include "clesperanto.hpp" + +#include + +class PushPullBenchmark : public BenchmarkBase +{ +protected: + cle::Clesperanto cle; + std::vector inputData; + std::array dim; + auto + Setup() -> void override + { + inputData = std::vector(dataWidth * dataWidth * dataWidth); + dim = std::array{ { dataWidth, dataWidth, dataWidth } }; + + cle.GetDevice()->WaitForKernelToFinish(); + } + + auto + Iteration() -> void override + { + auto gpuInput = cle.Push(inputData, dim); + auto output = cle.Pull(gpuInput); + } + + auto + Teardown() -> void override + {} + +public: + size_t dataWidth = 0; + + PushPullBenchmark() + : cle(cle::Clesperanto()) + {} + + ~PushPullBenchmark() = default; +}; + +auto +main(int argc, char ** argv) -> int +{ + PushPullBenchmark d; + d.dataWidth = 1 << 10; + + d.iterationWarmupCount = 5; + + if (argc >= 2) + { + d.dataWidth = std::stoi(argv[1]); + std::cout << "using " << d.dataWidth * d.dataWidth * d.dataWidth * sizeof(float) << " bytes memory" << std::endl; + } + + d.Run(); + + return 0; +} diff --git a/clic/include/core/cleBackend.hpp b/clic/include/core/cleBackend.hpp index 3447e33a9..4d1bc7513 100644 --- a/clic/include/core/cleBackend.hpp +++ b/clic/include/core/cleBackend.hpp @@ -360,6 +360,113 @@ EnqueueKernelExecution(const cl::CommandQueue & queue_pointer, } } +// inline auto +// EnqueueUnmapMemObject(const cl::CommandQueue & queue_pointer, const cl::Memory & memory_pointer, void * ptr) -> void +// { +// cl_int err = queue_pointer.enqueueUnmapMemObject(memory_pointer, ptr); +// if (err != CL_SUCCESS) +// { +// std::cerr << "Backend error in EnqueueUnmapMemObject: " << GetOpenCLErrorInfo(err) << std::endl; +// } +// } + +// inline auto +// EnqueueMapImage(const cl::CommandQueue & queue_pointer, +// const cl::Memory & image_pointer, +// const bool & block_flag, +// const std::array & origin, +// const std::array & region) -> void * +// { +// void * ptr = nullptr; +// cl_int err = CL_SUCCESS; +// if (image_pointer.getInfo() == CL_MEM_OBJECT_IMAGE1D) +// { +// const cl::Image1D memory(image_pointer.get(), true); +// ptr = queue_pointer.enqueueMapImage(memory, +// static_cast(block_flag), +// CL_MAP_READ | CL_MAP_WRITE, +// origin, +// region, +// nullptr, +// nullptr, +// nullptr, +// nullptr, +// &err); +// if (err != CL_SUCCESS) +// { +// std::cerr << "Backend error in EnqueueMapImage 1D: " << GetOpenCLErrorInfo(err) << std::endl; +// } +// return ptr; +// } +// if (image_pointer.getInfo() == CL_MEM_OBJECT_IMAGE2D) +// { +// const cl::Image2D memory(image_pointer.get(), true); +// ptr = queue_pointer.enqueueMapImage(memory, +// static_cast(block_flag), +// CL_MAP_READ | CL_MAP_WRITE, +// origin, +// region, +// nullptr, +// nullptr, +// nullptr, +// nullptr, +// &err); +// if (err != CL_SUCCESS) +// { +// std::cerr << "Backend error in EnqueueMapImage 2D: " << GetOpenCLErrorInfo(err) << std::endl; +// } +// return ptr; +// } +// if (image_pointer.getInfo() == CL_MEM_OBJECT_IMAGE3D) +// { +// const cl::Image3D memory(image_pointer.get(), true); +// ptr = queue_pointer.enqueueMapImage(memory, +// static_cast(block_flag), +// CL_MAP_READ | CL_MAP_WRITE, +// origin, +// region, +// nullptr, +// nullptr, +// nullptr, +// nullptr, +// &err); +// if (err != CL_SUCCESS) +// { +// std::cerr << "Backend error in EnqueueMapImage 3D: " << GetOpenCLErrorInfo(err) << std::endl; +// } +// return ptr; +// } +// if (err != CL_SUCCESS) +// { +// std::cerr << "Backend error in EnqueueMapImage: " << GetOpenCLErrorInfo(err) << std::endl; +// } +// return ptr; +// } + +// inline auto +// EnqueueMapBuffer(const cl::CommandQueue & queue_pointer, +// const cl::Memory & buffer_pointer, +// const bool & block_flag, +// const size_t & offset, +// const size_t & length_in_bytes) -> void * +// { +// const cl::Buffer memory(buffer_pointer.get(), true); +// cl_int err = CL_SUCCESS; +// void * ptr = queue_pointer.enqueueMapBuffer(memory, +// static_cast(block_flag), +// CL_MAP_READ | CL_MAP_WRITE, +// offset, +// length_in_bytes, +// nullptr, +// nullptr, +// &err); +// if (err != CL_SUCCESS) +// { +// std::cerr << "Backend error in EnqueueMapBuffer: " << GetOpenCLErrorInfo(err) << std::endl; +// } +// return ptr; +// } + inline auto EnqueueReadFromBuffer(const cl::CommandQueue & queue_pointer, const cl::Memory & buffer_pointer, @@ -482,10 +589,10 @@ EnqueueCopyBuffer(const cl::CommandQueue & queue_pointer, size_t dst_offset, const size_t & length_in_bytes) -> void { - const cl::Buffer src_memory(src_buffer_pointer.get(), true); + const cl::Buffer memory(src_buffer_pointer.get(), true); const cl::Buffer dst_memory(dst_buffer_pointer.get(), true); cl_int err = - queue_pointer.enqueueCopyBuffer(src_memory, dst_memory, src_offset, dst_offset, length_in_bytes, nullptr, nullptr); + queue_pointer.enqueueCopyBuffer(memory, dst_memory, src_offset, dst_offset, length_in_bytes, nullptr, nullptr); if (err != CL_SUCCESS) { std::cerr << "Backend error in EnqueueCopyBuffer : " << GetOpenCLErrorInfo(err) << std::endl; @@ -505,15 +612,15 @@ EnqueueCopyBufferRect(const cl::CommandQueue & queue_pointer, const std::array & dst_origin, const std::array & region) -> void { - const cl::Buffer src_memory(src_buffer_pointer.get(), true); + const cl::Buffer memory(src_buffer_pointer.get(), true); const cl::Buffer dst_memory(dst_buffer_pointer.get(), true); - size_t elementByteSize = src_memory.getInfo() / (region[0] * region[1] * region[2]); + size_t elementByteSize = memory.getInfo() / (region[0] * region[1] * region[2]); auto bufferRegion = const_cast &>(region); bufferRegion[0] *= elementByteSize; cl_int err = queue_pointer.enqueueCopyBufferRect( - src_memory, dst_memory, src_origin, dst_origin, bufferRegion, 0, 0, 0, 0, nullptr, nullptr); + memory, dst_memory, src_origin, dst_origin, bufferRegion, 0, 0, 0, 0, nullptr, nullptr); if (err != CL_SUCCESS) { std::cerr << "Backend error in EnqueueCopyBufferRect : " << GetOpenCLErrorInfo(err) << std::endl; @@ -530,36 +637,45 @@ EnqueueCopyBufferToImage(const cl::CommandQueue & queue_pointer, const std::array & dst_region) -> void { cl_int err = CL_SUCCESS; - const cl::Buffer src_memory(src_buffer_pointer.get(), true); - switch (dst_image_pointer.getInfo()) - { - case CL_MEM_OBJECT_IMAGE1D: { - const cl::Image1D dst_memory(dst_image_pointer.get(), true); - err = queue_pointer.enqueueCopyBufferToImage( - src_memory, dst_memory, src_offset, dst_origin, dst_region, nullptr, nullptr); - break; + const cl::Buffer memory(src_buffer_pointer.get(), true); + + if (dst_image_pointer.getInfo() == CL_MEM_OBJECT_IMAGE1D) + { + const cl::Image1D dst_memory(dst_image_pointer.get(), true); + err = + queue_pointer.enqueueCopyBufferToImage(memory, dst_memory, src_offset, dst_origin, dst_region, nullptr, nullptr); + if (err != CL_SUCCESS) + { + std::cerr << "Backend error in EnqueueCopyBufferToImage 1D : " << GetOpenCLErrorInfo(err) << std::endl; } - case CL_MEM_OBJECT_IMAGE2D: { - const cl::Image2D dst_memory(dst_image_pointer.get(), true); - err = queue_pointer.enqueueCopyBufferToImage( - src_memory, dst_memory, src_offset, dst_origin, dst_region, nullptr, nullptr); - break; + return; + } + if (dst_image_pointer.getInfo() == CL_MEM_OBJECT_IMAGE2D) + { + const cl::Image2D dst_memory(dst_image_pointer.get(), true); + err = + queue_pointer.enqueueCopyBufferToImage(memory, dst_memory, src_offset, dst_origin, dst_region, nullptr, nullptr); + if (err != CL_SUCCESS) + { + std::cerr << "Backend error in EnqueueCopyBufferToImage 2D : " << GetOpenCLErrorInfo(err) << std::endl; } - case CL_MEM_OBJECT_IMAGE3D: { - const cl::Image3D dst_memory(dst_image_pointer.get(), true); - err = queue_pointer.enqueueCopyBufferToImage( - src_memory, dst_memory, src_offset, dst_origin, dst_region, nullptr, nullptr); - break; + return; + } + if (dst_image_pointer.getInfo() == CL_MEM_OBJECT_IMAGE3D) + { + const cl::Image3D dst_memory(dst_image_pointer.get(), true); + err = + queue_pointer.enqueueCopyBufferToImage(memory, dst_memory, src_offset, dst_origin, dst_region, nullptr, nullptr); + if (err != CL_SUCCESS) + { + std::cerr << "Backend error in EnqueueCopyBufferToImage 3D : " << GetOpenCLErrorInfo(err) << std::endl; } + return; } if (err != CL_SUCCESS) { std::cerr << "Backend error in EnqueueCopyBufferToImage : " << GetOpenCLErrorInfo(err) << std::endl; } - if (block_flag) - { - WaitQueueToFinish(queue_pointer); - } } inline auto @@ -573,35 +689,45 @@ EnqueueCopyImageToBuffer(const cl::CommandQueue & queue_pointer, { cl_int err = CL_SUCCESS; const cl::Buffer dst_memory(dst_buffer_pointer.get(), true); - switch (src_image_pointer.getInfo()) + + + if (src_image_pointer.getInfo() == CL_MEM_OBJECT_IMAGE1D) { - case CL_MEM_OBJECT_IMAGE1D: { - const cl::Image1D src_memory(src_image_pointer.get(), true); - err = queue_pointer.enqueueCopyImageToBuffer( - src_memory, dst_memory, src_origin, src_region, dst_offset, nullptr, nullptr); - break; + const cl::Image1D src_memory(src_image_pointer.get(), true); + err = queue_pointer.enqueueCopyImageToBuffer( + src_memory, dst_memory, src_origin, src_region, dst_offset, nullptr, nullptr); + if (err != CL_SUCCESS) + { + std::cerr << "Backend error in EnqueueCopyImageToBuffer 1D : " << GetOpenCLErrorInfo(err) << std::endl; } - case CL_MEM_OBJECT_IMAGE2D: { - const cl::Image2D src_memory(src_image_pointer.get(), true); - err = queue_pointer.enqueueCopyImageToBuffer( - src_memory, dst_memory, src_origin, src_region, dst_offset, nullptr, nullptr); - break; + return; + } + if (src_image_pointer.getInfo() == CL_MEM_OBJECT_IMAGE2D) + { + const cl::Image2D src_memory(src_image_pointer.get(), true); + err = queue_pointer.enqueueCopyImageToBuffer( + src_memory, dst_memory, src_origin, src_region, dst_offset, nullptr, nullptr); + if (err != CL_SUCCESS) + { + std::cerr << "Backend error in EnqueueCopyImageToBuffer 2D : " << GetOpenCLErrorInfo(err) << std::endl; } - case CL_MEM_OBJECT_IMAGE3D: { - const cl::Image3D src_memory(src_image_pointer.get(), true); - err = queue_pointer.enqueueCopyImageToBuffer( - src_memory, dst_memory, src_origin, src_region, dst_offset, nullptr, nullptr); - break; + return; + } + if (src_image_pointer.getInfo() == CL_MEM_OBJECT_IMAGE3D) + { + const cl::Image3D src_memory(src_image_pointer.get(), true); + err = queue_pointer.enqueueCopyImageToBuffer( + src_memory, dst_memory, src_origin, src_region, dst_offset, nullptr, nullptr); + if (err != CL_SUCCESS) + { + std::cerr << "Backend error in EnqueueCopyImageToBuffer 3D : " << GetOpenCLErrorInfo(err) << std::endl; } + return; } if (err != CL_SUCCESS) { std::cerr << "Backend error in EnqueueCopyImageToBuffer : " << GetOpenCLErrorInfo(err) << std::endl; } - if (block_flag) - { - WaitQueueToFinish(queue_pointer); - } } inline auto @@ -613,26 +739,39 @@ EnqueueReadFromImage(const cl::CommandQueue & queue_pointer, void * host_memory_pointer) -> void { cl_int err = CL_SUCCESS; - switch (image_pointer.getInfo()) + + if (image_pointer.getInfo() == CL_MEM_OBJECT_IMAGE1D) { - case CL_MEM_OBJECT_IMAGE1D: { - const cl::Image1D memory(image_pointer.get(), true); - err = queue_pointer.enqueueReadImage( - memory, static_cast(block_flag), origin, region, 0, 0, host_memory_pointer, nullptr, nullptr); - break; + const cl::Image1D memory(image_pointer.get(), true); + err = queue_pointer.enqueueReadImage( + memory, static_cast(block_flag), origin, region, 0, 0, host_memory_pointer, nullptr, nullptr); + if (err != CL_SUCCESS) + { + std::cerr << "Backend error in EnqueueReadFromImage 1D : " << GetOpenCLErrorInfo(err) << std::endl; } - case CL_MEM_OBJECT_IMAGE2D: { - const cl::Image2D memory(image_pointer.get(), true); - err = queue_pointer.enqueueReadImage( - memory, static_cast(block_flag), origin, region, 0, 0, host_memory_pointer, nullptr, nullptr); - break; + return; + } + if (image_pointer.getInfo() == CL_MEM_OBJECT_IMAGE2D) + { + const cl::Image2D memory(image_pointer.get(), true); + err = queue_pointer.enqueueReadImage( + memory, static_cast(block_flag), origin, region, 0, 0, host_memory_pointer, nullptr, nullptr); + if (err != CL_SUCCESS) + { + std::cerr << "Backend error in EnqueueReadFromImage 2D : " << GetOpenCLErrorInfo(err) << std::endl; } - case CL_MEM_OBJECT_IMAGE3D: { - const cl::Image3D memory(image_pointer.get(), true); - err = queue_pointer.enqueueReadImage( - memory, static_cast(block_flag), origin, region, 0, 0, host_memory_pointer, nullptr, nullptr); - break; + return; + } + if (image_pointer.getInfo() == CL_MEM_OBJECT_IMAGE3D) + { + const cl::Image3D memory(image_pointer.get(), true); + err = queue_pointer.enqueueReadImage( + memory, static_cast(block_flag), origin, region, 0, 0, host_memory_pointer, nullptr, nullptr); + if (err != CL_SUCCESS) + { + std::cerr << "Backend error in EnqueueReadFromImage 3D : " << GetOpenCLErrorInfo(err) << std::endl; } + return; } if (err != CL_SUCCESS) { @@ -649,26 +788,39 @@ EnqueueWriteToImage(const cl::CommandQueue & queue_pointer, const void * host_memory_pointer) -> void { cl_int err = CL_SUCCESS; - switch (image_pointer.getInfo()) + + if (image_pointer.getInfo() == CL_MEM_OBJECT_IMAGE1D) { - case CL_MEM_OBJECT_IMAGE1D: { - const cl::Image1D memory(image_pointer.get(), true); - err = queue_pointer.enqueueWriteImage( - memory, static_cast(block_flag), origin, region, 0, 0, host_memory_pointer, nullptr, nullptr); - break; + const cl::Image1D memory(image_pointer.get(), true); + err = queue_pointer.enqueueWriteImage( + memory, static_cast(block_flag), origin, region, 0, 0, host_memory_pointer, nullptr, nullptr); + if (err != CL_SUCCESS) + { + std::cerr << "Backend error in EnqueueWriteToImage 1D : " << GetOpenCLErrorInfo(err) << std::endl; } - case CL_MEM_OBJECT_IMAGE2D: { - const cl::Image2D memory(image_pointer.get(), true); - err = queue_pointer.enqueueWriteImage( - memory, static_cast(block_flag), origin, region, 0, 0, host_memory_pointer, nullptr, nullptr); - break; + return; + } + if (image_pointer.getInfo() == CL_MEM_OBJECT_IMAGE2D) + { + const cl::Image2D memory(image_pointer.get(), true); + err = queue_pointer.enqueueWriteImage( + memory, static_cast(block_flag), origin, region, 0, 0, host_memory_pointer, nullptr, nullptr); + if (err != CL_SUCCESS) + { + std::cerr << "Backend error in EnqueueWriteToImage 2D : " << GetOpenCLErrorInfo(err) << std::endl; } - case CL_MEM_OBJECT_IMAGE3D: { - const cl::Image3D memory(image_pointer.get(), true); - err = queue_pointer.enqueueWriteImage( - memory, static_cast(block_flag), origin, region, 0, 0, host_memory_pointer, nullptr, nullptr); - break; + return; + } + if (image_pointer.getInfo() == CL_MEM_OBJECT_IMAGE3D) + { + const cl::Image3D memory(image_pointer.get(), true); + err = queue_pointer.enqueueWriteImage( + memory, static_cast(block_flag), origin, region, 0, 0, host_memory_pointer, nullptr, nullptr); + if (err != CL_SUCCESS) + { + std::cerr << "Backend error in EnqueueWriteToImage 3D : " << GetOpenCLErrorInfo(err) << std::endl; } + return; } if (err != CL_SUCCESS) { @@ -686,32 +838,40 @@ EnqueueFillImage(const cl::CommandQueue & queue_pointer, const NativeType & pattern) -> void { cl_int err = CL_SUCCESS; - switch (image_pointer.getInfo()) + if (image_pointer.getInfo() == CL_MEM_OBJECT_IMAGE1D) { - case CL_MEM_OBJECT_IMAGE1D: { - const cl::Image1D memory(image_pointer.get(), true); - err = queue_pointer.enqueueFillImage(memory, pattern, origin, region, nullptr, nullptr); - break; + const cl::Image1D memory(image_pointer.get(), true); + err = queue_pointer.enqueueFillImage(memory, pattern, origin, region, nullptr, nullptr); + if (err != CL_SUCCESS) + { + std::cerr << "Backend error in EnqueueFillImage 1D : " << GetOpenCLErrorInfo(err) << std::endl; } - case CL_MEM_OBJECT_IMAGE2D: { - const cl::Image2D memory(image_pointer.get(), true); - err = queue_pointer.enqueueFillImage(memory, pattern, origin, region, nullptr, nullptr); - break; + return; + } + if (image_pointer.getInfo() == CL_MEM_OBJECT_IMAGE2D) + { + const cl::Image2D memory(image_pointer.get(), true); + err = queue_pointer.enqueueFillImage(memory, pattern, origin, region, nullptr, nullptr); + if (err != CL_SUCCESS) + { + std::cerr << "Backend error in EnqueueFillImage 2D : " << GetOpenCLErrorInfo(err) << std::endl; } - case CL_MEM_OBJECT_IMAGE3D: { - const cl::Image3D memory(image_pointer.get(), true); - err = queue_pointer.enqueueFillImage(memory, pattern, origin, region, nullptr, nullptr); - break; + return; + } + if (image_pointer.getInfo() == CL_MEM_OBJECT_IMAGE3D) + { + const cl::Image3D memory(image_pointer.get(), true); + err = queue_pointer.enqueueFillImage(memory, pattern, origin, region, nullptr, nullptr); + if (err != CL_SUCCESS) + { + std::cerr << "Backend error in EnqueueFillImage 3D : " << GetOpenCLErrorInfo(err) << std::endl; } + return; } if (err != CL_SUCCESS) { std::cerr << "Backend error in EnqueueFillImage : " << GetOpenCLErrorInfo(err) << std::endl; } - if (block_flag) - { - WaitQueueToFinish(queue_pointer); - } } inline auto @@ -724,35 +884,43 @@ EnqueueCopyImage(const cl::CommandQueue & queue_pointer, const std::array & region) -> void { cl_int err = CL_SUCCESS; - switch (src_image_pointer.getInfo()) + if (src_image_pointer.getInfo() == CL_MEM_OBJECT_IMAGE1D) { - case CL_MEM_OBJECT_IMAGE1D: { - const cl::Image1D src_memory(src_image_pointer.get(), true); - const cl::Image1D dst_memory(dst_image_pointer.get(), true); - err = queue_pointer.enqueueCopyImage(src_memory, dst_memory, src_origin, dst_origin, region, nullptr, nullptr); - break; + const cl::Image1D memory(src_image_pointer.get(), true); + const cl::Image1D dst_memory(dst_image_pointer.get(), true); + err = queue_pointer.enqueueCopyImage(memory, dst_memory, src_origin, dst_origin, region, nullptr, nullptr); + if (err != CL_SUCCESS) + { + std::cerr << "Backend error in EnqueueCopyImage 1D : " << GetOpenCLErrorInfo(err) << std::endl; } - case CL_MEM_OBJECT_IMAGE2D: { - const cl::Image2D src_memory(src_image_pointer.get(), true); - const cl::Image2D dst_memory(dst_image_pointer.get(), true); - err = queue_pointer.enqueueCopyImage(src_memory, dst_memory, src_origin, dst_origin, region, nullptr, nullptr); - break; + return; + } + if (src_image_pointer.getInfo() == CL_MEM_OBJECT_IMAGE2D) + { + const cl::Image2D memory(src_image_pointer.get(), true); + const cl::Image2D dst_memory(dst_image_pointer.get(), true); + err = queue_pointer.enqueueCopyImage(memory, dst_memory, src_origin, dst_origin, region, nullptr, nullptr); + if (err != CL_SUCCESS) + { + std::cerr << "Backend error in EnqueueCopyImage 2D : " << GetOpenCLErrorInfo(err) << std::endl; } - case CL_MEM_OBJECT_IMAGE3D: { - const cl::Image3D src_memory(src_image_pointer.get(), true); - const cl::Image3D dst_memory(dst_image_pointer.get(), true); - err = queue_pointer.enqueueCopyImage(src_memory, dst_memory, src_origin, dst_origin, region, nullptr, nullptr); - break; + return; + } + if (src_image_pointer.getInfo() == CL_MEM_OBJECT_IMAGE3D) + { + const cl::Image3D memory(src_image_pointer.get(), true); + const cl::Image3D dst_memory(dst_image_pointer.get(), true); + err = queue_pointer.enqueueCopyImage(memory, dst_memory, src_origin, dst_origin, region, nullptr, nullptr); + if (err != CL_SUCCESS) + { + std::cerr << "Backend error in EnqueueCopyImage 3D : " << GetOpenCLErrorInfo(err) << std::endl; } + return; } if (err != CL_SUCCESS) { std::cerr << "Backend error in EnqueueCopyImage : " << GetOpenCLErrorInfo(err) << std::endl; } - if (block_flag) - { - WaitQueueToFinish(queue_pointer); - } } } // namespace cle::Backend diff --git a/clic/include/core/cleMemory.hpp b/clic/include/core/cleMemory.hpp index e979b4f68..543f7fa9c 100644 --- a/clic/include/core/cleMemory.hpp +++ b/clic/include/core/cleMemory.hpp @@ -38,12 +38,17 @@ WriteBufferObject(const Image & image, const std::vector & array) -> void if (image.Ndim() == 1) { Backend::EnqueueWriteToBuffer(image.GetDevice()->QueuePtr(), image.Get(), true, 0, byte_length, array.data()); + return; } - else - { - Backend::EnqueueWriteToBufferRect( - image.GetDevice()->QueuePtr(), image.Get(), true, image.Origin(), image.Origin(), image.Shape(), array.data()); - } + Backend::EnqueueWriteToBufferRect( + image.GetDevice()->QueuePtr(), image.Get(), true, image.Origin(), image.Origin(), image.Shape(), array.data()); + + //** this may be only interesting if the buffer is very large and if both map and unmap are done + //** in the same scope + // auto ptr = Backend::EnqueueMapBuffer(image.GetDevice()->QueuePtr(), image.Get(), true, 0, byte_length); + // std::memcpy(ptr, array.data(), byte_length); + // Backend::EnqueueUnmapMemObject(image.GetDevice()->QueuePtr(), image.Get(), ptr); + // return; } template @@ -60,24 +65,29 @@ ReadBufferObject(const Image & image, const std::vector & array) -> void { if (sizeof(type) != image.GetSizeOfElements()) { - throw(std::runtime_error("Error: Buffer and host array are not of the same type.")); + throw(std::runtime_error("Error: Buffer and host array are not of the same data type.")); } size_t byte_length = array.size() * DataTypeToSizeOf(image.GetDataType()); if (image.Ndim() == 1) { Backend::EnqueueReadFromBuffer( image.GetDevice()->QueuePtr(), image.Get(), true, 0, byte_length, (void *)(array.data())); + return; } - else - { - Backend::EnqueueReadFromBufferRect(image.GetDevice()->QueuePtr(), - image.Get(), - true, - image.Origin(), - image.Origin(), - image.Shape(), - (void *)(array.data())); - } + Backend::EnqueueReadFromBufferRect(image.GetDevice()->QueuePtr(), + image.Get(), + true, + image.Origin(), + image.Origin(), + image.Shape(), + (void *)(array.data())); + + //** this may be only interesting if the buffer is very large and if both map and unmap are done + //** in the same scope + // auto ptr = Backend::EnqueueMapBuffer(image.GetDevice()->QueuePtr(), image.Get(), true, 0, byte_length); + // std::memcpy((void *)(array.data()), ptr, byte_length); + // Backend::EnqueueUnmapMemObject(image.GetDevice()->QueuePtr(), image.Get(), ptr); + // return; } template