conv cs interface update

Author: yaroslav

include/api/mli_ref_compiler_api.hpp

@@ -35,7 +35,9 @@ class Conv2d_CS : public lib_mli::Conv2d_CS {
      * of all values in the related perception area of all channels of the input tensor.
      *
      * @deprected
+     * Be carefull - you need to use another deprected method to set tiling - SetIterators
      * Be carefull - conv2d I/O tensors of rank 4 are deprecated - new interfaces use rank 5 
+     * Be carefull - this is the most deprecated Constructor
      *
      * @param pd [IN] Platform description
      * @param in [IN] input tensor (full shape, BHWCi layout)
@@ -51,6 +53,7 @@ class Conv2d_CS : public lib_mli::Conv2d_CS {
 
     /**
       * @brief Constructor to create an Conv2d_CS compiler support object.
+      * @deprecated
       *
       * This constructor can be used to create a Convolution 2D compiler support
       * object. This kernel computes each value of the output tensor as the result of convolution operation
@@ -75,36 +78,52 @@ class Conv2d_CS : public lib_mli::Conv2d_CS {
       * @brief Constructor to create an Conv2d_CS compiler support object.
       *
       * This constructor can be used to create a Convolution 2D compiler support
-      * object. This kernel computes each value of the output tensor as the result of convolution operation
+      * object. This kernel computes each value of the output as the result of convolution operation
       * of input with weights.
       *
       * @param pd          [I] Platform description
       * @param input       [I] Input TensorIterator (BHWGCi layout)
-      * @param input_zp    [I] input_zp TensorIterator
-      * @param weights     [I] weights TensorIterator (GKyKxCiCo layout)
-      * @param weights_zp  [I] weights_zp TensorIterator
-      * @param cfg         [I] Conv2DConfig structure
-      * @param output      [I] output TensorIterator (BHWGCo layout)
+      * @param input_zp    [I] Input zero point(s) TensorIterator
+      * @param weights     [I] Weights TensorIterator (GKyKxCiCo layout)
+      * @param weights_zp  [I] Weights zero point(s) TensorIterator
+      * @param cfg         [I] Conv2DConfig structure with conv parameters (stride, dilation, paddings)
+      * @param output      [I] Output TensorIterator (BHWGCo layout)
       */
     Conv2d_CS(const lib_mli::PlatformDescription pd,
               const TensorIterator<NoBuffer, kConvIORank, kConvIterRank> &input,
               const TensorIterator<NoBuffer, kConvZPRank, kConvIterRank> &input_zp,
               const TensorIterator<NoBuffer, kConvWRank,  kConvIterRank> &weights,
               const TensorIterator<NoBuffer, kConvZPRank, kConvIterRank> &weights_zp,
               const Conv2DConfig &cfg,
-              const TensorIterator<NoBuffer, kConvIORank, kConvIterRank> &output) { NOT_IMPLEMENTED_METHOD; };
+              const TensorIterator<NoBuffer, kConvIORank, kConvIterRank> &output);
 
+    /**
+     * @deprecated
+     */
     mli_status EncodeWeights(Tensor<Buffer, kConvWRank> &weights,
                              Buffer &encoded_weights,
                              compression_mode_t mode = compression_mode_t::Uncompressed) override;
 
+    mli_status EncodeWeightsAndZeroPts(TensorIterator<Buffer, kConvWRank, kConvIterRank>& weights,
+                                       TensorIterator<Buffer, kConvZPRank, kConvIterRank>& weights_zp,
+                                       Buffer& encoded_weights) override;
+
     unsigned GetEncodedWeightsSize() override;
 
+    /**
+     * @deprecated
+     */
     mli_status EncodeInpZeroPts(Tensor<Buffer, kInpZPRank> &inpzeropts,
                                 Buffer &encoded_inpzeropts) override;
 
+    mli_status EncodeInpZeroPts(TensorIterator<Buffer, kConvZPRank, kConvZPIterRank>& input_zp,
+                                Buffer& encoded_inpzeropts) override;
+
     unsigned GetEncodedInpZeroPtsSize() override;
 
+    /**
+     * @deprecated
+     */
     mli_status EncodeWtsZeroPts(Tensor<Buffer, kConvZPRank> &wtszeropts,
                                 Buffer &encoded_wtszeropts) override;
 
@@ -148,7 +167,8 @@ class Conv2d_CS : public lib_mli::Conv2d_CS {
 
     /**
      * @deprecated
-     * Be carefull - conv2d I/O tensors of rank 4 are deprecated - new interfaces use rank 5 
+     * Be carefull - conv2d I/O tensors of rank 4 are deprecated - new interfaces use rank 5
+     * Be carefull - don't use this method with new Conv2d_CS ctors - only with deprecated ctor that takes tensors
      */
     mli_status SetIterators(uint32_t output_total_size[4],
                             uint32_t iteration_order[4],
@@ -191,6 +211,7 @@ class DepthwiseConv2d_CS : public lib_mli::DepthwiseConv2d_CS {
      * @deprecated
      * Be carefull - this ctor doesn't support tiling - only single tile size of provided tensors
      * Be carefull - depthwise conv2d I/O tensors of rank 4 are deprecated - new interfaces use rank 5
+     * Be carefull - this is the most deprecated Constructor
      */
     DepthwiseConv2d_CS(const lib_mli::PlatformDescription pd,
                        const Tensor<NoBuffer, 4> &in,
@@ -200,6 +221,7 @@ class DepthwiseConv2d_CS : public lib_mli::DepthwiseConv2d_CS {
 
     /**
      * @brief Constructor of the DepthwiseConv2d_CS object
+     * @deprecated
      */
     DepthwiseConv2d_CS(const lib_mli::PlatformDescription pd,
                        const TensorIterator<NoBuffer, kDepthwiseIORank, kDepthwiseIterRank>& input,
@@ -229,19 +251,35 @@ class DepthwiseConv2d_CS : public lib_mli::DepthwiseConv2d_CS {
                        const TensorIterator<NoBuffer, kDepthwiseWRank,  kDepthwiseIterRank> &weights,
                        const TensorIterator<NoBuffer, kDepthwiseZPRank, kDepthwiseIterRank> &weights_zp,
                        const DwConv2DConfig &cfg,
-                       const TensorIterator<NoBuffer, kDepthwiseIORank, kDepthwiseIterRank> &output) { NOT_IMPLEMENTED_METHOD; };
+                       const TensorIterator<NoBuffer, kDepthwiseIORank, kDepthwiseIterRank> &output);
 
+    /**
+      * @deprecated
+      */
     mli_status EncodeWeights(Tensor<Buffer, kDepthwiseWRank> &weights,
                              Buffer &encoded_weights,
                              compression_mode_t mode = compression_mode_t::Uncompressed) override;
 
+    mli_status EncodeWeightsAndZeroPts(TensorIterator<Buffer, kDepthwiseWRank, kDepthwiseIterRank>& weights,
+                                       TensorIterator<Buffer, kDepthwiseZPRank, kDepthwiseIterRank>& weights_zp,
+                                       Buffer& encoded_weights) override;
+
     unsigned GetEncodedWeightsSize() override;
 
+    /**
+      * @deprecated
+      */
     mli_status EncodeInpZeroPts(Tensor<Buffer, kDepthwiseZPRank> &inpzeropts,
                                 Buffer &encoded_inpzeropts) override;
 
+    mli_status EncodeInpZeroPts(TensorIterator<Buffer, kDepthwiseZPRank, kDepthwiseIterRank>& input_zp,
+                                Buffer& encoded_input_zp) override;
+
     unsigned GetEncodedInpZeroPtsSize() override;
 
+    /**
+      * @deprecated
+      */
     mli_status EncodeWtsZeroPts(Tensor<Buffer, kDepthwiseZPRank> &wtszeropts,
                                 Buffer &encoded_wtszeropts) override;
 

include/mli_compiler_api.hpp

@@ -126,15 +126,15 @@ class Conv2d_CS : public CompilerGenericInterface {
 public:
     /**
      * @brief Method to encode the weights (coefficients)
-     *
+     * @deprecated
      * This method will read the weights buffer in a platform independent layout
      * and translate it into a buffer that can be easily read by the platform specific
      * kernel implementation.
      * This transformation may include compression
      * The content of the encode_weights buffer is opaque for the user.
      *
-     * @param weights [I] tensor with the weights
-     * @param buffer_t[I] buffer pointer where the encode function can write the encoded weights
+     * @param weights         [I] tensor with the weights
+     * @param encoded_weights [I] buffer where the encode function write the encoded weights
      *
      * TODO: how to handle sliding in the output channel dimension? is this weights encoding for the complete 'thing' or just for this slide?
      */
@@ -171,7 +171,7 @@ class Conv2d_CS : public CompilerGenericInterface {
 
     /**
      * @brief Method to encode input zero-points (padding values)
-     *
+     * @deprecated
      * This method will read the input zero-points buffer in a platform independent layout
      * and translate it into a buffer that can be easily read by the platform specific
      * kernel implementation.
@@ -205,7 +205,7 @@ class Conv2d_CS : public CompilerGenericInterface {
 
     /**
      * @brief Method to encode weights zero-points (padding values)
-     *
+     * @deprecated
      * This method will read the weights zero-points buffer in a platform independent layout
      * and translate it into a buffer that can be easily read by the platform specific
      * kernel implementation.
@@ -298,8 +298,9 @@ class Conv2d_CS : public CompilerGenericInterface {
      * NOTE: the use of this method is optional. if there is a single tile, and the .Update() is not used,
      *       this data doesn't need to be set.     
      * All the increments are following the output tile iterator.
-     * 
      * @deprecated
+     * Be carefull - don't use this method with new Conv2d_CS ctors - only with deprecated ctor that takes tensors
+     *
      * @param output_total_size[4] [I] total size in each dimension
      * @param iteration_order[4] [I] which dimension of the output to iterate first.
      * @param input_first_inc[4] [I] increment of the input buffer pointer for the first iteration in each dimension
@@ -444,6 +445,7 @@ class DepthwiseConv2d_CS : public CompilerGenericInterface {
 
     /**
      * @brief Method to encode the weights (coefficients).
+     * @deprecated
      * TODO: add description using conv2d_cs as a starting point
      */
     virtual mli_status EncodeWeights(Tensor<Buffer, kDepthwiseWRank> &weights,
@@ -476,7 +478,7 @@ class DepthwiseConv2d_CS : public CompilerGenericInterface {
 
     /**
      * @brief Method to encode input zero-points (padding values)
-     *
+     * @deprecated
      */
     virtual mli_status EncodeInpZeroPts(Tensor<Buffer, kDepthwiseZPRank> &inpzeropts,
                                         Buffer &encoded_inpzeropts) = 0;
@@ -505,7 +507,7 @@ class DepthwiseConv2d_CS : public CompilerGenericInterface {
 
     /**
      * @brief Method to encode weights zero-points
-     *
+     * @deprecated
      */
     virtual mli_status EncodeWtsZeroPts(Tensor<Buffer, kDepthwiseZPRank> &wtszeropts,
                                         Buffer &encoded_wtszeropts) { return MLI_STATUS_OK; }

include/mli_kernels_factory.hpp

@@ -104,7 +104,8 @@ class KernelsFactory {
     /**
      * @brief Convolution 2D kernel Compiler Support interface factory
      * method
-     *
+     * @deprecated
+     * 
      * @param kernel_buffer [I] Pointer to the pre-allocated memory to store
      *                          kernel Compiler Support object
      * @param input         [I] TensorIterator object containing input Tensor shape and
@@ -127,6 +128,34 @@ class KernelsFactory {
       return nullptr;
     }
 
+    /**
+      * @brief Convolution 2D kernel Compiler Support interface factory
+      * method
+      *
+      * @param kernel_buffer [I] Pointer to the pre-allocated memory to store
+      *                          kernel Compiler Support object
+      * @param input         [I] TensorIterator object containing input Tensor shape and
+      *                          memory strides and IteratorCfg
+      * @param input_zp      [I] TensorIterator object containing input zp(s) array
+      * @param weights       [I] TensorIterator object containing weights Tensor shape
+      *                          and memory strides and IteratorCfg
+      * @param weights_zp    [I] TensorIterator object containing weight zp(s) array
+      * @param cfg           [I] Kernel configuration structure
+      * @param output        [I] TensorIterator object containing output Tensor shape
+      *                          and memory strides and IteratorCfg
+      *
+      * @return Convolution 2D kernel Compiler Support interface object
+      */
+    virtual lib_mli::Conv2d_CS* Conv2d_CS(void* kernel_buffer,
+                                          const TensorIterator<NoBuffer, kConvIORank, kConvIOIterRank>& input,      // BHWGCi
+                                          const TensorIterator<NoBuffer, kConvZPRank, kConvZPIterRank>& input_zp,
+                                          const TensorIterator<NoBuffer, kConvWRank, kConvWIterRank>& weights,      // GKyKxCiCo
+                                          const TensorIterator<NoBuffer, kConvZPRank, kConvZPIterRank>& weights_zp, // Co tensor, GKyKxCiCo iterator
+                                          const Conv2DConfig& cfg,
+                                          const TensorIterator<NoBuffer, kConvIORank, kConvIOIterRank>& output) {   // BHWGCo
+      return nullptr;
+    }
+
     /**
      * @brief Convolution 2D kernel Compiler Support interface
      *        to get the Alignment Restrictions in Input Tensor.
@@ -411,7 +440,7 @@ class KernelsFactory {
       * @deprecated
       * Be carefull - this factory method doesn't support tiling - only single tile size of provided tensors
       * Be carefull - depthwise conv2d I/O tensors of rank 4 are deprecated - new interfaces use rank 5 
-      * 
+      * Be carefull - this is the most deprecated factory method for DepthwiseConv2d_CS
       * @param kernel_buffer       [I] Pointer to the pre-allocated memory to store
       *                                kernel Compiler Support object
       * @param in                  [I] Tensor object containing input Tensor shape and
@@ -436,6 +465,7 @@ class KernelsFactory {
      * @brief Depthwise Convolution 2D kernel Compiler Support interface factory
      * method
      *
+     * @deprecated
      * @param kernel_buffer [I] Pointer to the pre-allocated memory to store
      *                          kernel Compiler Support object
      * @param input         [I] TensorIterator object containing input Tensor shape and
@@ -458,6 +488,35 @@ class KernelsFactory {
       return nullptr;
     }
 
+    /**
+     * @brief Depthwise Convolution 2D kernel Compiler Support interface factory
+     * method
+     *
+     * @param kernel_buffer [I] Pointer to the pre-allocated memory to store
+     *                          kernel Compiler Support object
+     * @param input         [I] TensorIterator object containing input Tensor shape and
+     *                          memory strides and IteratorCfg
+     * @param input_zp      [I] TensorIterator object containing input zp(s) Tensor shape and
+     *                          memory strides and IteratorCfg
+     * @param weights       [I] TensorIterator object containing weights Tensor shape
+     *                          and memory strides and IteratorCfg
+     * @param weights_zp    [I] TensorIterator object containing weight zp(s) array
+     * @param cfg           [I] Kernel configuration structure
+     * @param output        [I] TensorIterator object containing output Tensor shape
+     *                          and memory strides and IteratorCfg
+     *
+     * @return Depthwise Convolution 2D kernel Compiler Support interface object
+     */
+    virtual lib_mli::DepthwiseConv2d_CS* DepthwiseConv2d_CS(void* kernel_buffer,
+                                                            const TensorIterator<NoBuffer, kDepthwiseIORank, kDepthwiseIterRank>& input,      // BHWGC
+                                                            const TensorIterator<NoBuffer, kDepthwiseZPRank, kDepthwiseIterRank>& input_zp,
+                                                            const TensorIterator<NoBuffer, kDepthwiseWRank, kDepthwiseIterRank>& weights,     // KiKoC
+                                                            const TensorIterator<NoBuffer, kDepthwiseZPRank, kDepthwiseIterRank>& weights_zp, // C
+                                                            const DwConv2DConfig& cfg,
+                                                            const TensorIterator<NoBuffer, kDepthwiseIORank, kDepthwiseIterRank>& output) {   // BHWGC
+      return nullptr;
+    }
+
     /**
      * @brief Depthwise Convolution 2D kernel Compiler Support interface
      *        to get the Alignment Restrictions in Input Tensor.