Add a padding operator.

.gitignore

@@ -1,3 +1,6 @@
+tags
 build/
-experiments/
-smaug/operators/padding_op_test.h
+*.pyc
+__pycache__
+*.swp
+*.swo

smaug/core/backend.cpp

@@ -114,11 +114,11 @@ DEF_CREATE_OP(PaddingOp, SmvBackend)
 
 // for simple tracing.
 namespace ref {
-const unsigned kConvolutionHw = 0x0001;   // 0x0001;
-const unsigned kInnerProductHw = 0x0001;  // 0x0002;
-const unsigned kEltwiseOpHw = 0x0001;     // 0x0003;
-const unsigned kBatchNormHw = 0x0001;     // 0x0004;
-const unsigned kPoolingHw = 0x0001;       // 0x0005;
+const unsigned kConvolutionHw = 0x0001;
+const unsigned kInnerProductHw = 0x0002;
+const unsigned kEltwiseOpHw = 0x0003;
+const unsigned kBatchNormHw = 0x0004;
+const unsigned kPoolingHw = 0x0005;
 }  // namespace ref
 
 namespace smv {

smaug/core/network_builder.cpp

@@ -264,9 +264,9 @@ static void createAndAddOperator(const NodeProto& node,
     } else if (type == OpType::Tanh) {
         auto op = Backend::createTanhOp(name, workspace);
         network->addOperator(op);
-    } else if (type == OpType::Padding) {  // how to set this
+    } else if (type == OpType::Padding) {
         auto op = Backend::createPaddingOp(name, workspace);
-        op->setPadder(node.params().padding_params().padding_size());
+        op->setPaddingSize(node.params().padding_params().padding_size());
         network->addOperator(op);
     } else if (type == OpType::HardTanh) {
         auto op = Backend::createHardTanhOp(name, workspace);

smaug/core/node.proto

@@ -16,7 +16,7 @@ message PoolParams {
 }
 
 message PaddingParams {
-  int32 padding_size = 1;
+  repeated int32 padding_size = 1;
 }
 
 message ConcatParams {

smaug/core/types.proto

@@ -3,80 +3,80 @@ syntax = "proto3";
 package smaug;
 
 enum DataType {
-    UnknownDataType = 0;
-    Int32 = 1;
-    Int64 = 2;
-    Float16 = 3;
-    Float32 = 4;
-    Float64 = 5;
-    Bool = 6;
+  UnknownDataType = 0;
+  Int32 = 1;
+  Int64 = 2;
+  Float16 = 3;
+  Float32 = 4;
+  Float64 = 5;
+  Bool = 6;
 }
 
 enum DataLayout {
-    option allow_alias = true;
-    UnknownLayout = 0;
-    NCHW = 1;
-    NHWC = 2;
-    NC = 4;
-    CN = 8;
-    NCT = 16;
-    NTC = 32;
-    N = 64;
-    X = 127;  // Elementwise
-    EndDataLayout = 64;
+  option allow_alias = true;
+  UnknownLayout = 0;
+  NCHW = 1;
+  NHWC = 2;
+  NC = 4;
+  CN = 8;
+  NCT = 16;
+  NTC = 32;
+  N = 64;
+  X = 127;  // Elementwise
+  EndDataLayout = 64;
 }
 
 enum DataStorageFormat {
-    UnknownStorageFormat = 0;
-    Uncompressed = 1;
-    CSR = 2;
-    PackedCSR = 3;
-    UncompressedHalfPrecision = 4;
+  UnknownStorageFormat = 0;
+  Uncompressed = 1;
+  CSR = 2;
+  PackedCSR = 3;
+  UncompressedHalfPrecision = 4;
 }
 
 enum OpType {
-    UnknownOp = 0;
-    Convolution3d = 1;
-    ConvolutionDepthwise = 2;
-    MaxPooling = 3;
-    AveragePooling = 4;
-    InnerProduct = 5;
-    BatchNorm = 6;
-    Data = 7;
-    ReLU = 8;
-    LReLU = 9;
-    ELU = 10;
-    SELU = 11;
-    Tanh = 12;
-    HardTanh = 13;
-    Sigmoid = 14;
-    Softmax = 15;
-    EltwiseAdd = 16;
-    Reorder = 17;
-    EltwiseMul = 18;
-    Concat = 19;
-    Split = 20;
-    Reshape = 21;
-    Repeat = 22;
-    Less = 23;
-    LessEqual = 24;
-    Greater = 25;
-    GreaterEqual = 26;
-    Switch = 27;
-    Merge = 28;
-    Padding = 29;
+  UnknownOp = 0;
+  Convolution3d = 1;
+  ConvolutionDepthwise = 2;
+  MaxPooling = 3;
+  AveragePooling = 4;
+  InnerProduct = 5;
+  BatchNorm = 6;
+  Data = 7;
+  ReLU = 8;
+  LReLU = 9;
+  ELU = 10;
+  SELU = 11;
+  Tanh = 12;
+  HardTanh = 13;
+  Sigmoid = 14;
+  Softmax = 15;
+  EltwiseAdd = 16;
+  Reorder = 17;
+  EltwiseMul = 18;
+  Concat = 19;
+  Split = 20;
+  Reshape = 21;
+  Repeat = 22;
+  Less = 23;
+  LessEqual = 24;
+  Greater = 25;
+  GreaterEqual = 26;
+  Switch = 27;
+  Merge = 28;
+  Padding = 29;
 }
 
 enum PaddingType {
-    UnknownPadding = 0;
-    SamePadding = 1;
-    ValidPadding = 2;
+  UnknownPadding = 0;
+  SamePadding = 1;
+  ValidPadding = 2;
 }
 
 enum HostMemoryAccessPolicy {
-    UnknownMemoryPolicy = 0;
-    AllDma = 1;
-    AllAcp = 2;
-    AllCache = 3;
-    AllAcpWithDmaForWeights = 4;
+  UnknownMemoryPolicy = 0;
+  AllDma = 1;
+  AllAcp = 2;
+  AllCache = 3;
+  AllAcpWithDmaForWeights = 4;
 }

smaug/operators/padding_op.h

@@ -4,13 +4,14 @@
 #include "smaug/core/backend.h"
 #include "smaug/core/operator.h"
 #include "smaug/core/tensor.h"
-// #include "smaug/core/tensor_utils.h"
 #include "smaug/core/workspace.h"
+#include <google/protobuf/repeated_field.h>
+using namespace google::protobuf;
 
 namespace smaug {
 
 /** \ingroup Operators
- * \brief Pad a given tensor in different dimension.
+ * \brief Pad a given tensor in  any number of dimensions with arbitrary size.
  *
  * This has a software-based implementation.
  *
@@ -19,95 +20,77 @@ namespace smaug {
 template <typename Backend>
 class PaddingOp : public Operator {
    public:
-    PaddingOp(const std::string& name,
-              Workspace* workspace)
-            : Operator(name, OpType::Repeat, workspace){
+    PaddingOp(const std::string& name, Workspace* workspace)
+            : Operator(name, OpType::Padding, workspace) {
         inputs.resize(kNumInputs, nullptr);
         outputs.resize(kNumOutputs, nullptr);
     }
 
-    PaddingOp(const std::string& name,
-              Workspace* workspace,
-              int val)
-            : Operator(name, OpType::Repeat, workspace), padder(val){
-        inputs.resize(kNumInputs, nullptr);
-        outputs.resize(kNumOutputs, nullptr);
+    /**
+     * Set the paddingSize of the Tensor along each dimension.
+     * The paddingSize is orgainized as <dim1_forward, dim1_backward, ...
+     * ,dimk_backward>
+     */
+    void setPaddingSize(RepeatedField<google::protobuf::int32> const& val) {
+        paddingSize.assign(val.begin(), val.end());
     }
 
-    /** Set the number of padders of the Tensor along each dimension. */
-    void setPadder(const int& val) {
-        padder = val;
-        // set output size?
-    }
+    void setPaddingSize(std::vector<int> const& val) { paddingSize = val; }
 
-    int getPadder() { return padder; }
+    std::vector<int> getPaddingSize() const { return paddingSize; }
 
     void run() override {
-      Tensor* input = getInput(0);
-      Tensor* output = getOutput(0);
-      int ndims = input->ndims();
-      std::vector<int> inputDims = input->getShape().dims();
-      std::vector<int> outputDims = output->getShape().dims();
-      int total_dim = 1;
-      for (int i: outputDims){
-        total_dim *= i;
-      }
-      std::vector<float> vf(total_dim, 0);
-      output->fillData(vf.data(), vf.size());
-      /*
-      copyTensorRegion(Tensor* dest,
-                      Tensor* src,
-                      const std::vector<int>& destOrigin,
-                      const std::vector<int>& srcOrigin,
-                      const std::vector<int>& regionSize
-      */
-      std::vector<int> destOrigin;
-      if (input->getShape().getLayout() == DataLayout::NCHW){
-        destOrigin = std::vector<int>({0, 0, padder, padder});
-      }
-      else if(input->getShape().getLayout() == DataLayout::NHWC){
-        destOrigin = std::vector<int>({0, padder, padder, 0});
-      }
-      else{
-        assert(false && "Invalid padding data type!");
-      }
-      std::vector<int> srcOrigin = std::vector<int>({0, 0, 0, 0});
-      std::vector<int> regionSize = inputDims;
-      copyTensorRegion(output, input, destOrigin, srcOrigin, regionSize);
+        Tensor* input = getInput(0);
+        Tensor* output = getOutput(0);
+        int ndims = input->ndims();
+        const std::vector<int> inputDims = input->getShape().dims();
+        const std::vector<int> outputDims = output->getShape().dims();
+        int total_dim = 1;
+        for (int i : outputDims) {
+            total_dim *= i;
+        }
+        std::vector<float> vf(total_dim, 0);
+        output->fillData(vf.data(), vf.size());
+        std::vector<int> destOrigin, paddingBegin, srcOrigin;
+        for (int i = 0; i < ndims; i++) {
+            paddingBegin.push_back(paddingSize[2 * i]);
+            srcOrigin.push_back(0);
+        }
+        destOrigin = std::vector<int>(paddingBegin);
+        std::vector<int> regionSize = inputDims;
+        copyTensorRegion(output, input, destOrigin, srcOrigin, regionSize);
     }
 
     // Optional override for testing purposes.
     void createAllTensors() override {
         Tensor* input = getInput(0);
+        int ndims = input->ndims();
         std::vector<int> dims = input->getShape().dims();
-        if (input->getShape().getLayout() == DataLayout::NCHW){
-          dims[2] += 2*padder;
-          dims[3] += 2*padder;
-        }
-        else if (input->getShape().getLayout() == DataLayout::NHWC){
-          dims[1] += 2*padder;
-          dims[2] += 2*padder;
+        for (int i = 0; i < ndims; i++) {
+            dims[i] += (paddingSize[2 * i] + paddingSize[2 * i + 1]);
         }
         TensorShape shape(
                 dims, input->getShape().getLayout(), Backend::Alignment);
         Tensor* output = new Tensor(name, shape);
         workspace->addTensor(output);
         outputs.at(0) = output;
-     }
+    }
 
     // Optional but recommended function to verify operator parameters.
     bool validate() override {
-      if (padder < 0){
-        return false;
-      }
+        Tensor* input = getInput(0);
+        int ndims = input->ndims();
+        if (paddingSize.size() != 2 * ndims) {
+            return false;
+        }
         return Operator::validate();
     }
-    
+
     enum { kInputs, kNumInputs };
     enum { kOutputs, kNumOutputs };
 
-  private:
-    int padder = 0;
+   private:
+    std::vector<int> paddingSize = {};
 };
 
 }  // namespace smaug