arm_compute v17.04

Author: AnthonyBarbier

arm_compute/core/AccessWindowAutoPadding.h

@@ -58,12 +58,16 @@ class AccessWindowAutoPadding : public IAccessWindow
     AccessWindowAutoPadding &operator=(AccessWindowAutoPadding &&) = default;
     ~AccessWindowAutoPadding()                                     = default;
 
+    /** Set the valid region to match the entire tensor. */
     void set_valid_region();
 
+    /** Return a valid region that spans across the entire tensor. */
+    ValidRegion compute_valid_region() const;
+
     // Inherited methods overridden:
     bool update_window_if_needed(Window &window) const override;
     bool update_padding_if_needed(const Window &window) const override;
-    void set_valid_region(const Window &window, ValidRegion input_valid_region, bool border_undefined, BorderSize border_size) override;
+    ValidRegion compute_valid_region(const Window &window, ValidRegion input_valid_region, bool border_undefined, BorderSize border_size) const override;
 
 private:
     TensorInfo *_info;

arm_compute/core/AccessWindowStatic.h

@@ -62,11 +62,25 @@ class AccessWindowStatic : public IAccessWindow
     AccessWindowStatic &operator=(AccessWindowStatic &&) = default;
     ~AccessWindowStatic()                                = default;
 
+    /** Set the valid region based on the static access pattern and valid
+     *  region of the inputs.
+     *
+     * @param[in] window             Execution window of the kernel.
+     * @param[in] input_valid_region Combined valid region of all inputs.
+     */
+    void set_valid_region(const Window &window, const ValidRegion &input_valid_region);
+
+    /** Compute the valid region based on the static access pattern and valid region of the inputs.
+     *
+     * @param[in] window             Execution window of the kernel.
+     * @param[in] input_valid_region Combined valid region of all inputs.
+     */
+    ValidRegion compute_valid_region(const Window &window, ValidRegion input_valid_region) const;
+
     // Inherited methods overriden:
     bool update_window_if_needed(Window &window) const override;
     bool update_padding_if_needed(const Window &window) const override;
-    void set_valid_region(const Window &window, ValidRegion input_valid_region);
-    void set_valid_region(const Window &window, ValidRegion input_valid_region, bool border_undefined, BorderSize border_size) override;
+    ValidRegion compute_valid_region(const Window &window, ValidRegion input_valid_region, bool border_undefined, BorderSize border_size) const override;
 
     TensorInfo *_info;
     int         _start_x;

arm_compute/core/AccessWindowTranspose.h

@@ -41,8 +41,8 @@ class AccessWindowTranspose : public AccessWindowRectangle
     using AccessWindowRectangle::AccessWindowRectangle;
     bool update_window_if_needed(Window &window) const override;
     bool update_padding_if_needed(const Window &window) const override;
-    using AccessWindowRectangle::set_valid_region;
-    void set_valid_region(const Window &window, ValidRegion input_valid_region, bool border_undefined, BorderSize border_size) override;
+    using AccessWindowRectangle::compute_valid_region;
+    ValidRegion compute_valid_region(const Window &window, ValidRegion input_valid_region, bool border_undefined, BorderSize border_size) const override;
 };
 } // namespace arm_compute
 #endif /*__ARM_COMPUTE_IACCESS_WINDOW_TRANSPOSE_H__*/

arm_compute/core/CL/CLKernels.h

@@ -25,7 +25,6 @@
 #define __ARM_COMPUTE_CLKERNELS_H__
 
 /* Header regrouping all the CL kernels */
-
 #include "arm_compute/core/CL/kernels/CLAbsoluteDifferenceKernel.h"
 #include "arm_compute/core/CL/kernels/CLAccumulateKernel.h"
 #include "arm_compute/core/CL/kernels/CLActivationLayerKernel.h"
@@ -50,6 +49,7 @@
 #include "arm_compute/core/CL/kernels/CLFastCornersKernel.h"
 #include "arm_compute/core/CL/kernels/CLFillBorderKernel.h"
 #include "arm_compute/core/CL/kernels/CLGEMMInterleave4x4Kernel.h"
