From c3c352e60050f3deacad767e429a88dc24b31af0 Mon Sep 17 00:00:00 2001 From: Georgios Pinitas Date: Thu, 18 Mar 2021 10:59:40 +0000 Subject: Add Queue support Queues are responsible for scheduling operators and performing other runtime related activities like for example tuning. Signed-off-by: Georgios Pinitas Change-Id: I0366d9048470d277b8cbf59fa42f95c0ae57c5c9 Reviewed-on: https://review.mlplatform.org/c/ml/ComputeLibrary/+/5487 Tested-by: Arm Jenkins Reviewed-by: Michele Di Giorgio Reviewed-by: Michalis Spyrou Comments-Addressed: Arm Jenkins --- src/gpu/cl/ClContext.cpp | 23 +++++++++-- src/gpu/cl/ClContext.h | 12 +++++- src/gpu/cl/ClQueue.cpp | 102 +++++++++++++++++++++++++++++++++++++++++++++++ src/gpu/cl/ClQueue.h | 84 ++++++++++++++++++++++++++++++++++++++ 4 files changed, 217 insertions(+), 4 deletions(-) create mode 100644 src/gpu/cl/ClQueue.cpp create mode 100644 src/gpu/cl/ClQueue.h (limited to 'src/gpu') diff --git a/src/gpu/cl/ClContext.cpp b/src/gpu/cl/ClContext.cpp index 2e04e1d593..d8ef18e62e 100644 --- a/src/gpu/cl/ClContext.cpp +++ b/src/gpu/cl/ClContext.cpp @@ -23,8 +23,11 @@ */ #include "src/gpu/cl/ClContext.h" +#include "src/gpu/cl/ClQueue.h" #include "src/gpu/cl/ClTensor.h" +#include "arm_compute/core/CL/CLKernelLibrary.h" + namespace arm_compute { namespace gpu @@ -49,12 +52,15 @@ mlgo::MLGOHeuristics populate_mlgo(const char *filename) ClContext::ClContext(const AclContextOptions *options) : IContext(Target::GpuOcl), _mlgo_heuristics(), - _cl_context() + _cl_ctx(), + _cl_dev() { if(options != nullptr) { _mlgo_heuristics = populate_mlgo(options->kernel_config_file); } + _cl_ctx = CLKernelLibrary::get().context(); + _cl_dev = CLKernelLibrary::get().get_device(); } const mlgo::MLGOHeuristics &ClContext::mlgo() const @@ -64,14 +70,20 @@ const mlgo::MLGOHeuristics &ClContext::mlgo() const ::cl::Context ClContext::cl_ctx() { - return _cl_context; + return _cl_ctx; +} + +::cl::Device ClContext::cl_dev() +{ + return _cl_dev; } bool ClContext::set_cl_ctx(::cl::Context ctx) { if(this->refcount() == 0) { - _cl_context = ctx; + _cl_ctx = ctx; + CLScheduler::get().set_context(ctx); return true; } return false; @@ -86,6 +98,11 @@ ITensorV2 *ClContext::create_tensor(const AclTensorDescriptor &desc, bool alloca } return tensor; } + +IQueue *ClContext::create_queue(const AclQueueOptions *options) +{ + return new ClQueue(this, options); +} } // namespace opencl } // namespace gpu } // namespace arm_compute diff --git a/src/gpu/cl/ClContext.h b/src/gpu/cl/ClContext.h index dd6699a0c9..2a0d4ee1c8 100644 --- a/src/gpu/cl/ClContext.h +++ b/src/gpu/cl/ClContext.h @@ -44,6 +44,7 @@ public: * @param[in] options Creational options */ explicit ClContext(const AclContextOptions *options); + /** Extract MLGO heuristics * * @return Heuristics tree @@ -55,6 +56,13 @@ public: * @return the cl context used */ ::cl::Context cl_ctx(); + + /** Underlying cl device accessor + * + * @return the cl device used + */ + ::cl::Device cl_dev(); + /** Update/inject an underlying cl context object * * @warning Context will be able to set if the object doesn't have any pending reference to other objects @@ -67,10 +75,12 @@ public: // Inherrited methods overridden ITensorV2 *create_tensor(const AclTensorDescriptor &desc, bool allocate) override; + IQueue *create_queue(const AclQueueOptions *options) override; private: mlgo::MLGOHeuristics _mlgo_heuristics; - ::cl::Context _cl_context; + ::cl::Context _cl_ctx; + ::cl::Device _cl_dev; }; } // namespace opencl } // namespace gpu diff --git a/src/gpu/cl/ClQueue.cpp b/src/gpu/cl/ClQueue.cpp new file mode 100644 index 0000000000..2123adcf39 --- /dev/null +++ b/src/gpu/cl/ClQueue.cpp @@ -0,0 +1,102 @@ +/* + * Copyright (c) 2021 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 "src/gpu/cl/ClQueue.h" + +#include "arm_compute/runtime/CL/CLScheduler.h" +#include "arm_compute/runtime/CL/CLTuner.h" + +namespace arm_compute +{ +namespace gpu +{ +namespace opencl +{ +namespace +{ +CLTunerMode map_tuner_mode(AclTuningMode mode) +{ + switch(mode) + { + case AclRapid: + return CLTunerMode::RAPID; + break; + case AclNormal: + return CLTunerMode::NORMAL; + break; + case AclExhaustive: + return CLTunerMode::EXHAUSTIVE; + break; + default: + ARM_COMPUTE_ERROR("Invalid tuner mode"); + break; + } +} + +std::unique_ptr populate_tuner(const AclQueueOptions *options) +{ + if(options == nullptr || options->mode == AclTuningModeNone) + { + return nullptr; + } + + CLTuningInfo tune_info; + tune_info.tuner_mode = map_tuner_mode(options->mode); + tune_info.tune_wbsm = false; + + return std::make_unique(true /* tune_new_kernels */, tune_info); +} +} // namespace + +ClQueue::ClQueue(IContext *ctx, const AclQueueOptions *options) + : IQueue(ctx), _tuner(nullptr) +{ + _tuner = populate_tuner(options); +} + +arm_compute::CLScheduler &ClQueue::scheduler() +{ + return arm_compute::CLScheduler::get(); +} + +::cl::CommandQueue ClQueue::cl_queue() +{ + return arm_compute::CLScheduler::get().queue(); +} + +bool ClQueue::set_cl_queue(::cl::CommandQueue queue) +{ + // TODO: Check queue is from the same context + arm_compute::CLScheduler::get().set_queue(queue); + return true; +} + +StatusCode ClQueue::finish() +{ + arm_compute::CLScheduler::get().queue().finish(); + return StatusCode::Success; +} + +} // namespace opencl +} // namespace gpu +} // namespace arm_compute diff --git a/src/gpu/cl/ClQueue.h b/src/gpu/cl/ClQueue.h new file mode 100644 index 0000000000..b16a0f4e83 --- /dev/null +++ b/src/gpu/cl/ClQueue.h @@ -0,0 +1,84 @@ +/* + * Copyright (c) 2021 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 SRC_GPU_CLQUEUE_H +#define SRC_GPU_CLQUEUE_H + +#include "src/common/IQueue.h" + +#include "arm_compute/runtime/CL/CLScheduler.h" + +#include + +namespace arm_compute +{ +// Forward declarations +class CLTuner; + +namespace gpu +{ +namespace opencl +{ +/** OpenCL queue implementation class */ +class ClQueue final : public IQueue +{ +public: + /** Construct a new CpuQueue object + * + * @param[in] ctx Context to be used + * @param[in] options Command queue options + */ + ClQueue(IContext *ctx, const AclQueueOptions *options); + + /** Return legacy scheduler + * + * @return arm_compute::IScheduler& + */ + arm_compute::CLScheduler &scheduler(); + + /** Underlying cl command queue accessor + * + * @return the cl command queue used + */ + ::cl::CommandQueue cl_queue(); + + /** Update/inject an underlying cl command queue object + * + * @warning Command queue needs to come from the same context as the AclQueue + * + * @param[in] queue Underlying cl command queue to be used + * + * @return true if the queue was set successfully else falseS + */ + bool set_cl_queue(::cl::CommandQueue queue); + + // Inherited functions overridden + StatusCode finish() override; + +private: + std::unique_ptr _tuner; +}; +} // namespace opencl +} // namespace gpu +} // namespace arm_compute +#endif /* SRC_GPU_CLQUEUE_H */ -- cgit v1.2.1