From df3103622b7de05f4e35b22a2c94b4a46eab4efc Mon Sep 17 00:00:00 2001 From: Georgios Pinitas Date: Wed, 14 Nov 2018 13:16:56 +0000 Subject: COMPMID-1088: Use IMemoryRegion in interfaces where possible -Simplifies import memory interface -Changes the used of void** handles with appropriate interfaces. Change-Id: I5918c855c11f46352058864623336b352162a4b7 --- src/runtime/GLES_COMPUTE/GCBufferAllocator.cpp | 18 ++--- src/runtime/GLES_COMPUTE/GCMemory.cpp | 81 ++++++++++++++++++++++ src/runtime/GLES_COMPUTE/GCMemoryRegion.cpp | 96 ++++++++++++++++++++++++++ src/runtime/GLES_COMPUTE/GCTensorAllocator.cpp | 40 ++++------- 4 files changed, 201 insertions(+), 34 deletions(-) create mode 100644 src/runtime/GLES_COMPUTE/GCMemory.cpp create mode 100644 src/runtime/GLES_COMPUTE/GCMemoryRegion.cpp (limited to 'src/runtime/GLES_COMPUTE') diff --git a/src/runtime/GLES_COMPUTE/GCBufferAllocator.cpp b/src/runtime/GLES_COMPUTE/GCBufferAllocator.cpp index cdd12c3ad5..70a1f4f8ff 100644 --- a/src/runtime/GLES_COMPUTE/GCBufferAllocator.cpp +++ b/src/runtime/GLES_COMPUTE/GCBufferAllocator.cpp @@ -22,10 +22,10 @@ * SOFTWARE. */ #include "arm_compute/runtime/GLES_COMPUTE/GCBufferAllocator.h" -#include "arm_compute/runtime/GLES_COMPUTE/GCTensorAllocator.h" #include "arm_compute/core/Error.h" #include "arm_compute/core/GLES_COMPUTE/OpenGLES.h" +#include "arm_compute/runtime/GLES_COMPUTE/GCMemoryRegion.h" #include @@ -34,24 +34,26 @@ namespace arm_compute void *GCBufferAllocator::allocate(size_t size, size_t alignment) { ARM_COMPUTE_UNUSED(alignment); - auto *gl_buffer = new GLBufferWrapper(); - ARM_COMPUTE_GL_CHECK(glBindBuffer(GL_SHADER_STORAGE_BUFFER, gl_buffer->_ssbo_name)); + + auto *gl_ssbo_name = new GLuint; + ARM_COMPUTE_GL_CHECK(glBindBuffer(GL_SHADER_STORAGE_BUFFER, *gl_ssbo_name)); ARM_COMPUTE_GL_CHECK(glBufferData(GL_SHADER_STORAGE_BUFFER, static_cast(size), nullptr, GL_STATIC_DRAW)); ARM_COMPUTE_GL_CHECK(glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0)); - return reinterpret_cast(gl_buffer); + return reinterpret_cast(gl_ssbo_name); } void GCBufferAllocator::free(void *ptr) { ARM_COMPUTE_ERROR_ON(ptr == nullptr); - auto *gl_buffer = reinterpret_cast(ptr); - delete gl_buffer; + auto *gl_ssbo_name = reinterpret_cast(ptr); + ARM_COMPUTE_GL_CHECK(glDeleteBuffers(1, gl_ssbo_name)); + delete gl_ssbo_name; } std::unique_ptr GCBufferAllocator::make_region(size_t size, size_t alignment) { - ARM_COMPUTE_UNUSED(size, alignment); - return nullptr; + ARM_COMPUTE_UNUSED(alignment); + return arm_compute::support::cpp14::make_unique(size); } } // namespace arm_compute diff --git a/src/runtime/GLES_COMPUTE/GCMemory.cpp b/src/runtime/GLES_COMPUTE/GCMemory.cpp new file mode 100644 index 0000000000..fed4a158a3 --- /dev/null +++ b/src/runtime/GLES_COMPUTE/GCMemory.cpp @@ -0,0 +1,81 @@ +/* + * Copyright (c) 2018 ARM Limited. + * + * SPDX-License-Identifier: MIT + * + * 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 "arm_compute/runtime/GLES_COMPUTE/GCMemory.h" + +#include "arm_compute/core/utils/misc/Cast.h" +#include "arm_compute/runtime/GLES_COMPUTE/GCMemoryRegion.h" + +namespace arm_compute +{ +GCMemory::GCMemory() + : _region(nullptr), _region_owned(nullptr) +{ +} + +GCMemory::GCMemory(std::shared_ptr memory) + : _region(nullptr), _region_owned(std::move(memory)) +{ + _region_owned = memory; + _region = _region_owned.get(); +} + +GCMemory::GCMemory(IGCMemoryRegion *memory) + : _region(memory), _region_owned(nullptr) +{ + _region = memory; +} + +IGCMemoryRegion *GCMemory::gc_region() +{ + return _region; +} + +IGCMemoryRegion *GCMemory::gc_region() const +{ + return _region; +} + +IMemoryRegion *GCMemory::region() +{ + return _region; +} + +IMemoryRegion *GCMemory::region() const +{ + return _region; +} + +void GCMemory::set_region(IMemoryRegion *region) +{ + auto gc_region = utils::cast::polymorphic_downcast(region); + _region_owned = nullptr; + _region = gc_region; +} + +void GCMemory::set_owned_region(std::unique_ptr region) +{ + _region_owned = utils::cast::polymorphic_downcast_unique_ptr(std::move(region)); + _region = _region_owned.get(); +} +} // namespace arm_compute diff --git a/src/runtime/GLES_COMPUTE/GCMemoryRegion.cpp b/src/runtime/GLES_COMPUTE/GCMemoryRegion.cpp new file mode 100644 index 0000000000..45fd6e8944 --- /dev/null +++ b/src/runtime/GLES_COMPUTE/GCMemoryRegion.cpp @@ -0,0 +1,96 @@ +/* + * Copyright (c) 2018 ARM Limited. + * + * SPDX-License-Identifier: MIT + * + * 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 "arm_compute/runtime/GLES_COMPUTE/GCMemoryRegion.h" + +#include "arm_compute/core/Error.h" + +namespace arm_compute +{ +IGCMemoryRegion::IGCMemoryRegion(size_t size) + : IMemoryRegion(size), _mapping(nullptr), _ssbo_name(0) +{ +} + +const GLuint &IGCMemoryRegion::gc_ssbo_name() const +{ + return _ssbo_name; +} + +void *IGCMemoryRegion::buffer() +{ + return _mapping; +} + +void *IGCMemoryRegion::buffer() const +{ + return _mapping; +} + +GCBufferMemoryRegion::GCBufferMemoryRegion(size_t size) + : IGCMemoryRegion(size) +{ + ARM_COMPUTE_GL_CHECK(glGenBuffers(1, &_ssbo_name)); + ARM_COMPUTE_GL_CHECK(glBindBuffer(GL_SHADER_STORAGE_BUFFER, _ssbo_name)); + ARM_COMPUTE_GL_CHECK(glBufferData(GL_SHADER_STORAGE_BUFFER, static_cast(size), nullptr, GL_STATIC_DRAW)); + ARM_COMPUTE_GL_CHECK(glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0)); +} + +GCBufferMemoryRegion::~GCBufferMemoryRegion() +{ + ARM_COMPUTE_GL_CHECK(glDeleteBuffers(1, &_ssbo_name)); +} + +void *GCBufferMemoryRegion::ptr() +{ + return nullptr; +} + +void *GCBufferMemoryRegion::map(bool blocking) +{ + ARM_COMPUTE_ERROR_ON(_mapping != nullptr); + ARM_COMPUTE_UNUSED(blocking); + + ARM_COMPUTE_GL_CHECK(glBindBuffer(GL_SHADER_STORAGE_BUFFER, _ssbo_name)); + void *p = ARM_COMPUTE_GL_CHECK(glMapBufferRange(GL_SHADER_STORAGE_BUFFER, 0, static_cast(size()), GL_MAP_READ_BIT | GL_MAP_WRITE_BIT)); + _mapping = reinterpret_cast(p); + + return _mapping; +} + +void GCBufferMemoryRegion::unmap() +{ + ARM_COMPUTE_ERROR_ON(_mapping == nullptr); + + ARM_COMPUTE_GL_CHECK(glBindBuffer(GL_SHADER_STORAGE_BUFFER, _ssbo_name)); + ARM_COMPUTE_GL_CHECK(glUnmapBuffer(GL_SHADER_STORAGE_BUFFER)); + ARM_COMPUTE_GL_CHECK(glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0)); + _mapping = nullptr; +} + +std::unique_ptr GCBufferMemoryRegion::extract_subregion(size_t offset, size_t size) +{ + ARM_COMPUTE_UNUSED(offset, size); + return nullptr; +} +} // namespace arm_compute \ No newline at end of file diff --git a/src/runtime/GLES_COMPUTE/GCTensorAllocator.cpp b/src/runtime/GLES_COMPUTE/GCTensorAllocator.cpp index abd2b483d3..a0dd540a7c 100644 --- a/src/runtime/GLES_COMPUTE/GCTensorAllocator.cpp +++ b/src/runtime/GLES_COMPUTE/GCTensorAllocator.cpp @@ -26,21 +26,17 @@ #include "arm_compute/core/Error.h" #include "arm_compute/core/TensorInfo.h" +#include "arm_compute/runtime/GLES_COMPUTE/GCMemoryRegion.h" #include "arm_compute/runtime/GLES_COMPUTE/GCScheduler.h" #include "support/ToolchainSupport.h" using namespace arm_compute; GCTensorAllocator::GCTensorAllocator(GCTensor *owner) - : _associated_memory_group(nullptr), _gl_buffer(), _mapping(nullptr), _owner(owner) + : _associated_memory_group(nullptr), _memory(), _mapping(nullptr), _owner(owner) { } -GCTensorAllocator::~GCTensorAllocator() -{ - _gl_buffer = support::cpp14::make_unique(); -} - uint8_t *GCTensorAllocator::data() { return _mapping; @@ -50,32 +46,28 @@ void GCTensorAllocator::allocate() { if(_associated_memory_group == nullptr) { - _gl_buffer = support::cpp14::make_unique(); - ARM_COMPUTE_GL_CHECK(glBindBuffer(GL_SHADER_STORAGE_BUFFER, _gl_buffer->_ssbo_name)); - ARM_COMPUTE_GL_CHECK(glBufferData(GL_SHADER_STORAGE_BUFFER, static_cast(info().total_size()), nullptr, GL_STATIC_DRAW)); - ARM_COMPUTE_GL_CHECK(glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0)); + _memory.set_owned_region(support::cpp14::make_unique(info().total_size())); } else { - _associated_memory_group->finalize_memory(_owner, reinterpret_cast(&_gl_buffer), info().total_size()); + _associated_memory_group->finalize_memory(_owner, _memory, info().total_size()); } info().set_is_resizable(false); } void GCTensorAllocator::free() { - if(_associated_memory_group == nullptr) - { - _gl_buffer.reset(); - info().set_is_resizable(true); - } + _mapping = nullptr; + _memory.set_region(nullptr); + info().set_is_resizable(true); } void GCTensorAllocator::set_associated_memory_group(GCMemoryGroup *associated_memory_group) { ARM_COMPUTE_ERROR_ON(associated_memory_group == nullptr); ARM_COMPUTE_ERROR_ON(_associated_memory_group != nullptr); - ARM_COMPUTE_ERROR_ON(_gl_buffer.get() != nullptr); + ARM_COMPUTE_ERROR_ON(_memory.region() != nullptr && _memory.gc_region()->gc_ssbo_name() != 0); + _associated_memory_group = associated_memory_group; } @@ -91,27 +83,23 @@ void GCTensorAllocator::unlock() GLuint GCTensorAllocator::get_gl_ssbo_name() const { - return _gl_buffer->_ssbo_name; + return (_memory.region() == nullptr) ? static_cast(0) : _memory.gc_region()->gc_ssbo_name(); } uint8_t *GCTensorAllocator::map(bool blocking) { ARM_COMPUTE_ERROR_ON(_mapping != nullptr); - ARM_COMPUTE_UNUSED(blocking); - - ARM_COMPUTE_GL_CHECK(glBindBuffer(GL_SHADER_STORAGE_BUFFER, _gl_buffer->_ssbo_name)); - void *p = ARM_COMPUTE_GL_CHECK(glMapBufferRange(GL_SHADER_STORAGE_BUFFER, 0, static_cast(info().total_size()), GL_MAP_READ_BIT | GL_MAP_WRITE_BIT)); - _mapping = reinterpret_cast(p); + ARM_COMPUTE_ERROR_ON(_memory.region() == nullptr); + _mapping = reinterpret_cast(_memory.gc_region()->map(blocking)); return _mapping; } void GCTensorAllocator::unmap() { ARM_COMPUTE_ERROR_ON(_mapping == nullptr); + ARM_COMPUTE_ERROR_ON(_memory.region() == nullptr); - ARM_COMPUTE_GL_CHECK(glBindBuffer(GL_SHADER_STORAGE_BUFFER, _gl_buffer->_ssbo_name)); - ARM_COMPUTE_GL_CHECK(glUnmapBuffer(GL_SHADER_STORAGE_BUFFER)); - ARM_COMPUTE_GL_CHECK(glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0)); + _memory.gc_region()->unmap(); _mapping = nullptr; } \ No newline at end of file -- cgit v1.2.1