+#include "arm_compute/core/CL/kernels/CLGEMMLowpMatrixMultiplyKernel.h"
 #include "arm_compute/core/CL/kernels/CLGEMMMatrixAccumulateBiasesKernel.h"
 #include "arm_compute/core/CL/kernels/CLGEMMMatrixAdditionKernel.h"
 #include "arm_compute/core/CL/kernels/CLGEMMMatrixMultiplyKernel.h"

arm_compute/core/CL/ICLSimpleKernel.h

@@ -49,13 +49,13 @@ class ICLSimpleKernel : public ICLKernel
 
     /** Configure the kernel
      *
-     * @param[in]  input              Source tensor.
-     * @param[out] output             Destination tensor.
-     * @param[in]  processed_elements Number of processed elements per iteration.
-     * @param[in]  border_undefined   (Optional) True if the border mode is undefined. False if it's replicate or constant.
-     * @param[in]  border_size        (Optional) Size of the border.
+     * @param[in]  input                             Source tensor.
+     * @param[out] output                            Destination tensor.
+     * @param[in]  num_elems_processed_per_iteration Number of processed elements per iteration.
+     * @param[in]  border_undefined                  (Optional) True if the border mode is undefined. False if it's replicate or constant.
+     * @param[in]  border_size                       (Optional) Size of the border.
      */
-    void configure(const ICLTensor *input, ICLTensor *output, unsigned int processed_elements, bool border_undefined = false, const BorderSize &border_size = BorderSize());
+    void configure(const ICLTensor *input, ICLTensor *output, unsigned int num_elems_processed_per_iteration, bool border_undefined = false, const BorderSize &border_size = BorderSize());
 
 protected:
     const ICLTensor *_input;

arm_compute/core/CL/kernels/CLCannyEdgeKernel.h

@@ -47,32 +47,28 @@ class CLGradientKernel : public ICLKernel
      *
      * @note gx, gy and mag must all be the same size (either 16 or 32).
      *
-     * @param[in]  gx                     Source tensor - Gx component. Data types supported: S16/S32.
-     * @param[in]  gy                     Source tensor - Gy component. Data types supported: Same as gx.
-     * @param[out] magnitude              Destination tensor - Magnitude. Data types supported: U16/U32. Must match the pixel size of gx, gy.
-     * @param[out] phase                  Destination tensor - Quantized phase. Data types supported: U8.
-     * @param[in]  norm_type              Normalization type. if 1, L1-Norm otherwise L2-Norm.
-     * @param[in]  num_pixel_to_skip_prev Number of pixels to skip of previous stage if border_mode = UNDEFINED
-     * @param[in]  border_undefined       True if the border mode is undefined. False if it's replicate or constant.
+     * @param[in]  gx        Source tensor - Gx component. Data types supported: S16/S32.
+     * @param[in]  gy        Source tensor - Gy component. Data types supported: Same as gx.
+     * @param[out] magnitude Destination tensor - Magnitude. Data types supported: U16/U32. Must match the pixel size of gx, gy.
+     * @param[out] phase     Destination tensor - Quantized phase. Data types supported: U8.
+     * @param[in]  norm_type Normalization type. if 1, L1-Norm otherwise L2-Norm.
      */
-    void configure(const ICLTensor *gx, const ICLTensor *gy, ICLTensor *magnitude, ICLTensor *phase, int32_t norm_type, int32_t num_pixel_to_skip_prev, bool border_undefined);
+    void configure(const ICLTensor *gx, const ICLTensor *gy, ICLTensor *magnitude, ICLTensor *phase, int32_t norm_type);
 
     // Inherited methods overridden:
     void run(const Window &window, cl::CommandQueue &queue) override;
-    BorderSize border_size() const override;
 
 private:
-    const ICLTensor *_gx;             /**< Source tensor - Gx component */
-    const ICLTensor *_gy;             /**< Source tensor - Gy component */
-    ICLTensor       *_magnitude;      /**< Destination tensor - Magnitude */
-    ICLTensor       *_phase;          /**< Destination tensor - Quantized phase */
-    unsigned int     _pixels_to_skip; /**< Pixels to skip around the border. */
+    const ICLTensor *_gx;        /**< Source tensor - Gx component */
+    const ICLTensor *_gy;        /**< Source tensor - Gy component */
+    ICLTensor       *_magnitude; /**< Destination tensor - Magnitude */
+    ICLTensor       *_phase;     /**< Destination tensor - Quantized phase */
 };
 
 /** OpenCL kernel to perform Non-Maxima suppression for Canny Edge.
  *
  * @note This kernel is meant to be used alongside CannyEdge and performs a non-maxima suppression using magnitude and phase of input
- *       to characterize points as possible edges.
+ *       to characterize points as possible edges. The output buffer needs to be cleared before this kernel is executed.
  *
  * @note Hysteresis is computed in @ref CLEdgeTraceKernel
  */
