nnfw::cker::depthwise_conv_op::DepthwiseConv2DKernel< T > Struct Template Reference

#include <depthwise_conv_op.h>

Static Public Member Functions
static void	Run (int filter_rows, int filter_cols, int out_cols, int out_depth, const int64_t padded_filter_inner_dim_size, const int64_t out_r, const int64_t out_c, const T *filter, const T *input_buffer, T *output)

Detailed Description

template<typename T>
struct nnfw::cker::depthwise_conv_op::DepthwiseConv2DKernel< T >

Definition at line 362 of file depthwise_conv_op.h.

Member Function Documentation

Run()

template<typename T >

static void nnfw::cker::depthwise_conv_op::DepthwiseConv2DKernel< T >::Run ( int  filter_rows, int  filter_cols, int  out_cols, int  out_depth, const int64_t  padded_filter_inner_dim_size, const int64_t  out_r, const int64_t  out_c, const T *  filter, const T *  input_buffer, T *  output  )

inlinestatic

Definition at line 364 of file depthwise_conv_op.h.

  {
    typedef typename Eigen::internal::packet_traits<T>::type Packet;
    static const int64_t kPacketSize = (sizeof(Packet) / sizeof(T));
 
    const int64_t filter_spatial_size = static_cast<int64_t>(filter_rows) * filter_cols;
    const int64_t output_scalar_size = out_depth % kPacketSize;
    const int64_t output_vectorized_size = (out_depth / kPacketSize) * kPacketSize;
    const int64_t base_output_index = (out_r * out_cols + out_c) * out_depth;
 
    for (int i = 0; i < output_vectorized_size; i += kPacketSize)
    {
      // Reset accumulator.
      auto vaccum = Eigen::internal::pset1<Packet>(static_cast<T>(0));
      for (int j = 0; j < filter_spatial_size; ++j)
      {
        // Calculate index.
        const int64_t index = i + j * padded_filter_inner_dim_size;
        // Load filter.
        // TODO(andydavis) Unroll 'out_c' loop in caller so we can load
        // multiple inputs here to amortize the cost of each filter block load.
        const auto filter_block = Eigen::internal::ploadu<Packet>(filter + index);
        // Load input.
        const auto data_block = Eigen::internal::ploadu<Packet>(input_buffer + index);
        // Vector multiply-add.
        vaccum = Eigen::internal::pmadd<Packet>(filter_block, data_block, vaccum);
      }
      // Store vector accumulator to output.
      Eigen::internal::pstoreu<T>(output + base_output_index + i, vaccum);
    }
 
    if (output_scalar_size > 0)
    {
      auto vaccum = Eigen::internal::pset1<Packet>(static_cast<T>(0));
      for (int j = 0; j < filter_spatial_size; ++j)
      {
        const int64_t index = output_vectorized_size + j * padded_filter_inner_dim_size;
        const auto filter_block = Eigen::internal::ploadu<Packet>(filter + index);
        const auto data_block = Eigen::internal::ploadu<Packet>(input_buffer + index);
        vaccum = Eigen::internal::pmadd<Packet>(filter_block, data_block, vaccum);
      }
      // Load accumulator into an array and loop through output.
      T out_buf[kPacketSize];
      Eigen::internal::pstoreu<T>(out_buf, vaccum);
      const int64_t last_output_index = base_output_index + output_vectorized_size;
      for (int j = 0; j < output_scalar_size; ++j)
      {
        output[last_output_index + j] = out_buf[j];
      }
    }
  }

Referenced by nnfw::cker::depthwise_conv_op::LaunchDepthwiseConvOp< CPUDevice, T >::operator()().

---

The documentation for this struct was generated from the following file:

• compute/cker/include/cker/eigen/depthwise_conv_op.h