From ff421f2100e0e9e532f5fe78585300546af61690 Mon Sep 17 00:00:00 2001 From: Georgios Pinitas Date: Wed, 4 Oct 2017 16:53:58 +0100 Subject: COMPMID-601: Add GraphContext GraphContext hold all the information about the hints that need to be passed in the nodes. As these might expand, it serves as a centralized class for such information. Change-Id: I0b5527630fb97cc5fa500db0bac8307ff2ea36e6 Reviewed-on: http://mpd-gerrit.cambridge.arm.com/90300 Tested-by: Kaizen Reviewed-by: Anthony Barbier --- arm_compute/graph/Graph.h | 30 +++++---- arm_compute/graph/GraphContext.h | 88 +++++++++++++++++++++++++++ arm_compute/graph/INode.h | 27 ++++---- arm_compute/graph/SubTensor.h | 6 +- arm_compute/graph/Tensor.h | 12 ++-- arm_compute/graph/Types.h | 2 +- arm_compute/graph/nodes/ActivationLayer.h | 5 +- arm_compute/graph/nodes/ConvolutionLayer.h | 3 +- arm_compute/graph/nodes/FullyConnectedLayer.h | 5 +- arm_compute/graph/nodes/NormalizationLayer.h | 3 +- arm_compute/graph/nodes/PoolingLayer.h | 5 +- arm_compute/graph/nodes/SoftmaxLayer.h | 3 +- examples/graph_alexnet.cpp | 5 +- examples/graph_lenet.cpp | 4 +- src/graph/Graph.cpp | 87 ++++++++++++++------------ src/graph/GraphContext.cpp | 66 ++++++++++++++++++++ src/graph/INode.cpp | 20 +++--- src/graph/SubTensor.cpp | 15 +++-- src/graph/Tensor.cpp | 19 +++--- src/graph/nodes/ActivationLayer.cpp | 28 ++++----- src/graph/nodes/ConvolutionLayer.cpp | 58 +++++++++--------- src/graph/nodes/FullyConnectedLayer.cpp | 32 +++++----- src/graph/nodes/NormalizationLayer.cpp | 28 ++++----- src/graph/nodes/PoolingLayer.cpp | 28 ++++----- src/graph/nodes/SoftmaxLayer.cpp | 28 ++++----- 25 files changed, 393 insertions(+), 214 deletions(-) create mode 100644 arm_compute/graph/GraphContext.h create mode 100644 src/graph/GraphContext.cpp diff --git a/arm_compute/graph/Graph.h b/arm_compute/graph/Graph.h index 3c263c2bdd..da41548119 100644 --- a/arm_compute/graph/Graph.h +++ b/arm_compute/graph/Graph.h @@ -65,25 +65,21 @@ public: * @param[in] tensor Tensor to add */ void add_tensor(std::unique_ptr tensor); - /** Sets an execution hint to the graph - * - * @note Hint is propagated to the following node and as per name - * its just a hint/preference to be considered by the graph executor - * - * @param[in] hint execution hint - */ - void set_hint(Hint hint); /** Manually sets the output of the current node * * @param[in] tmp Output info to set */ void set_temp(TensorInfo &&tmp); - /** Sets whether to enable information print out * * @param[in] is_enabled Set to true if need info printed out */ void set_info_enablement(bool is_enabled); + /** Returns the graph hints that are currently used + * + * @return Graph hints + */ + GraphHints &hints(); private: class Private; @@ -106,14 +102,22 @@ Graph &operator<<(Graph &graph, TensorInfo &&info); * @return Updated graph */ Graph &operator<<(Graph &graph, Tensor &&tensor); -/** Overloaded stream operator to provide an execution hint to the graph +/** Overloaded stream operator to provide a target hint to the graph + * + * @param[in, out] graph Graph to provide the hint to + * @param[in] target_hint Target hint to be considered + * + * @return Updated graph + */ +Graph &operator<<(Graph &graph, TargetHint target_hint); +/** Overloaded stream operator to provide a convolution method hint to the graph * - * @param[in, out] graph Graph to provide the hint to - * @param[in] hint Execution hint to be considered + * @param[in, out] graph Graph to provide the hint to + * @param[in] conv_method_hint Convolution method hint to be considered * * @return Updated graph */ -Graph &operator<<(Graph &graph, Hint hint); +Graph &operator<<(Graph &graph, ConvolutionMethodHint conv_method_hint); /** Overloaded stream operator to add a node to the graph * * @param[in, out] graph Graph to add the tensor diff --git a/arm_compute/graph/GraphContext.h b/arm_compute/graph/GraphContext.h new file mode 100644 index 0000000000..98bc8c02f8 --- /dev/null +++ b/arm_compute/graph/GraphContext.h @@ -0,0 +1,88 @@ +/* + * Copyright (c) 2017 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_GRAPH_CONTEXT_H__ +#define __ARM_COMPUTE_GRAPH_CONTEXT_H__ + +#include "arm_compute/graph/Types.h" + +namespace arm_compute +{ +namespace graph +{ +/** Hints that can be passed to the graph to expose parameterization */ +class GraphHints +{ +public: + /** Default Constructor */ + GraphHints(TargetHint target_hint = TargetHint::DONT_CARE, + ConvolutionMethodHint conv_method_hint = ConvolutionMethodHint::GEMM); + /** Sets target execution hint + * + * @param target_hint Target execution hint + */ + void set_target_hint(TargetHint target_hint); + /** Sets convolution method to use + * + * @param convolution_method Convolution method to use + */ + void set_convolution_method_hint(ConvolutionMethodHint convolution_method); + /** Returns target execution hint + * + * @return target execution hint + */ + TargetHint target_hint() const; + /** Returns convolution method hint + * + * @return convolution method hint + */ + ConvolutionMethodHint convolution_method_hint() const; + +private: + TargetHint _target_hint; /**< Target execution hint */ + ConvolutionMethodHint _convolution_method_hint; /**< Convolution method hint */ +}; + +/** Graph context */ +class GraphContext +{ +public: + /** Default Constuctor */ + GraphContext(); + /** Returns graph hints + * + * @return Graph hints + */ + GraphHints &hints(); + /** Returns graph hints + * + * @return Graph hints + */ + const GraphHints &hints() const; + +private: + GraphHints _hints; /**< Graph hints */ +}; +} // namespace graph +} // namespace arm_compute +#endif /* __ARM_COMPUTE_GRAPH_CONTEXT_H__ */ diff --git a/arm_compute/graph/INode.h b/arm_compute/graph/INode.h index 13b5d05f87..6ce9b1b986 100644 --- a/arm_compute/graph/INode.h +++ b/arm_compute/graph/INode.h @@ -24,6 +24,7 @@ #ifndef __ARM_COMPUTE_GRAPH_INODE_H__ #define __ARM_COMPUTE_GRAPH_INODE_H__ +#include "arm_compute/graph/GraphContext.h" #include "arm_compute/graph/Types.h" #include "arm_compute/runtime/IFunction.h" @@ -41,37 +42,37 @@ public: virtual ~INode() = default; /** Interface to be implemented that instantiates the node * - * @param[in] hint Hint to where the node should be executed + * @param[in] ctx Graph context to be used * @param[in] input Input tensor of the node * @param[in] output Output tensor of the node */ - virtual std::unique_ptr instantiate_node(Hint hint, ITensor *input, ITensor *output) = 0; - /** Override the existing hint + virtual std::unique_ptr instantiate_node(GraphContext &ctx, ITensor *input, ITensor *output) = 0; + /** Override the existing target hint * * @note If the input is DONT_CARE then the method has to pick a technology, * else it can accept the hint or override it (But not with DONT_CARE) * - * @param[in] hint Hint to be considered + * @param[in] target_hint Target hint to be considered * - * @return The updated hint + * @return The updated target hint */ - Hint override_hint(Hint hint) const; + TargetHint override_target_hint(TargetHint target_hint) const; virtual void print_info() = 0; protected: - /** Interface to be implement that override the hint + /** Interface to be implement that override the hints * - * @param[in] hint Hint to be considered + * @param[in] hints Hints to be considered * - * @return The updated hint + * @return The updated hints */ - virtual Hint node_override_hint(Hint hint) const; + virtual GraphHints node_override_hints(GraphHints hints) const; protected: - Hint _hint{ Hint::DONT_CARE }; - ITensor *_input{ nullptr }; - ITensor *_output{ nullptr }; + TargetHint _target_hint{ TargetHint::DONT_CARE }; + ITensor *_input{ nullptr }; + ITensor *_output{ nullptr }; }; } // namespace graph } // namespace arm_compute diff --git a/arm_compute/graph/SubTensor.h b/arm_compute/graph/SubTensor.h index a73b0d6b0e..ace93d20a3 100644 --- a/arm_compute/graph/SubTensor.h +++ b/arm_compute/graph/SubTensor.h @@ -55,7 +55,7 @@ public: * @param[in] coords Starting coordinates of the sub-tensor in the parent tensor * @param[in] target Execution target */ - SubTensor(ITensor *parent, TensorShape tensor_shape, Coordinates coords, Hint target); + SubTensor(ITensor *parent, TensorShape tensor_shape, Coordinates coords, TargetHint target); /** Prevent instances of this class from being copied (As this class contains pointers) */ SubTensor(const SubTensor &) = delete; /** Prevent instances of this class from being copied (As this class contains pointers) */ @@ -86,14 +86,14 @@ public: * * @return Target of the tensor */ - Hint target() const; + TargetHint target() const; private: /** Instantiates a sub-tensor */ void instantiate_subtensor(); private: - Hint _target; /**< Target that this tensor is pinned on */ + TargetHint _target; /**< Target that this tensor is pinned on */ Coordinates _coords; /**< SubTensor Coordinates */ SubTensorInfo _info; /**< SubTensor metadata */ ITensor *_parent; /**< Parent tensor */ diff --git a/arm_compute/graph/Tensor.h b/arm_compute/graph/Tensor.h index 0e823ffad0..9fdd56db6e 100644 --- a/arm_compute/graph/Tensor.h +++ b/arm_compute/graph/Tensor.h @@ -49,7 +49,7 @@ public: */ template Tensor(std::unique_ptr accessor) - : _target(Hint::DONT_CARE), _info(), _accessor(std::move(accessor)), _tensor(nullptr) + : _target(TargetHint::DONT_CARE), _info(), _accessor(std::move(accessor)), _tensor(nullptr) { } /** Constructor @@ -58,7 +58,7 @@ public: */ template Tensor(AccessorType &&accessor) - : _target(Hint::DONT_CARE), _info(), _accessor(arm_compute::support::cpp14::make_unique(std::forward(accessor))), _tensor(nullptr) + : _target(TargetHint::DONT_CARE), _info(), _accessor(arm_compute::support::cpp14::make_unique(std::forward(accessor))), _tensor(nullptr) { } /** Constructor @@ -68,7 +68,7 @@ public: */ template Tensor(TensorInfo &&info, AccessorType &&accessor) - : _target(Hint::DONT_CARE), _info(info), _accessor(arm_compute::support::cpp14::make_unique(std::forward(accessor))), _tensor(nullptr) + : _target(TargetHint::DONT_CARE), _info(info), _accessor(arm_compute::support::cpp14::make_unique(std::forward(accessor))), _tensor(nullptr) { } /** Default Destructor */ @@ -95,7 +95,7 @@ public: * * @return */ - ITensor *set_target(Hint target); + ITensor *set_target(TargetHint target); /** Returns tensor's TensorInfo * * @return TensorInfo of the tensor @@ -114,10 +114,10 @@ public: * * @return Target of the tensor */ - Hint target() const; + TargetHint target() const; private: - Hint _target; /**< Target that this tensor is pinned on */ + TargetHint _target; /**< Target that this tensor is pinned on */ TensorInfo _info; /**< Tensor metadata */ std::unique_ptr _accessor; /**< Tensor Accessor */ std::unique_ptr _tensor; /**< Tensor */ diff --git a/arm_compute/graph/Types.h b/arm_compute/graph/Types.h index 538d64e9bb..e48ff84abf 100644 --- a/arm_compute/graph/Types.h +++ b/arm_compute/graph/Types.h @@ -47,7 +47,7 @@ using arm_compute::PoolingLayerInfo; using arm_compute::PoolingType; /**< Execution hint to the graph executor */ -enum class Hint +enum class TargetHint { DONT_CARE, /**< Run node in any device */ OPENCL, /**< Run node on an OpenCL capable device (GPU) */ diff --git a/arm_compute/graph/nodes/ActivationLayer.h b/arm_compute/graph/nodes/ActivationLayer.h index c23674e7b6..ea32dd02a2 100644 --- a/arm_compute/graph/nodes/ActivationLayer.h +++ b/arm_compute/graph/nodes/ActivationLayer.h @@ -24,6 +24,7 @@ #ifndef __ARM_COMPUTE_GRAPH_ACTIVATION_LAYER_H__ #define __ARM_COMPUTE_GRAPH_ACTIVATION_LAYER_H__ +#include "arm_compute/graph/GraphContext.h" #include "arm_compute/graph/INode.h" #include "arm_compute/graph/Tensor.h" #include "arm_compute/graph/Types.h" @@ -33,7 +34,7 @@ namespace arm_compute namespace graph { /** Activation Layer node */ -class ActivationLayer : public INode +class ActivationLayer final : public INode { public: /** Default Constructor @@ -43,7 +44,7 @@ public: ActivationLayer(const ActivationLayerInfo activation_info); // Inherited methods overriden: - std::unique_ptr instantiate_node(Hint hint, ITensor *input, ITensor *output) override; + std::unique_ptr instantiate_node(GraphContext &ctx, ITensor *input, ITensor *output) override; void print_info() override; private: diff --git a/arm_compute/graph/nodes/ConvolutionLayer.h b/arm_compute/graph/nodes/ConvolutionLayer.h index fcd097bdaa..086bf03dfe 100644 --- a/arm_compute/graph/nodes/ConvolutionLayer.h +++ b/arm_compute/graph/nodes/ConvolutionLayer.h @@ -24,6 +24,7 @@ #ifndef __ARM_COMPUTE_GRAPH_CONVOLUTION_LAYER_H__ #define __ARM_COMPUTE_GRAPH_CONVOLUTION_LAYER_H__ +#include "arm_compute/graph/GraphContext.h" #include "arm_compute/graph/INode.h" #include "arm_compute/graph/SubTensor.h" #include "arm_compute/graph/Tensor.h" @@ -76,7 +77,7 @@ public: } // Inherited methods overriden: - std::unique_ptr instantiate_node(Hint hint, ITensor *input, ITensor *output) override; + std::unique_ptr instantiate_node(GraphContext &ctx, ITensor *input, ITensor *output) override; void print_info() override; private: diff --git a/arm_compute/graph/nodes/FullyConnectedLayer.h b/arm_compute/graph/nodes/FullyConnectedLayer.h index 3e1fe23b11..b05bc96c99 100644 --- a/arm_compute/graph/nodes/FullyConnectedLayer.h +++ b/arm_compute/graph/nodes/FullyConnectedLayer.h @@ -24,6 +24,7 @@ #ifndef __ARM_COMPUTE_GRAPH_FULLY_CONNECTED_LAYER_H__ #define __ARM_COMPUTE_GRAPH_FULLY_CONNECTED_LAYER_H__ +#include "arm_compute/graph/GraphContext.h" #include "arm_compute/graph/INode.h" #include "arm_compute/graph/Tensor.h" #include "arm_compute/graph/Types.h" @@ -33,7 +34,7 @@ namespace arm_compute namespace graph { /** Fully connected layer node */ -class FullyConnectedLayer : public INode +class FullyConnectedLayer final : public INode { public: /** Default constructor @@ -49,7 +50,7 @@ public: } // Inherited methods overriden: - std::unique_ptr instantiate_node(Hint hint, ITensor *input, ITensor *output) override; + std::unique_ptr instantiate_node(GraphContext &ctx, ITensor *input, ITensor *output) override; void print_info() override; // Inherited methods overriden: diff --git a/arm_compute/graph/nodes/NormalizationLayer.h b/arm_compute/graph/nodes/NormalizationLayer.h index 40b9c2b467..52f67d2c31 100644 --- a/arm_compute/graph/nodes/NormalizationLayer.h +++ b/arm_compute/graph/nodes/NormalizationLayer.h @@ -24,6 +24,7 @@ #ifndef __ARM_COMPUTE_GRAPH_NORMALIZATION_LAYER_H__ #define __ARM_COMPUTE_GRAPH_NORMALIZATION_LAYER_H__ +#include "arm_compute/graph/GraphContext.h" #include "arm_compute/graph/INode.h" #include "arm_compute/graph/Types.h" @@ -42,7 +43,7 @@ public: explicit NormalizationLayer(const NormalizationLayerInfo norm_info); // Inherited methods overriden: - std::unique_ptr instantiate_node(Hint hint, ITensor *input, ITensor *output) override; + std::unique_ptr instantiate_node(GraphContext &ctx, ITensor *input, ITensor *output) override; void print_info() override; private: diff --git a/arm_compute/graph/nodes/PoolingLayer.h b/arm_compute/graph/nodes/PoolingLayer.h index 14e2c6d264..f07800a7b8 100644 --- a/arm_compute/graph/nodes/PoolingLayer.h +++ b/arm_compute/graph/nodes/PoolingLayer.h @@ -24,6 +24,7 @@ #ifndef __ARM_COMPUTE_GRAPH_POOLING_LAYER_H__ #define __ARM_COMPUTE_GRAPH_POOLING_LAYER_H__ +#include "arm_compute/graph/GraphContext.h" #include "arm_compute/graph/INode.h" #include "arm_compute/graph/Tensor.h" #include "arm_compute/graph/Types.h" @@ -33,7 +34,7 @@ namespace arm_compute namespace graph { /** Pooling layer node */ -class PoolingLayer : public INode +class PoolingLayer final : public INode { public: /** Default Constructor @@ -43,7 +44,7 @@ public: PoolingLayer(const PoolingLayerInfo pool_info); // Inherited methods overriden: - std::unique_ptr instantiate_node(Hint hint, ITensor *input, ITensor *output) override; + std::unique_ptr instantiate_node(GraphContext &ctx, ITensor *input, ITensor *output) override; void print_info() override; private: diff --git a/arm_compute/graph/nodes/SoftmaxLayer.h b/arm_compute/graph/nodes/SoftmaxLayer.h index 1779adae66..1515a0f28a 100644 --- a/arm_compute/graph/nodes/SoftmaxLayer.h +++ b/arm_compute/graph/nodes/SoftmaxLayer.h @@ -24,6 +24,7 @@ #ifndef __ARM_COMPUTE_GRAPH_SOFTMAX_LAYER_H__ #define __ARM_COMPUTE_GRAPH_SOFTMAX_LAYER_H__ +#include "arm_compute/graph/GraphContext.h" #include "arm_compute/graph/INode.h" #include "arm_compute/graph/Tensor.h" #include "arm_compute/graph/Types.h" @@ -37,7 +38,7 @@ class SoftmaxLayer : public INode { public: // Inherited methods overriden: - std::unique_ptr instantiate_node(Hint hint, ITensor *input, ITensor *output) override; + std::unique_ptr instantiate_node(GraphContext &ctx, ITensor *input, ITensor *output) override; void print_info() override; }; diff --git a/examples/graph_alexnet.cpp b/examples/graph_alexnet.cpp index cf5f635d33..9c736c5df1 100644 --- a/examples/graph_alexnet.cpp +++ b/examples/graph_alexnet.cpp @@ -94,11 +94,11 @@ void main_graph_alexnet(int argc, const char **argv) } // Check if OpenCL is available and initialize the scheduler - Hint hint = Hint::NEON; + TargetHint hint = TargetHint::NEON; if(arm_compute::opencl_is_available()) { arm_compute::CLScheduler::get().default_init(); - hint = Hint::OPENCL; + hint = TargetHint::OPENCL; } Graph graph; @@ -116,6 +116,7 @@ void main_graph_alexnet(int argc, const char **argv) << NormalizationLayer(NormalizationLayerInfo(NormType::CROSS_MAP, 5, 0.0001f, 0.75f)) << PoolingLayer(PoolingLayerInfo(PoolingType::MAX, 3, PadStrideInfo(2, 2, 0, 0))) // Layer 2 + << ConvolutionMethodHint::DIRECT << ConvolutionLayer( 5U, 5U, 256U, get_accessor(data_path, "/cnn_data/alexnet_model/conv2_w.npy"), diff --git a/examples/graph_lenet.cpp b/examples/graph_lenet.cpp index 1f04ff8a50..51b0881b1b 100644 --- a/examples/graph_lenet.cpp +++ b/examples/graph_lenet.cpp @@ -93,11 +93,11 @@ void main_graph_lenet(int argc, const char **argv) } // Check if OpenCL is available and initialize the scheduler - Hint hint = Hint::NEON; + TargetHint hint = TargetHint::NEON; if(arm_compute::opencl_is_available()) { arm_compute::CLScheduler::get().default_init(); - hint = Hint::OPENCL; + hint = TargetHint::OPENCL; } Graph graph; diff --git a/src/graph/Graph.cpp b/src/graph/Graph.cpp index 525506f316..25c4577df7 100644 --- a/src/graph/Graph.cpp +++ b/src/graph/Graph.cpp @@ -46,7 +46,7 @@ public: * * @param _next_hint Device execution hint */ - void configure(Hint _next_hint); + void configure(GraphHints _next_hints); /** Sets whether to enable information print out * @@ -54,11 +54,12 @@ public: */ void set_info_enablement(bool is_enabled); + GraphContext _ctx{}; std::vector _pipeline{}; std::vector> _tensors{}; std::vector> _nodes{}; - Hint _current_hint{ Hint::DONT_CARE }; - Hint _next_hint{ Hint::DONT_CARE }; + GraphHints _current_hints{}; + GraphHints _next_hints{}; std::unique_ptr _graph_input{ nullptr }; std::unique_ptr _graph_output{ nullptr }; std::unique_ptr _current_node{ nullptr }; @@ -66,8 +67,8 @@ public: bool _info_enabled{ false }; private: - Tensor *_current_input{ nullptr }; - Hint _previous_hint{ Hint::DONT_CARE }; + Tensor *_current_input{ nullptr }; + GraphHints _previous_hints{}; }; Graph::~Graph() //NOLINT @@ -102,7 +103,7 @@ void Graph::run() } //Finalize current node's configuration -void Graph::Private::configure(Hint _next_hint) +void Graph::Private::configure(GraphHints _next_hints) { ARM_COMPUTE_ERROR_ON(_current_node == nullptr); ARM_COMPUTE_ERROR_ON(_graph_input == nullptr); @@ -110,9 +111,9 @@ void Graph::Private::configure(Hint _next_hint) // Is it the first node of the graph ? if(_current_input == nullptr) { - _graph_input->set_target(_current_hint); - _current_input = _graph_input.get(); - _previous_hint = _current_hint; // For the first node just assume the previous node was of the same type as this one + _graph_input->set_target(_current_hints.target_hint()); + _current_input = _graph_input.get(); + _previous_hints = _current_hints; // For the first node just assume the previous node was of the same type as this one } //Automatic output configuration ? @@ -123,29 +124,31 @@ void Graph::Private::configure(Hint _next_hint) } // If either the writer or reader node needs OpenCL then use OpenCL memory: - if((_next_hint == Hint::OPENCL || _current_hint == Hint::OPENCL)) + if((_next_hints.target_hint() == TargetHint::OPENCL || _current_hints.target_hint() == TargetHint::OPENCL)) { - _current_output->set_target(Hint::OPENCL); + _current_output->set_target(TargetHint::OPENCL); } else { - _current_output->set_target(Hint::NEON); + _current_output->set_target(TargetHint::NEON); } - // Map input if needed - std::unique_ptr func = _current_node->instantiate_node(_current_hint, _current_input->tensor(), _current_output->tensor()); + // Update ctx and instantiate node + _ctx.hints() = _current_hints; + std::unique_ptr func = _current_node->instantiate_node(_ctx, _current_input->tensor(), _current_output->tensor()); _current_input->allocate(); - if(_current_input->target() == Hint::OPENCL) + // Map input if needed + if(_current_input->target() == TargetHint::OPENCL) { - if(_previous_hint == Hint::NEON) + if(_previous_hints.target_hint() == TargetHint::NEON) { - ARM_COMPUTE_ERROR_ON(_current_hint == Hint::NEON); + ARM_COMPUTE_ERROR_ON(_current_hints.target_hint() == TargetHint::NEON); _pipeline.push_back({ _current_input, _current_input, arm_compute::support::cpp14::make_unique(_current_input) }); } - if(_current_hint == Hint::NEON) + if(_current_hints.target_hint() == TargetHint::NEON) { - ARM_COMPUTE_ERROR_ON(_previous_hint == Hint::NEON); + ARM_COMPUTE_ERROR_ON(_previous_hints.target_hint() == TargetHint::NEON); _pipeline.push_back({ _current_input, _current_input, arm_compute::support::cpp14::make_unique(_current_input, true) }); } } @@ -154,8 +157,8 @@ void Graph::Private::configure(Hint _next_hint) _current_input = _current_output; _current_output = nullptr; - _previous_hint = _current_hint; - _current_hint = _next_hint; + std::swap(_previous_hints, _current_hints); + std::swap(_current_hints, _next_hints); } void Graph::Private::set_info_enablement(bool is_enabled) @@ -169,12 +172,13 @@ void Graph::add_node(std::unique_ptr node) ARM_COMPUTE_ERROR_ON_MSG(_pimpl->_graph_output != nullptr, "Nothing can be added after the output tensor"); //Trigger the creation of the current Node: - Hint _next_hint = node->override_hint(_pimpl->_next_hint); - ARM_COMPUTE_ERROR_ON(_next_hint == Hint::DONT_CARE); + GraphHints _next_hints = _pimpl->_next_hints; + _next_hints.set_target_hint(node->override_target_hint(_pimpl->_next_hints.target_hint())); + ARM_COMPUTE_ERROR_ON(_next_hints.target_hint() == TargetHint::DONT_CARE); if(_pimpl->_current_node) { //Finalize the previous Node: - _pimpl->configure(_pimpl->_next_hint); + _pimpl->configure(_pimpl->_next_hints); if(_pimpl->_info_enabled) { @@ -183,8 +187,8 @@ void Graph::add_node(std::unique_ptr node) } else { - // If that's the first node then use the same Hint before and after the node. - _pimpl->_current_hint = _next_hint; + // If that's the first node then use the same TargetHint before and after the node. + _pimpl->_current_hints = _next_hints; } if(_pimpl->_current_node) { @@ -192,15 +196,6 @@ void Graph::add_node(std::unique_ptr node) } _pimpl->_current_node = std::move(node); } -void Graph::set_hint(Hint hint) -{ - _pimpl->_next_hint = hint; -} - -void Graph::set_info_enablement(bool is_enabled) -{ - _pimpl->set_info_enablement(is_enabled); -} //Add a tensor with an Accessor (i.e either the input or output of the graph) void Graph::add_tensor(std::unique_ptr tensor) @@ -221,7 +216,7 @@ void Graph::add_tensor(std::unique_ptr tensor) _pimpl->_current_output = _pimpl->_graph_output.get(); // Finalize the graph by configuring the last Node of the graph: - _pimpl->configure(_pimpl->_current_hint); // Ignore _next_hint as this is the last node, and just use the same hint as before this node. + _pimpl->configure(_pimpl->_current_hints); // Ignore _next_hint as this is the last node, and just use the same hint as before this node. _pimpl->_graph_output->allocate(); } } @@ -236,6 +231,16 @@ void Graph::set_temp(TensorInfo &&tmp) _pimpl->_current_output = _pimpl->_tensors.back().get(); } +void Graph::set_info_enablement(bool is_enabled) +{ + _pimpl->set_info_enablement(is_enabled); +} + +GraphHints &Graph::hints() +{ + return _pimpl->_next_hints; +} + Graph &arm_compute::graph::operator<<(Graph &graph, TensorInfo &&info) { graph.set_temp(std::move(info)); @@ -248,8 +253,14 @@ Graph &arm_compute::graph::operator<<(Graph &graph, Tensor &&tensor) return graph; } -Graph &arm_compute::graph::operator<<(Graph &graph, Hint hint) +Graph &arm_compute::graph::operator<<(Graph &graph, TargetHint target_hint) +{ + graph.hints().set_target_hint(target_hint); + return graph; +} + +Graph &arm_compute::graph::operator<<(Graph &graph, ConvolutionMethodHint conv_method_hint) { - graph.set_hint(hint); + graph.hints().set_convolution_method_hint(conv_method_hint); return graph; } diff --git a/src/graph/GraphContext.cpp b/src/graph/GraphContext.cpp new file mode 100644 index 0000000000..bfc6fcdfca --- /dev/null +++ b/src/graph/GraphContext.cpp @@ -0,0 +1,66 @@ +/* + * Copyright (c) 2017 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/graph/GraphContext.h" + +using namespace arm_compute::graph; + +GraphHints::GraphHints(TargetHint target_hint, ConvolutionMethodHint conv_method_hint) + : _target_hint(target_hint), _convolution_method_hint(conv_method_hint) +{ +} + +void GraphHints::set_target_hint(TargetHint target_hint) +{ + _target_hint = target_hint; +} + +void GraphHints::set_convolution_method_hint(ConvolutionMethodHint convolution_method) +{ + _convolution_method_hint = convolution_method; +} + +TargetHint GraphHints::target_hint() const +{ + return _target_hint; +} + +ConvolutionMethodHint GraphHints::convolution_method_hint() const +{ + return _convolution_method_hint; +} + +GraphContext::GraphContext() + : _hints() +{ +} + +GraphHints &GraphContext::hints() +{ + return _hints; +} + +const GraphHints &GraphContext::hints() const +{ + return _hints; +} \ No newline at end of file diff --git a/src/graph/INode.cpp b/src/graph/INode.cpp index 6b25022d15..4b383f562b 100644 --- a/src/graph/INode.cpp +++ b/src/graph/INode.cpp @@ -21,7 +21,6 @@ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ - #include "arm_compute/graph/INode.h" #include "arm_compute/core/CL/OpenCL.h" @@ -31,17 +30,20 @@ using namespace arm_compute::graph; -Hint INode::override_hint(Hint hint) const +TargetHint INode::override_target_hint(TargetHint target_hint) const { - if(hint == Hint::OPENCL && !opencl_is_available()) + if(target_hint == TargetHint::OPENCL && !opencl_is_available()) { - hint = Hint::DONT_CARE; + target_hint = TargetHint::DONT_CARE; } - hint = node_override_hint(hint); - ARM_COMPUTE_ERROR_ON(hint == Hint::OPENCL && !opencl_is_available()); - return hint; + GraphHints hints{ target_hint }; + target_hint = node_override_hints(hints).target_hint(); + ARM_COMPUTE_ERROR_ON(target_hint == TargetHint::OPENCL && !opencl_is_available()); + return target_hint; } -Hint INode::node_override_hint(Hint hint) const +GraphHints INode::node_override_hints(GraphHints hints) const { - return hint == Hint::DONT_CARE ? Hint::NEON : hint; + TargetHint target_hint = hints.target_hint(); + hints.set_target_hint((target_hint == TargetHint::DONT_CARE) ? TargetHint::NEON : target_hint); + return hints; } diff --git a/src/graph/SubTensor.cpp b/src/graph/SubTensor.cpp index a70f32927b..abf8506c33 100644 --- a/src/graph/SubTensor.cpp +++ b/src/graph/SubTensor.cpp @@ -21,7 +21,6 @@ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ - #include "arm_compute/graph/SubTensor.h" #include "arm_compute/core/Error.h" @@ -45,12 +44,12 @@ std::unique_ptr initialise_subtensor(ITensor *parent, TensorShape shape } // namespace SubTensor::SubTensor() - : _target(Hint::DONT_CARE), _coords(), _info(), _parent(nullptr), _subtensor(nullptr) + : _target(TargetHint::DONT_CARE), _coords(), _info(), _parent(nullptr), _subtensor(nullptr) { } SubTensor::SubTensor(Tensor &parent, TensorShape tensor_shape, Coordinates coords) - : _target(Hint::DONT_CARE), _coords(coords), _info(), _parent(nullptr), _subtensor(nullptr) + : _target(TargetHint::DONT_CARE), _coords(coords), _info(), _parent(nullptr), _subtensor(nullptr) { ARM_COMPUTE_ERROR_ON(parent.tensor() == nullptr); _parent = parent.tensor(); @@ -60,7 +59,7 @@ SubTensor::SubTensor(Tensor &parent, TensorShape tensor_shape, Coordinates coord instantiate_subtensor(); } -SubTensor::SubTensor(ITensor *parent, TensorShape tensor_shape, Coordinates coords, Hint target) +SubTensor::SubTensor(ITensor *parent, TensorShape tensor_shape, Coordinates coords, TargetHint target) : _target(target), _coords(coords), _info(), _parent(parent), _subtensor(nullptr) { ARM_COMPUTE_ERROR_ON(parent == nullptr); @@ -84,7 +83,7 @@ ITensor *SubTensor::tensor() return _subtensor.get(); } -Hint SubTensor::target() const +TargetHint SubTensor::target() const { return _target; } @@ -93,13 +92,13 @@ void SubTensor::instantiate_subtensor() { switch(_target) { - case Hint::OPENCL: + case TargetHint::OPENCL: _subtensor = initialise_subtensor(_parent, _info.tensor_shape(), _coords); break; - case Hint::NEON: + case TargetHint::NEON: _subtensor = initialise_subtensor(_parent, _info.tensor_shape(), _coords); break; default: - ARM_COMPUTE_ERROR("Invalid Hint"); + ARM_COMPUTE_ERROR("Invalid TargetHint"); } } diff --git a/src/graph/Tensor.cpp b/src/graph/Tensor.cpp index c534ae0296..31dd4e86ac 100644 --- a/src/graph/Tensor.cpp +++ b/src/graph/Tensor.cpp @@ -21,7 +21,6 @@ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ - #include "arm_compute/graph/Tensor.h" #include "arm_compute/core/Error.h" @@ -53,7 +52,7 @@ void tensor_allocate(ITensor &tensor) } // namespace Tensor::Tensor(TensorInfo &&info) - : _target(Hint::DONT_CARE), _info(info), _accessor(nullptr), _tensor(nullptr) + : _target(TargetHint::DONT_CARE), _info(info), _accessor(nullptr), _tensor(nullptr) { } @@ -96,7 +95,7 @@ const TensorInfo &Tensor::info() const return _info; } -ITensor *Tensor::set_target(Hint target) +ITensor *Tensor::set_target(TargetHint target) { if(_tensor != nullptr) { @@ -106,14 +105,14 @@ ITensor *Tensor::set_target(Hint target) { switch(target) { - case Hint::OPENCL: + case TargetHint::OPENCL: _tensor = initialise_tensor(_info); break; - case Hint::NEON: + case TargetHint::NEON: _tensor = initialise_tensor(_info); break; default: - ARM_COMPUTE_ERROR("Invalid Hint"); + ARM_COMPUTE_ERROR("Invalid TargetHint"); } _target = target; } @@ -125,14 +124,14 @@ void Tensor::allocate() ARM_COMPUTE_ERROR_ON_NULLPTR(_tensor.get()); switch(_target) { - case Hint::OPENCL: + case TargetHint::OPENCL: tensor_allocate(*_tensor); break; - case Hint::NEON: + case TargetHint::NEON: tensor_allocate(*_tensor); break; default: - ARM_COMPUTE_ERROR("Invalid Hint"); + ARM_COMPUTE_ERROR("Invalid TargetHint"); } } @@ -145,7 +144,7 @@ void Tensor::allocate_and_fill_if_needed() } } -Hint Tensor::target() const +TargetHint Tensor::target() const { return _target; } diff --git a/src/graph/nodes/ActivationLayer.cpp b/src/graph/nodes/ActivationLayer.cpp index b71e22c601..da2dac04e2 100644 --- a/src/graph/nodes/ActivationLayer.cpp +++ b/src/graph/nodes/ActivationLayer.cpp @@ -34,7 +34,7 @@ using namespace arm_compute::graph; namespace { -template +template std::unique_ptr instantiate_function(ITensor *input, ITensor *output, const ActivationLayerInfo &activation_info) { auto activation = arm_compute::support::cpp14::make_unique(); @@ -46,19 +46,19 @@ std::unique_ptr instantiate_function(ITensor *input, ITe return std::move(activation); } -template +template std::unique_ptr instantiate(ITensor *input, ITensor *output, const ActivationLayerInfo &activation_info); template <> -std::unique_ptr instantiate(ITensor *input, ITensor *output, const ActivationLayerInfo &activation_info) +std::unique_ptr instantiate(ITensor *input, ITensor *output, const ActivationLayerInfo &activation_info) { - return instantiate_function(input, output, activation_info); + return instantiate_function(input, output, activation_info); } template <> -std::unique_ptr instantiate(ITensor *input, ITensor *output, const ActivationLayerInfo &activation_info) +std::unique_ptr instantiate(ITensor *input, ITensor *output, const ActivationLayerInfo &activation_info) { - return instantiate_function(input, output, activation_info); + return instantiate_function(input, output, activation_info); } } // namespace @@ -67,27 +67,27 @@ ActivationLayer::ActivationLayer(const ActivationLayerInfo activation_info) { } -std::unique_ptr ActivationLayer::instantiate_node(Hint hint, ITensor *input, ITensor *output) +std::unique_ptr ActivationLayer::instantiate_node(GraphContext &ctx, ITensor *input, ITensor *output) { std::unique_ptr func; - _hint = hint; - _input = input; - _output = output; + _target_hint = ctx.hints().target_hint(); + _input = input; + _output = output; - if(_hint == Hint::OPENCL) + if(_target_hint == TargetHint::OPENCL) { - func = instantiate(input, output, _activation_info); + func = instantiate(input, output, _activation_info); } else { - func = instantiate(input, output, _activation_info); + func = instantiate(input, output, _activation_info); } return func; } void ActivationLayer::print_info() { - if(_hint == Hint::OPENCL) + if(_target_hint == TargetHint::OPENCL) { std::cout << "Instantiating CLActivationLayer"; } diff --git a/src/graph/nodes/ConvolutionLayer.cpp b/src/graph/nodes/ConvolutionLayer.cpp index ce9f096719..a992095786 100644 --- a/src/graph/nodes/ConvolutionLayer.cpp +++ b/src/graph/nodes/ConvolutionLayer.cpp @@ -65,7 +65,7 @@ TensorShape calculate_convolution_layer_output_shape(const TensorShape &input_sh } // Instantiate GEMM based convolution layer -template +template std::unique_ptr instantiate_function(ITensor *input, ITensor *weights, ITensor *biases, ITensor *output, const PadStrideInfo &conv_info, const WeightsInfo &weights_info) { auto conv = arm_compute::support::cpp14::make_unique(); @@ -79,7 +79,7 @@ std::unique_ptr instantiate_function(ITensor *input, ITe } // Instantiate direct convolution layer -template +template std::unique_ptr instantiate_direct_function(ITensor *input, ITensor *weights, ITensor *biases, ITensor *output, const PadStrideInfo &conv_info) { auto conv = arm_compute::support::cpp14::make_unique(); @@ -92,35 +92,37 @@ std::unique_ptr instantiate_direct_function(ITensor *inp return std::move(conv); } -template +template std::unique_ptr instantiate(ITensor *input, ITensor *weights, ITensor *biases, ITensor *output, const PadStrideInfo &conv_info, const WeightsInfo &weights_info, ConvolutionMethodHint conv_method); template <> -std::unique_ptr instantiate(ITensor *input, ITensor *weights, ITensor *biases, ITensor *output, const PadStrideInfo &conv_info, const WeightsInfo &weights_info, - ConvolutionMethodHint conv_method) +std::unique_ptr instantiate(ITensor *input, ITensor *weights, ITensor *biases, ITensor *output, const PadStrideInfo &conv_info, + const WeightsInfo &weights_info, + ConvolutionMethodHint conv_method) { if(conv_method == ConvolutionMethodHint::GEMM) { - return instantiate_function(input, weights, biases, output, conv_info, weights_info); + return instantiate_function(input, weights, biases, output, conv_info, weights_info); } else { - return instantiate_direct_function(input, weights, biases, output, conv_info); + return instantiate_direct_function(input, weights, biases, output, conv_info); } } template <> -std::unique_ptr instantiate(ITensor *input, ITensor *weights, ITensor *biases, ITensor *output, const PadStrideInfo &conv_info, const WeightsInfo &weights_info, - ConvolutionMethodHint conv_method) +std::unique_ptr instantiate(ITensor *input, ITensor *weights, ITensor *biases, ITensor *output, const PadStrideInfo &conv_info, + const WeightsInfo &weights_info, + ConvolutionMethodHint conv_method) { if(conv_method == ConvolutionMethodHint::GEMM) { - return instantiate_function(input, weights, biases, output, conv_info, weights_info); + return instantiate_function(input, weights, biases, output, conv_info, weights_info); } else { - return instantiate_direct_function(input, weights, biases, output, conv_info); + return instantiate_direct_function(input, weights, biases, output, conv_info); } } } // namespace @@ -166,7 +168,7 @@ private: std::vector> _convolutions; }; -std::unique_ptr ConvolutionLayer::instantiate_node(Hint hint, ITensor *input, ITensor *output) +std::unique_ptr ConvolutionLayer::instantiate_node(GraphContext &ctx, ITensor *input, ITensor *output) { // Set weights and biases info if(_weights.tensor() == nullptr) @@ -181,17 +183,18 @@ std::unique_ptr ConvolutionLayer::instantiate_node(Hint } std::unique_ptr func; - _hint = hint; - _input = input; - _output = output; + _target_hint = ctx.hints().target_hint(); + _input = input; + _output = output; + const ConvolutionMethodHint conv_method_hint = ctx.hints().convolution_method_hint(); // Check if the weights and biases are loaded bool weights_are_loaded = _weights.tensor() != nullptr; bool biases_are_loaded = _weights.tensor() != nullptr; // Set bias and weights target - _weights.set_target(_hint); - _biases.set_target(_hint); + _weights.set_target(_target_hint); + _biases.set_target(_target_hint); // Calculate output shape TensorShape output_shape = calculate_convolution_layer_output_shape(_input->info()->tensor_shape(), _weights.info().tensor_shape(), _conv_info); @@ -200,14 +203,13 @@ std::unique_ptr ConvolutionLayer::instantiate_node(Hint arm_compute::auto_init_if_empty(*_output->info(), output_shape, 1, _input->info()->data_type(), _input->info()->fixed_point_position()); // Create appropriate convolution function - // TODO(geopin01): Fix convolution layer hints once the GraphContext has been added if(_num_groups == 1) { - func = instantiate_convolution(ConvolutionMethodHint::GEMM); + func = instantiate_convolution(conv_method_hint); } else { - func = instantiate_grouped_convolution(ConvolutionMethodHint::GEMM); + func = instantiate_grouped_convolution(conv_method_hint); } // Fill weights @@ -226,7 +228,7 @@ std::unique_ptr ConvolutionLayer::instantiate_node(Hint void ConvolutionLayer::print_info() { - if(_hint == Hint::OPENCL) + if(_target_hint == TargetHint::OPENCL) { std::cout << "Instantiating CLConvolutionLayer"; } @@ -248,13 +250,13 @@ void ConvolutionLayer::print_info() std::unique_ptr ConvolutionLayer::instantiate_convolution(ConvolutionMethodHint conv_method_hint) { std::unique_ptr func; - if(_hint == Hint::OPENCL) + if(_target_hint == TargetHint::OPENCL) { - func = instantiate(_input, _weights.tensor(), _biases.tensor(), _output, _conv_info, _weights_info, conv_method_hint); + func = instantiate(_input, _weights.tensor(), _biases.tensor(), _output, _conv_info, _weights_info, conv_method_hint); } else { - func = instantiate(_input, _weights.tensor(), _biases.tensor(), _output, _conv_info, _weights_info, conv_method_hint); + func = instantiate(_input, _weights.tensor(), _biases.tensor(), _output, _conv_info, _weights_info, conv_method_hint); } return func; } @@ -306,20 +308,20 @@ std::unique_ptr ConvolutionLayer::instantiate_grouped_co Coordinates biases_coord(biases_split * i); // Create sub-tensors for input, output, weights and bias - auto hint_to_use = (_hint == Hint::OPENCL) ? Hint::OPENCL : Hint::NEON; + auto hint_to_use = (_target_hint == TargetHint::OPENCL) ? TargetHint::OPENCL : TargetHint::NEON; _is[i] = SubTensor(_input, input_shape, input_coord, hint_to_use); _os[i] = SubTensor(_output, output_shape, output_coord, hint_to_use); _ws[i] = SubTensor(_weights.tensor(), weights_shape, weights_coord, hint_to_use); _bs[i] = SubTensor(_biases.tensor(), biases_shape, biases_coord, hint_to_use); // Instantiate convolution function - if(_hint == Hint::OPENCL) + if(_target_hint == TargetHint::OPENCL) { - func = instantiate(_is[i].tensor(), _ws[i].tensor(), _bs[i].tensor(), _os[i].tensor(), _conv_info, _weights_info, conv_method_hint); + func = instantiate(_is[i].tensor(), _ws[i].tensor(), _bs[i].tensor(), _os[i].tensor(), _conv_info, _weights_info, conv_method_hint); } else { - func = instantiate(_is[i].tensor(), _ws[i].tensor(), _bs[i].tensor(), _os[i].tensor(), _conv_info, _weights_info, conv_method_hint); + func = instantiate(_is[i].tensor(), _ws[i].tensor(), _bs[i].tensor(), _os[i].tensor(), _conv_info, _weights_info, conv_method_hint); } // Add convolution function to the list of convolutions for the grouped convolution diff --git a/src/graph/nodes/FullyConnectedLayer.cpp b/src/graph/nodes/FullyConnectedLayer.cpp index fcc86be8fa..c317660b20 100644 --- a/src/graph/nodes/FullyConnectedLayer.cpp +++ b/src/graph/nodes/FullyConnectedLayer.cpp @@ -43,7 +43,7 @@ TensorShape calculate_fullyconnected_layer_output_shape(const TensorShape &input } return TensorShape(output_neurons, batches); } -template +template std::unique_ptr instantiate_function(ITensor *input, Tensor &weights, Tensor &biases, ITensor *output) { bool weights_are_loaded = weights.tensor() != nullptr; @@ -52,8 +52,8 @@ std::unique_ptr instantiate_function(ITensor *input, Ten auto conv = arm_compute::support::cpp14::make_unique(); conv->configure( dynamic_cast(input), - dynamic_cast(weights.set_target(hint)), - dynamic_cast(biases.set_target(hint)), + dynamic_cast(weights.set_target(target_hint)), + dynamic_cast(biases.set_target(target_hint)), dynamic_cast(output)); if(!weights_are_loaded) { @@ -67,23 +67,23 @@ std::unique_ptr instantiate_function(ITensor *input, Ten return std::move(conv); } -template +template std::unique_ptr instantiate(ITensor *input, Tensor &weights, Tensor &biases, ITensor *output); template <> -std::unique_ptr instantiate(ITensor *input, Tensor &weights, Tensor &biases, ITensor *output) +std::unique_ptr instantiate(ITensor *input, Tensor &weights, Tensor &biases, ITensor *output) { - return instantiate_function(input, weights, biases, output); + return instantiate_function(input, weights, biases, output); } template <> -std::unique_ptr instantiate(ITensor *input, Tensor &weights, Tensor &biases, ITensor *output) +std::unique_ptr instantiate(ITensor *input, Tensor &weights, Tensor &biases, ITensor *output) { - return instantiate_function(input, weights, biases, output); + return instantiate_function(input, weights, biases, output); } } // namespace -std::unique_ptr FullyConnectedLayer::instantiate_node(Hint hint, ITensor *input, ITensor *output) +std::unique_ptr FullyConnectedLayer::instantiate_node(GraphContext &ctx, ITensor *input, ITensor *output) { if(_weights.tensor() == nullptr) { @@ -111,17 +111,17 @@ std::unique_ptr FullyConnectedLayer::instantiate_node(Hi input->info()->num_channels(), input->info()->data_type(), input->info()->fixed_point_position()); std::unique_ptr func; - _hint = hint; - _input = input; - _output = output; + _target_hint = ctx.hints().target_hint(); + _input = input; + _output = output; - if(_hint == Hint::OPENCL) + if(_target_hint == TargetHint::OPENCL) { - func = instantiate(input, _weights, _biases, output); + func = instantiate(input, _weights, _biases, output); } else { - func = instantiate(input, _weights, _biases, output); + func = instantiate(input, _weights, _biases, output); } return func; @@ -129,7 +129,7 @@ std::unique_ptr FullyConnectedLayer::instantiate_node(Hi void FullyConnectedLayer::print_info() { - if(_hint == Hint::OPENCL) + if(_target_hint == TargetHint::OPENCL) { std::cout << "Instantiating CLFullyConnectedLayer"; } diff --git a/src/graph/nodes/NormalizationLayer.cpp b/src/graph/nodes/NormalizationLayer.cpp index 55ef9bf243..99d07dc8da 100644 --- a/src/graph/nodes/NormalizationLayer.cpp +++ b/src/graph/nodes/NormalizationLayer.cpp @@ -34,7 +34,7 @@ using namespace arm_compute::graph; namespace { -template +template std::unique_ptr instantiate_function(ITensor *input, ITensor *output, const NormalizationLayerInfo &norm_info) { auto norm = arm_compute::support::cpp14::make_unique(); @@ -46,19 +46,19 @@ std::unique_ptr instantiate_function(ITensor *input, ITe return std::move(norm); } -template +template std::unique_ptr instantiate(ITensor *input, ITensor *output, const NormalizationLayerInfo &norm_info); template <> -std::unique_ptr instantiate(ITensor *input, ITensor *output, const NormalizationLayerInfo &norm_info) +std::unique_ptr instantiate(ITensor *input, ITensor *output, const NormalizationLayerInfo &norm_info) { - return instantiate_function(input, output, norm_info); + return instantiate_function(input, output, norm_info); } template <> -std::unique_ptr instantiate(ITensor *input, ITensor *output, const NormalizationLayerInfo &norm_info) +std::unique_ptr instantiate(ITensor *input, ITensor *output, const NormalizationLayerInfo &norm_info) { - return instantiate_function(input, output, norm_info); + return instantiate_function(input, output, norm_info); } } // namespace @@ -67,20 +67,20 @@ NormalizationLayer::NormalizationLayer(const NormalizationLayerInfo norm_info) { } -std::unique_ptr NormalizationLayer::instantiate_node(Hint hint, ITensor *input, ITensor *output) +std::unique_ptr NormalizationLayer::instantiate_node(GraphContext &ctx, ITensor *input, ITensor *output) { std::unique_ptr func; - _hint = hint; - _input = input; - _output = output; + _target_hint = ctx.hints().target_hint(); + _input = input; + _output = output; - if(_hint == Hint::OPENCL) + if(_target_hint == TargetHint::OPENCL) { - func = instantiate(input, output, _norm_info); + func = instantiate(input, output, _norm_info); } else { - func = instantiate(input, output, _norm_info); + func = instantiate(input, output, _norm_info); } return func; @@ -88,7 +88,7 @@ std::unique_ptr NormalizationLayer::instantiate_node(Hin void NormalizationLayer::print_info() { - if(_hint == Hint::OPENCL) + if(_target_hint == TargetHint::OPENCL) { std::cout << "Instantiating CLNormalizationLayer"; } diff --git a/src/graph/nodes/PoolingLayer.cpp b/src/graph/nodes/PoolingLayer.cpp index f29332f65b..2a5e4cb3d8 100644 --- a/src/graph/nodes/PoolingLayer.cpp +++ b/src/graph/nodes/PoolingLayer.cpp @@ -34,7 +34,7 @@ using namespace arm_compute::graph; namespace { -template +template std::unique_ptr instantiate_function(ITensor *input, ITensor *output, const PoolingLayerInfo &pool_info) { auto pool = arm_compute::support::cpp14::make_unique(); @@ -46,19 +46,19 @@ std::unique_ptr instantiate_function(ITensor *input, ITe return std::move(pool); } -template +template std::unique_ptr instantiate(ITensor *input, ITensor *output, const PoolingLayerInfo &pool_info); template <> -std::unique_ptr instantiate(ITensor *input, ITensor *output, const PoolingLayerInfo &pool_info) +std::unique_ptr instantiate(ITensor *input, ITensor *output, const PoolingLayerInfo &pool_info) { - return instantiate_function(input, output, pool_info); + return instantiate_function(input, output, pool_info); } template <> -std::unique_ptr instantiate(ITensor *input, ITensor *output, const PoolingLayerInfo &pool_info) +std::unique_ptr instantiate(ITensor *input, ITensor *output, const PoolingLayerInfo &pool_info) { - return instantiate_function(input, output, pool_info); + return instantiate_function(input, output, pool_info); } } // namespace @@ -67,20 +67,20 @@ PoolingLayer::PoolingLayer(const PoolingLayerInfo pool_info) { } -std::unique_ptr PoolingLayer::instantiate_node(Hint hint, ITensor *input, ITensor *output) +std::unique_ptr PoolingLayer::instantiate_node(GraphContext &ctx, ITensor *input, ITensor *output) { std::unique_ptr func; - _hint = hint; - _input = input; - _output = output; + _target_hint = ctx.hints().target_hint(); + _input = input; + _output = output; - if(_hint == Hint::OPENCL) + if(_target_hint == TargetHint::OPENCL) { - func = instantiate(input, output, _pool_info); + func = instantiate(input, output, _pool_info); } else { - func = instantiate(input, output, _pool_info); + func = instantiate(input, output, _pool_info); } return func; @@ -88,7 +88,7 @@ std::unique_ptr PoolingLayer::instantiate_node(Hint hint void PoolingLayer::print_info() { - if(_hint == Hint::OPENCL) + if(_target_hint == TargetHint::OPENCL) { std::cout << "Instantiating CLPoolingLayer"; } diff --git a/src/graph/nodes/SoftmaxLayer.cpp b/src/graph/nodes/SoftmaxLayer.cpp index fee88970fc..9e798ef7cc 100644 --- a/src/graph/nodes/SoftmaxLayer.cpp +++ b/src/graph/nodes/SoftmaxLayer.cpp @@ -34,7 +34,7 @@ using namespace arm_compute::graph; namespace { -template +template std::unique_ptr instantiate_function(ITensor *input, ITensor *output) { auto softmax = arm_compute::support::cpp14::make_unique(); @@ -45,36 +45,36 @@ std::unique_ptr instantiate_function(ITensor *input, ITe return std::move(softmax); } -template +template std::unique_ptr instantiate(ITensor *input, ITensor *output); template <> -std::unique_ptr instantiate(ITensor *input, ITensor *output) +std::unique_ptr instantiate(ITensor *input, ITensor *output) { - return instantiate_function(input, output); + return instantiate_function(input, output); } template <> -std::unique_ptr instantiate(ITensor *input, ITensor *output) +std::unique_ptr instantiate(ITensor *input, ITensor *output) { - return instantiate_function(input, output); + return instantiate_function(input, output); } } // namespace -std::unique_ptr SoftmaxLayer::instantiate_node(Hint hint, ITensor *input, ITensor *output) +std::unique_ptr SoftmaxLayer::instantiate_node(GraphContext &ctx, ITensor *input, ITensor *output) { std::unique_ptr func; - _hint = hint; - _input = input; - _output = output; + _target_hint = ctx.hints().target_hint(); + _input = input; + _output = output; - if(_hint == Hint::OPENCL) + if(_target_hint == TargetHint::OPENCL) { - func = instantiate(input, output); + func = instantiate(input, output); } else { - func = instantiate(input, output); + func = instantiate(input, output); } return func; @@ -82,7 +82,7 @@ std::unique_ptr SoftmaxLayer::instantiate_node(Hint hint void SoftmaxLayer::print_info() { - if(_hint == Hint::OPENCL) + if(_target_hint == TargetHint::OPENCL) { std::cout << "Instantiating CLSoftmaxLayer"; } -- cgit v1.2.1