@@ -87,24 +83,22 @@ class CLEdgeNonMaxSuppressionKernel : public ICLKernel
     CLEdgeNonMaxSuppressionKernel &operator=(const CLEdgeNonMaxSuppressionKernel &) = delete;
     /** Initialise the kernel's sources, destination and border mode.
      *
-     * @param[in]  magnitude              Source tensor - Magnitude. Data types supported: U16/U32.
-     * @param[in]  phase                  Source tensor - Quantized phase. Data types supported: U8.
-     * @param[out] output                 Destination tensor
-     * @param[in]  lower_thr              Lower threshold.
-     * @param[in]  num_pixel_to_skip_prev Number of pixels to skip of previous stage if border_mode = UNDEFINED
-     * @param[in]  border_undefined       True if the border mode is undefined. False if it's replicate or constant.
+     * @param[in]  magnitude        Source tensor - Magnitude. Data types supported: U16/U32.
+     * @param[in]  phase            Source tensor - Quantized phase. Data types supported: U8.
+     * @param[out] output           Destination tensor. Data types supported: U16/U32.
+     * @param[in]  lower_thr        Lower threshold.
+     * @param[in]  border_undefined True if the border mode is undefined. False if it's replicate or constant.
      */
-    void configure(const ICLTensor *magnitude, const ICLTensor *phase, ICLTensor *output, int32_t lower_thr, int32_t num_pixel_to_skip_prev, bool border_undefined);
+    void configure(const ICLTensor *magnitude, const ICLTensor *phase, ICLTensor *output, int32_t lower_thr, bool border_undefined);
 
     // Inherited methods overridden:
     void run(const Window &window, cl::CommandQueue &queue) override;
     BorderSize border_size() const override;
 
 private:
-    const ICLTensor *_magnitude;      /**< Source tensor - Magnitude. */
-    const ICLTensor *_phase;          /**< Source tensor - Quantized phase. */
-    ICLTensor       *_output;         /**< Destination tensor. */
-    unsigned int     _pixels_to_skip; /**< Pixels to skip around the border. */
+    const ICLTensor *_magnitude; /**< Source tensor - Magnitude. */
+    const ICLTensor *_phase;     /**< Source tensor - Quantized phase. */
+    ICLTensor       *_output;    /**< Destination tensor. */
 };
 
 /** OpenCL kernel to perform Edge tracing.
@@ -120,28 +114,24 @@ class CLEdgeTraceKernel : public ICLKernel
     CLEdgeTraceKernel &operator=(const CLEdgeTraceKernel &) = delete;
     /** Initialise the kernel's source, destination and border mode.
      *
-     * @param[in]              input                  Source tensor. Data types supported: U8.
-     * @param[out]             output                 Destination tensor. Data types supported: U8.
-     * @param[in]              upper_thr              Upper threshold used for the hysteresis
-     * @param[in]              lower_thr              Lower threshold used for the hysteresis
-     * @param[in,out]          visited                Tensor for keeping the visited pixels. Data types supported: U32.
-     *                                                Expected to be initialized to 0 before each run.
-     * @param[in,out]          recorded               Tensor for keeping the recorded pixels. Data types supported: U32
-     *                                                Expected to be initialized to 0 before each run.
-     * @param[in,out]          l1_stack               Tensor with the L1 stack for each pixel. Data types supported: S32.
-     *                                                Expected to be initialized to 0 before each run.
-     * @param[in,out]          l1_stack_counter       Tensor for counting the elements in the L1 stack of each pixel. Data types supported: U8.
-     *                                                Expected to be initialized to 0 before each run.
-     * @param[in]              num_pixel_to_skip_prev Number of pixels to skip of previous stage if border_mode = UNDEFINED.
-        public:   * @param[in] border_undefined       True if the border mode is undefined. False if it's replicate or constant.
+     * @param[in]     input            Source tensor. Data types supported: U8.
+     * @param[out]    output           Destination tensor. Data types supported: U8.
+     * @param[in]     upper_thr        Upper threshold used for the hysteresis
+     * @param[in]     lower_thr        Lower threshold used for the hysteresis
+     * @param[in,out] visited          Tensor for keeping the visited pixels. Data types supported: U32.
+     *                                 Expected to be initialized to 0 before each run.
+     * @param[in,out] recorded         Tensor for keeping the recorded pixels. Data types supported: U32
+     *                                 Expected to be initialized to 0 before each run.
+     * @param[in,out] l1_stack         Tensor with the L1 stack for each pixel. Data types supported: S32.
+     *                                 Expected to be initialized to 0 before each run.
+     * @param[in,out] l1_stack_counter Tensor for counting the elements in the L1 stack of each pixel. Data types supported: U8.
+     *                                              Expected to be initialized to 0 before each run.
      */
     void configure(const ICLTensor *input, ICLTensor *output, int32_t upper_thr, int32_t lower_thr,
-                   ICLTensor *visited, ICLTensor *recorded, ICLTensor *l1_stack, ICLTensor *l1_stack_counter,
-                   int32_t num_pixel_to_skip_prev, bool border_undefined);
+                   ICLTensor *visited, ICLTensor *recorded, ICLTensor *l1_stack, ICLTensor *l1_stack_counter);
 
     // Inherited methods overridden:
     void run(const Window &window, cl::CommandQueue &queue) override;
