diff options
Diffstat (limited to 'arm_compute/runtime')
| -rw-r--r-- | arm_compute/runtime/CL/CLBufferAllocator.h | 20 | ||||
| -rw-r--r-- | arm_compute/runtime/CL/CLHelpers.h | 10 | ||||
| -rw-r--r-- | arm_compute/runtime/CL/CLMemoryRegion.h | 33 | ||||
| -rw-r--r-- | arm_compute/runtime/CL/CLRuntimeContext.h | 70 | ||||
| -rw-r--r-- | arm_compute/runtime/CL/CLScheduler.h | 74 | ||||
| -rw-r--r-- | arm_compute/runtime/CL/CLTensor.h | 27 | ||||
| -rw-r--r-- | arm_compute/runtime/CL/CLTensorAllocator.h | 6 | ||||
| -rw-r--r-- | arm_compute/runtime/CL/ICLSimpleFunction.h | 20 | ||||
| -rw-r--r-- | arm_compute/runtime/CL/functions/CLActivationLayer.h | 2 | ||||
| -rw-r--r-- | arm_compute/runtime/GLES_COMPUTE/GCTensor.h | 9 | ||||
| -rw-r--r-- | arm_compute/runtime/Tensor.h | 10 |
11 files changed, 188 insertions, 93 deletions
diff --git a/arm_compute/runtime/CL/CLBufferAllocator.h b/arm_compute/runtime/CL/CLBufferAllocator.h index 19a3e627ca..772402270b 100644 --- a/arm_compute/runtime/CL/CLBufferAllocator.h +++ b/arm_compute/runtime/CL/CLBufferAllocator.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017-2018 ARM Limited. + * Copyright (c) 2017-2019 ARM Limited. * * SPDX-License-Identifier: MIT * @@ -26,19 +26,25 @@ #include "arm_compute/runtime/IAllocator.h" -#include "arm_compute/core/CL/OpenCL.h" -#include "arm_compute/runtime/CL/CLScheduler.h" - #include <cstddef> namespace arm_compute { +class CLCoreRuntimeContext; /** Default OpenCL cl buffer allocator implementation */ class CLBufferAllocator final : public IAllocator { public: - /** Default constructor */ - explicit CLBufferAllocator(cl::Context context = CLScheduler::get().context()); + /** Default constructor + * + * @param[in] ctx A runtime context. + */ + CLBufferAllocator(CLCoreRuntimeContext *ctx = nullptr); + + /** Default copy constructor */ + CLBufferAllocator(const CLBufferAllocator &) = default; + /** Default copy assignment operator */ + CLBufferAllocator &operator=(const CLBufferAllocator &) = default; // Inherited methods overridden: void *allocate(size_t size, size_t alignment) override; @@ -46,7 +52,7 @@ public: std::unique_ptr<IMemoryRegion> make_region(size_t size, size_t alignment) override; private: - cl::Context _context; + CLCoreRuntimeContext *_ctx; }; } // arm_compute #endif /*__ARM_COMPUTE_CLBUFFERALLOCATOR_H__ */ diff --git a/arm_compute/runtime/CL/CLHelpers.h b/arm_compute/runtime/CL/CLHelpers.h index f3b11f8b75..84f155afd2 100644 --- a/arm_compute/runtime/CL/CLHelpers.h +++ b/arm_compute/runtime/CL/CLHelpers.h @@ -25,9 +25,12 @@ #define __ARM_COMPUTE_CL_HELPERS_H__ #include "arm_compute/core/CL/OpenCL.h" +#include "arm_compute/runtime/IScheduler.h" namespace arm_compute { +class CLRuntimeContext; +class ICLKernel; /** This function creates an OpenCL context and a device. * * @note In debug builds, the function will automatically enable cl_arm_printf if the driver/device supports it. @@ -37,5 +40,12 @@ namespace arm_compute * a value telling why the function failed. */ std::tuple<cl::Context, cl::Device, cl_int> create_opencl_context_and_device(); +/** Schedules a kernel using the context if not nullptr else uses the legacy scheduling flow. + * + * @param[in] ctx Context to use. + * @param[in] kernel Kernel to schedule. + * @param[in] flush (Optional) Specifies if the command queue will be flushed after running the kernel. + */ +void schedule_kernel_on_ctx(CLRuntimeContext *ctx, ICLKernel *kernel, bool flush = true); } // namespace arm_compute #endif /* __ARM_COMPUTE_CL_HELPERS_H__ */ diff --git a/arm_compute/runtime/CL/CLMemoryRegion.h b/arm_compute/runtime/CL/CLMemoryRegion.h index dbfd8225ca..6f7c3cd9a8 100644 --- a/arm_compute/runtime/CL/CLMemoryRegion.h +++ b/arm_compute/runtime/CL/CLMemoryRegion.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2018 ARM Limited. + * Copyright (c) 2018-2019 ARM Limited. * * SPDX-License-Identifier: MIT * @@ -31,16 +31,17 @@ namespace arm_compute { +class CLCoreRuntimeContext; /** OpenCL memory region interface */ class ICLMemoryRegion : public IMemoryRegion { public: /** Constructor * - * @param[in] ctx OpenCL context + * @param[in] ctx Runtime context * @param[in] size Region size */ - ICLMemoryRegion(cl::Context ctx, size_t size); + ICLMemoryRegion(CLCoreRuntimeContext *ctx, size_t size); /** Default Destructor */ virtual ~ICLMemoryRegion() = default; /** Prevent instances of this class from being copied (As this class contains pointers) */ @@ -86,9 +87,10 @@ public: std::unique_ptr<IMemoryRegion> extract_subregion(size_t offset, size_t size) override; protected: - cl::Context _ctx; - void *_mapping; - cl::Buffer _mem; + cl::CommandQueue _queue; + cl::Context _ctx; + void *_mapping; + cl::Buffer _mem; }; /** OpenCL buffer memory region implementation */ @@ -97,16 +99,17 @@ class CLBufferMemoryRegion final : public ICLMemoryRegion public: /** Constructor * - * @param[in] ctx OpenCL context + * @param[in] ctx Runtime context * @param[in] flags Memory flags * @param[in] size Region size */ - CLBufferMemoryRegion(cl::Context ctx, cl_mem_flags flags, size_t size); + CLBufferMemoryRegion(CLCoreRuntimeContext *ctx, cl_mem_flags flags, size_t size); /** Constructor * * @param[in] buffer Buffer to be used as a memory region + * @param[in] ctx Runtime context */ - CLBufferMemoryRegion(const cl::Buffer &buffer); + CLBufferMemoryRegion(const cl::Buffer &buffer, CLCoreRuntimeContext *ctx); // Inherited methods overridden : void *ptr() final; @@ -120,12 +123,12 @@ class ICLSVMMemoryRegion : public ICLMemoryRegion protected: /** Constructor * - * @param[in] ctx OpenCL context + * @param[in] ctx Runtime context * @param[in] flags Memory flags * @param[in] size Region size * @param[in] alignment Alignment */ - ICLSVMMemoryRegion(cl::Context ctx, cl_mem_flags flags, size_t size, size_t alignment); + ICLSVMMemoryRegion(CLCoreRuntimeContext *ctx, cl_mem_flags flags, size_t size, size_t alignment); /** Destructor */ virtual ~ICLSVMMemoryRegion(); /** Prevent instances of this class from being copied (As this class contains pointers) */ @@ -150,12 +153,12 @@ class CLCoarseSVMMemoryRegion final : public ICLSVMMemoryRegion public: /** Constructor * - * @param[in] ctx OpenCL context + * @param[in] ctx Runtime context * @param[in] flags Memory flags * @param[in] size Region size * @param[in] alignment Alignment */ - CLCoarseSVMMemoryRegion(cl::Context ctx, cl_mem_flags flags, size_t size, size_t alignment); + CLCoarseSVMMemoryRegion(CLCoreRuntimeContext *ctx, cl_mem_flags flags, size_t size, size_t alignment); // Inherited methods overridden : void *map(cl::CommandQueue &q, bool blocking) final; @@ -168,12 +171,12 @@ class CLFineSVMMemoryRegion final : public ICLSVMMemoryRegion public: /** Constructor * - * @param[in] ctx OpenCL context + * @param[in] ctx Runtime context * @param[in] flags Memory flags * @param[in] size Region size * @param[in] alignment Alignment */ - CLFineSVMMemoryRegion(cl::Context ctx, cl_mem_flags flags, size_t size, size_t alignment); + CLFineSVMMemoryRegion(CLCoreRuntimeContext *ctx, cl_mem_flags flags, size_t size, size_t alignment); // Inherited methods overridden : void *map(cl::CommandQueue &q, bool blocking) final; diff --git a/arm_compute/runtime/CL/CLRuntimeContext.h b/arm_compute/runtime/CL/CLRuntimeContext.h new file mode 100644 index 0000000000..971dfd2224 --- /dev/null +++ b/arm_compute/runtime/CL/CLRuntimeContext.h @@ -0,0 +1,70 @@ +/* + * Copyright (c) 2019 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. + */ +#ifndef __ARM_COMPUTE_CLRUNTIME_CONTEXT_H__ +#define __ARM_COMPUTE_CLRUNTIME_CONTEXT_H__ + +#include "arm_compute/core/CL/CLCoreRuntimeContext.h" +#include "arm_compute/core/CL/CLKernelLibrary.h" +#include "arm_compute/core/CL/OpenCL.h" +#include "arm_compute/runtime/CL/CLScheduler.h" +#include "arm_compute/runtime/CL/CLTuner.h" +#include "arm_compute/runtime/IScheduler.h" +#include "arm_compute/runtime/RuntimeContext.h" + +namespace arm_compute +{ +/** Runtime context */ +class CLRuntimeContext : public RuntimeContext +{ +public: + /** Default Constructor */ + CLRuntimeContext(); + /** Destructor */ + ~CLRuntimeContext() = default; + /** Prevent instances of this class from being copied (As this class contains pointers) */ + CLRuntimeContext(const CLRuntimeContext &) = delete; + /** Default move constructor */ + CLRuntimeContext(CLRuntimeContext &&) = default; + /** Prevent instances of this class from being copied (As this class contains pointers) */ + CLRuntimeContext &operator=(const CLRuntimeContext &) = delete; + /** Default move assignment operator */ + CLRuntimeContext &operator=(CLRuntimeContext &&) = default; + /** CPU Scheduler setter */ + void set_gpu_scheduler(CLScheduler *scheduler); + + // Inherited overridden methods + CLScheduler *gpu_scheduler(); + CLKernelLibrary &kernel_library(); + CLCoreRuntimeContext *core_runtime_context(); + +private: + std::unique_ptr<CLScheduler> _gpu_owned_scheduler{ nullptr }; + CLScheduler *_gpu_scheduler{ nullptr }; + CLTuner _tuner{ false }; + CLKernelLibrary _kernel_lib{}; + CLSymbols _symbols{}; + CLCoreRuntimeContext _core_context{}; +}; +} // namespace arm_compute +#endif /*__ARM_COMPUTE_CLRUNTIME_CONTEXT_H__ */ diff --git a/arm_compute/runtime/CL/CLScheduler.h b/arm_compute/runtime/CL/CLScheduler.h index 53cb88ad5b..720c8b37f5 100644 --- a/arm_compute/runtime/CL/CLScheduler.h +++ b/arm_compute/runtime/CL/CLScheduler.h @@ -25,7 +25,6 @@ #define __ARM_COMPUTE_CLSCHEDULER_H__ #include "arm_compute/core/CL/CLHelpers.h" -#include "arm_compute/core/CL/CLKernelLibrary.h" #include "arm_compute/core/CL/CLTypes.h" #include "arm_compute/core/CL/OpenCL.h" #include "arm_compute/core/Error.h" @@ -35,21 +34,21 @@ namespace arm_compute { class ICLKernel; - +class ICLTuner; /** Provides global access to a CL context and command queue. */ -class CLScheduler +class CLScheduler final { -private: +public: /** Constructor */ CLScheduler(); /** Prevent instances of this class from being copied (As this class contains pointers) */ CLScheduler(const CLScheduler &) = delete; /** Prevent instances of this class from being copied (As this class contains pointers) */ CLScheduler &operator=(const CLScheduler &) = delete; - -public: + /** Default destructor */ + ~CLScheduler() = default; /** Access the scheduler singleton. - * + * This method has been deprecated and will be removed in future releases * @return The scheduler */ static CLScheduler &get(); @@ -88,31 +87,19 @@ public: * * @return A CL context. */ - cl::Context &context() - { - ARM_COMPUTE_ERROR_ON(!_is_initialised); - _context = CLKernelLibrary::get().context(); - return _context; - } + cl::Context &context(); /** Accessor for the associated CL command queue. * * @return A CL command queue. */ - cl::CommandQueue &queue() - { - ARM_COMPUTE_ERROR_ON(!_is_initialised); - return _queue; - } + cl::CommandQueue &queue(); /** Get the target GPU. * * @return The target GPU. */ - GPUTarget target() const - { - return _target; - } + GPUTarget target() const; /** Accessor to set the CL context to be used by the scheduler. * @@ -124,63 +111,36 @@ public: * * @param[in] queue A CL command queue. */ - void set_queue(cl::CommandQueue queue) - { - _queue = std::move(queue); - } + void set_queue(cl::CommandQueue queue); /** Accessor to set target GPU to be used by the scheduler. * * @param[in] target The target GPU. */ - void set_target(GPUTarget target) - { - _target = target; - } + void set_target(GPUTarget target); /** Accessor to set the CL tuner to be used by the scheduler. * * @param[in] tuner A CL tuner */ - void set_tuner(ICLTuner *tuner) - { - _cl_tuner = tuner; - } + void set_tuner(ICLTuner *tuner); /** Blocks until all commands in the associated command queue have finished. */ - void sync() - { - _queue.finish(); - } + void sync(); /** Enqueues a marker into the associated command queue and return the event. * * @return An event that can be waited on to block the executing thread. */ - cl::Event enqueue_sync_event() - { - cl::Event event; - _queue.enqueueMarker(&event); - - return event; - } + cl::Event enqueue_sync_event(); /** Tunes OpenCL kernel * * @param[in] kernel Kernel to tune */ - void tune_kernel_static(ICLKernel &kernel) - { - if(_cl_tuner != nullptr) - { - _cl_tuner->tune_kernel_static(kernel); - } - } - - bool is_initialised() const - { - return _is_initialised; - } + void tune_kernel_static(ICLKernel &kernel); + + bool is_initialised() const; private: /** Flag to ensure symbols initialisation is happening before Scheduler creation */ diff --git a/arm_compute/runtime/CL/CLTensor.h b/arm_compute/runtime/CL/CLTensor.h index bc72839492..c108d1afad 100644 --- a/arm_compute/runtime/CL/CLTensor.h +++ b/arm_compute/runtime/CL/CLTensor.h @@ -35,13 +35,32 @@ namespace arm_compute // Forward declarations class ITensorAllocator; class ITensorInfo; - +class IRuntimeContext; +class CLRuntimeContext; /** Basic implementation of the OpenCL tensor interface */ class CLTensor : public ICLTensor, public IMemoryManageable { public: - /** Constructor */ - CLTensor(); + /** Constructor. + * + * @param[in] ctx (Optional) Pointer to a @ref CLRuntimeContext. + * If nullptr is passed in, the legacy api using the singletons will be used. Otherwise the memory for the + * tensor will allocate on the context passed in. + * The singletons legacy api has been deprecated and will be removed. + */ + CLTensor(IRuntimeContext *ctx = nullptr); + + /** Destructor */ + ~CLTensor() = default; + /** Default copy constructor */ + CLTensor(const CLTensor &) = default; + /** Default move constructor */ + CLTensor(CLTensor &&) = default; + /** Default copy assignment */ + CLTensor &operator=(const CLTensor &) = default; + /** Default move assignment operator */ + CLTensor &operator=(CLTensor &&) = default; + /** Return a pointer to the tensor's allocator * * @return A pointer to the tensor's allocator @@ -69,6 +88,7 @@ public: const cl::Buffer &cl_buffer() const override; CLQuantization quantization() const override; void associate_memory_group(IMemoryGroup *memory_group) override; + CLRuntimeContext *context(); protected: // Inherited methods overridden: @@ -77,6 +97,7 @@ protected: private: mutable CLTensorAllocator _allocator; /**< Instance of the OpenCL tensor allocator */ + CLRuntimeContext *_ctx{ nullptr }; }; /** OpenCL Image */ diff --git a/arm_compute/runtime/CL/CLTensorAllocator.h b/arm_compute/runtime/CL/CLTensorAllocator.h index 3450c72d61..b3ffd8b949 100644 --- a/arm_compute/runtime/CL/CLTensorAllocator.h +++ b/arm_compute/runtime/CL/CLTensorAllocator.h @@ -37,7 +37,7 @@ namespace arm_compute { class CLTensor; - +class CLRuntimeContext; /** Basic implementation of a CL memory tensor allocator. */ class CLTensorAllocator : public ITensorAllocator { @@ -45,8 +45,9 @@ public: /** Default constructor. * * @param[in] owner (Optional) Owner of the allocator. + * @param[in] ctx (Optional) Runtime context. */ - CLTensorAllocator(IMemoryManageable *owner = nullptr); + CLTensorAllocator(IMemoryManageable *owner = nullptr, CLRuntimeContext *ctx = nullptr); /** Prevent instances of this class from being copied (As this class contains pointers) */ CLTensorAllocator(const CLTensorAllocator &) = delete; /** Prevent instances of this class from being copy assigned (As this class contains pointers) */ @@ -139,6 +140,7 @@ private: static const cl::Buffer _empty_buffer; private: + CLRuntimeContext *_ctx; IMemoryManageable *_owner; /**< Memory manageable object that owns the allocator */ IMemoryGroup *_associated_memory_group; /**< Registered memory manager */ CLMemory _memory; /**< OpenCL memory */ diff --git a/arm_compute/runtime/CL/ICLSimpleFunction.h b/arm_compute/runtime/CL/ICLSimpleFunction.h index 130c58a98c..8399a3d58e 100644 --- a/arm_compute/runtime/CL/ICLSimpleFunction.h +++ b/arm_compute/runtime/CL/ICLSimpleFunction.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016, 2017 ARM Limited. + * Copyright (c) 2016-2019 ARM Limited. * * SPDX-License-Identifier: MIT * @@ -32,12 +32,25 @@ namespace arm_compute { +class CLRuntimeContext; /** Basic interface for functions which have a single OpenCL kernel */ class ICLSimpleFunction : public IFunction { public: - /** Default constructor */ - ICLSimpleFunction(); + /** Constructor + * + * @param[in] ctx Runtime context to be used by the function + */ + ICLSimpleFunction(CLRuntimeContext *ctx = nullptr); + + /** Prevent instances of this class from being copied (As this class contains pointers) */ + ICLSimpleFunction(const ICLSimpleFunction &) = delete; + /** Default move constructor */ + ICLSimpleFunction(ICLSimpleFunction &&) = default; + /** Prevent instances of this class from being copied (As this class contains pointers) */ + ICLSimpleFunction &operator=(const ICLSimpleFunction &) = delete; + /** Default move assignment operator */ + ICLSimpleFunction &operator=(ICLSimpleFunction &&) = default; // Inherited methods overridden: void run() override final; @@ -45,6 +58,7 @@ public: protected: std::unique_ptr<ICLKernel> _kernel; /**< Kernel to run */ CLFillBorderKernel _border_handler; /**< Kernel to handle borders */ + CLRuntimeContext *_ctx; /**< Context to use */ }; } #endif /*__ARM_COMPUTE_ICLSIMPLEFUNCTION_H__ */ diff --git a/arm_compute/runtime/CL/functions/CLActivationLayer.h b/arm_compute/runtime/CL/functions/CLActivationLayer.h index 1201d7d355..e1e3e877d5 100644 --- a/arm_compute/runtime/CL/functions/CLActivationLayer.h +++ b/arm_compute/runtime/CL/functions/CLActivationLayer.h @@ -43,7 +43,7 @@ public: * * @param[in] ctx Runtime context to be used by the function */ - CLActivationLayer(void *ctx = nullptr); + CLActivationLayer(CLRuntimeContext *ctx = nullptr); /** Prevent instances of this class from being copied (As this class contains pointers) */ CLActivationLayer(const CLActivationLayer &) = delete; /** Default move constructor */ diff --git a/arm_compute/runtime/GLES_COMPUTE/GCTensor.h b/arm_compute/runtime/GLES_COMPUTE/GCTensor.h index 344c78852b..a308ba0237 100644 --- a/arm_compute/runtime/GLES_COMPUTE/GCTensor.h +++ b/arm_compute/runtime/GLES_COMPUTE/GCTensor.h @@ -32,13 +32,18 @@ namespace arm_compute { class ITensorAllocator; class ITensorInfo; +class IRuntimeContext; /** Interface for OpenGL ES tensor */ class GCTensor : public IGCTensor, public IMemoryManageable { public: - /** Default constructor */ - GCTensor(); + /** Default constructor + * + * @param[in] ctx (Optional) Pointer to the runtime context. + * + */ + GCTensor(IRuntimeContext *ctx = nullptr); /** Prevent instances of this class from being copied (As this class contains pointers) */ GCTensor(const GCTensor &) = delete; diff --git a/arm_compute/runtime/Tensor.h b/arm_compute/runtime/Tensor.h index 6fa7c8ca0e..e469f70817 100644 --- a/arm_compute/runtime/Tensor.h +++ b/arm_compute/runtime/Tensor.h @@ -32,13 +32,17 @@ namespace arm_compute { class ITensorInfo; - +class IRuntimeContext; /** Basic implementation of the tensor interface */ class Tensor : public ITensor, public IMemoryManageable { public: - /** Constructor */ - Tensor(); + /** Constructor + * + * @param[in] ctx (Optional) Pointer to the runtime context. + * + */ + Tensor(IRuntimeContext *ctx = nullptr); /** Destructor: free the tensor's memory */ ~Tensor() = default; /** Allow instances of this class to be move constructed */ |