-    BorderSize border_size() const override;
 
 private:
     const ICLTensor *_input;            /**< Source tensor. */
@@ -152,7 +142,6 @@ class CLEdgeTraceKernel : public ICLKernel
     ICLTensor       *_recorded;         /**< Marks recorded elements */
     ICLTensor       *_l1_stack;         /**< L1 hysteris stack */
     ICLTensor       *_l1_stack_counter; /**< L1 hysteris stack counter */
-    unsigned int     _pixels_to_skip;   /**< Pixels to skip */
 };
 }
 #endif /* __ARM_COMPUTE_CLCANNYEDGEKERNEL_H__ */

arm_compute/core/CL/kernels/CLGaussianPyramidKernel.h

@@ -24,14 +24,14 @@
 #ifndef __ARM_COMPUTE_CLGAUSSIANPYRAMIDKERNEL_H__
 #define __ARM_COMPUTE_CLGAUSSIANPYRAMIDKERNEL_H__
 
-#include "arm_compute/core/CL/ICLKernel.h"
+#include "arm_compute/core/CL/ICLSimpleKernel.h"
 
 namespace arm_compute
 {
 class ICLTensor;
 
 /** OpenCL kernel to perform a Gaussian filter and half scaling across width (horizontal pass) */
-class CLGaussianPyramidHorKernel : public ICLKernel
+class CLGaussianPyramidHorKernel : public ICLSimpleKernel
 {
 public:
     /** Default constructor */
@@ -60,12 +60,12 @@ class CLGaussianPyramidHorKernel : public ICLKernel
     BorderSize border_size() const override;
 
 private:
-    const ICLTensor *_input;
-    ICLTensor       *_output;
+    BorderSize _border_size;
+    int        _l2_load_offset;
 };
 
 /** OpenCL kernel to perform a Gaussian filter and half scaling across height (vertical pass) */
-class CLGaussianPyramidVertKernel : public ICLKernel
+class CLGaussianPyramidVertKernel : public ICLSimpleKernel
 {
 public:
     /** Default constructor */
@@ -94,8 +94,7 @@ class CLGaussianPyramidVertKernel : public ICLKernel
     BorderSize border_size() const override;
 
 private:
-    const ICLTensor *_input;
-    ICLTensor       *_output;
+    int _t2_load_offset;
 };
 }
 #endif /*__ARM_COMPUTE_CLGAUSSIANPYRAMIDKERNEL_H__ */

arm_compute/core/CL/kernels/CLLKTrackerKernel.h

@@ -108,6 +108,16 @@ class CLLKTrackerFinalizeKernel : public ICLKernel
 class CLLKTrackerStage0Kernel : public ICLKernel
 {
 public:
+    /** Default constructor */
+    CLLKTrackerStage0Kernel();
+    /** Prevent instances of this class from being copied (As this class contains pointers) */
+    CLLKTrackerStage0Kernel(const CLLKTrackerStage0Kernel &) = delete;
+    /** Prevent instances of this class from being copied (As this class contains pointers) */
+    CLLKTrackerStage0Kernel &operator=(const CLLKTrackerStage0Kernel &) = delete;
+    /** Allow instances of this class to be moved */
+    CLLKTrackerStage0Kernel(CLLKTrackerStage0Kernel &&) = default;
+    /** Allow instances of this class to be moved */
+    CLLKTrackerStage0Kernel &operator=(CLLKTrackerStage0Kernel &&) = default;
     /** Initialise the kernel input and output
      *
      * @param[in]      old_input           Pointer to the input old tensor. Data types supported: U8
@@ -119,21 +129,35 @@ class CLLKTrackerStage0Kernel : public ICLKernel
      * @param[out]     old_ival            Pointer to the array holding internal values
      * @param[in]      window_dimension    The size of the window on which to perform the algorithm
      * @param[in]      level               The pyramid level
-     * @param[in]      border_offset       The offset used to define the boundary of the tracked pixels in different border modes
      */
     void configure(const ICLTensor *old_input, const ICLTensor *old_scharr_gx, const ICLTensor *old_scharr_gy,
                    ICLLKInternalKeypointArray *old_points_internal, ICLLKInternalKeypointArray *new_points_internal,
                    ICLCoefficientTableArray *coeff_table, ICLOldValArray *old_ival,
-                   size_t window_dimension, size_t level, int32_t border_offset);
+                   size_t window_dimension, size_t level);
 
     // Inherited methods overridden:
     void run(const Window &window, cl::CommandQueue &queue) override;
+
+private:
+    const ICLTensor *_old_input;
+    const ICLTensor *_old_scharr_gx;
+    const ICLTensor *_old_scharr_gy;
 };
 
 /** Interface to run the second stage of LKTracker, where the motion vectors of the given points are computed */
 class CLLKTrackerStage1Kernel : public ICLKernel
 {
 public:
+    /** Default constructor */
+    CLLKTrackerStage1Kernel();
+    /** Prevent instances of this class from being copied (As this class contains pointers) */
+    CLLKTrackerStage1Kernel(const CLLKTrackerStage1Kernel &) = delete;
+    /** Prevent instances of this class from being copied (As this class contains pointers) */
+    CLLKTrackerStage1Kernel &operator=(const CLLKTrackerStage1Kernel &) = delete;
+    /** Allow instances of this class to be moved */
+    CLLKTrackerStage1Kernel(CLLKTrackerStage1Kernel &&) = default;
+    /** Allow instances of this class to be moved */
+    CLLKTrackerStage1Kernel &operator=(CLLKTrackerStage1Kernel &&) = default;
     /** Initialise the kernel input and output
      *
      * @param[in]      new_input           Pointer to the input new tensor. Data types supported: U8
@@ -145,13 +169,15 @@ class CLLKTrackerStage1Kernel : public ICLKernel
      * @param[in]      num_iterations      The maximum number of iterations before terminating the algorithm
      * @param[in]      window_dimension    The size of the window on which to perform the algorithm
      * @param[in]      level               The pyramid level
-     * @param[in]      border_offset       The offset used to define the boundary of the tracked pixels in different border modes
      */
     void configure(const ICLTensor *new_input, ICLLKInternalKeypointArray *new_points_internal, ICLCoefficientTableArray *coeff_table, ICLOldValArray *old_ival,
-                   Termination termination, float epsilon, size_t num_iterations, size_t window_dimension, size_t level, int32_t border_offset);
+                   Termination termination, float epsilon, size_t num_iterations, size_t window_dimension, size_t level);
 
     // Inherited methods overridden:
     void run(const Window &window, cl::CommandQueue &queue) override;
+
+private:
+    const ICLTensor *_new_input;
 };
 }
 #endif /*__ARM_COMPUTE_CLLKTRACKERKERNEL_H__ */