refactor mace/ops code style

mace/ops/activation_benchmark.cc

@@ -19,7 +19,7 @@ static void ReluBenchmark(
   net.AddRandomInput<D, float>("Input", {batch, height, width, channels});
 
   if (D == DeviceType::OPENCL) {
-    BufferToImage<D, float>(net, "Input", "InputImage",
+    BufferToImage<D, float>(&net, "Input", "InputImage",
                             kernels::BufferType::IN_OUT_CHANNEL);
 
     OpDefBuilder("Activation", "ReluBM")
@@ -79,7 +79,7 @@ static void ReluxBenchmark(
   net.AddRandomInput<D, float>("Input", {batch, height, width, channels});
 
   if (D == DeviceType::OPENCL) {
-    BufferToImage<D, float>(net, "Input", "InputImage",
+    BufferToImage<D, float>(&net, "Input", "InputImage",
                             kernels::BufferType::IN_OUT_CHANNEL);
 
     OpDefBuilder("Activation", "ReluxBM")
@@ -142,9 +142,9 @@ static void PreluBenchmark(
   net.AddRandomInput<D, float>("Alpha", {channels});
 
   if (D == DeviceType::OPENCL) {
-    BufferToImage<D, float>(net, "Input", "InputImage",
+    BufferToImage<D, float>(&net, "Input", "InputImage",
                             kernels::BufferType::IN_OUT_CHANNEL);
-    BufferToImage<D, float>(net, "Alpha", "AlphaImage",
+    BufferToImage<D, float>(&net, "Alpha", "AlphaImage",
                             kernels::BufferType::ARGUMENT);
 
     OpDefBuilder("Activation", "PreluBM")
@@ -206,7 +206,7 @@ static void TanhBenchmark(
   net.AddRandomInput<D, float>("Input", {batch, height, width, channels});
 
   if (D == DeviceType::OPENCL) {
-    BufferToImage<D, float>(net, "Input", "InputImage",
+    BufferToImage<D, float>(&net, "Input", "InputImage",
                             kernels::BufferType::IN_OUT_CHANNEL);
 
     OpDefBuilder("Activation", "TanhBM")
@@ -266,7 +266,7 @@ static void SigmoidBenchmark(
   net.AddRandomInput<D, float>("Input", {batch, height, width, channels});
 
   if (D == DeviceType::OPENCL) {
-    BufferToImage<D, float>(net, "Input", "InputImage",
+    BufferToImage<D, float>(&net, "Input", "InputImage",
                             kernels::BufferType::IN_OUT_CHANNEL);
 
     OpDefBuilder("Activation", "SigmoidBM")

mace/ops/activation_test.cc

@@ -19,7 +19,7 @@ void TestSimpleRelu() {
       {-7, 7, -6, 6, -5, 5, -4, 4, -3, 3, -2, 2, -1, 1, 0, 0});
 
   if (D == DeviceType::OPENCL) {
-    BufferToImage<D, float>(net, "Input", "InputImage",
+    BufferToImage<D, float>(&net, "Input", "InputImage",
                             kernels::BufferType::IN_OUT_CHANNEL);
 
     OpDefBuilder("Activation", "ReluTest")
@@ -32,7 +32,7 @@ void TestSimpleRelu() {
     net.RunOp(D);
 
     // Transfer output
-    ImageToBuffer<D, float>(net, "OutputImage", "Output",
+    ImageToBuffer<D, float>(&net, "OutputImage", "Output",
                             kernels::BufferType::IN_OUT_CHANNEL);
   } else {
     OpDefBuilder("Activation", "ReluTest")
@@ -65,7 +65,7 @@ void TestUnalignedSimpleRelu() {
   net.AddInputFromArray<D, float>("Input", {1, 3, 2, 1}, {-7, 7, -6, 6, -5, 5});
 
   if (D == DeviceType::OPENCL) {
-    BufferToImage<D, float>(net, "Input", "InputImage",
+    BufferToImage<D, float>(&net, "Input", "InputImage",
                             kernels::BufferType::IN_OUT_CHANNEL);
 
     OpDefBuilder("Activation", "ReluTest")
@@ -78,7 +78,7 @@ void TestUnalignedSimpleRelu() {
     net.RunOp(D);
 
     // Transfer output
-    ImageToBuffer<D, float>(net, "OutputImage", "Output",
+    ImageToBuffer<D, float>(&net, "OutputImage", "Output",
                             kernels::BufferType::IN_OUT_CHANNEL);
   } else {
     OpDefBuilder("Activation", "ReluTest")
@@ -114,7 +114,7 @@ void TestSimpleRelux() {
       {-7, 7, -6, 6, -5, 5, -4, 4, -3, 3, -2, 2, -1, 1, 0, 0});
 
   if (D == DeviceType::OPENCL) {
-    BufferToImage<D, float>(net, "Input", "InputImage",
+    BufferToImage<D, float>(&net, "Input", "InputImage",
                             kernels::BufferType::IN_OUT_CHANNEL);
 
     OpDefBuilder("Activation", "ReluxTest")
@@ -128,7 +128,7 @@ void TestSimpleRelux() {
     net.RunOp(D);
 
     // Transfer output
-    ImageToBuffer<D, float>(net, "OutputImage", "Output",
+    ImageToBuffer<D, float>(&net, "OutputImage", "Output",
                             kernels::BufferType::IN_OUT_CHANNEL);
   } else {
     OpDefBuilder("Activation", "ReluxTest")
@@ -164,7 +164,7 @@ void TestSimpleReluRelux() {
       {-7, 7, -6, 6, -5, 5, -4, 4, -3, 3, -2, 2, -1, 1, 0, 0});
 
   if (D == DeviceType::OPENCL) {
-    BufferToImage<D, float>(net, "Input", "InputImage",
+    BufferToImage<D, float>(&net, "Input", "InputImage",
                             kernels::BufferType::IN_OUT_CHANNEL);
 
     OpDefBuilder("Activation", "ReluxTest")
@@ -178,7 +178,7 @@ void TestSimpleReluRelux() {
     net.RunOp(D);
 
     // Transfer output
-    ImageToBuffer<D, float>(net, "OutputImage", "Output",
+    ImageToBuffer<D, float>(&net, "OutputImage", "Output",
                             kernels::BufferType::IN_OUT_CHANNEL);
   } else {
     OpDefBuilder("Activation", "ReluxTest")
@@ -217,9 +217,9 @@ void TestSimplePrelu() {
   net.AddInputFromArray<D, float>("Alpha", {2}, {2.0, 3.0});
 
   if (D == DeviceType::OPENCL) {
-    BufferToImage<D, float>(net, "Input", "InputImage",
+    BufferToImage<D, float>(&net, "Input", "InputImage",
                             kernels::BufferType::IN_OUT_CHANNEL);
-    BufferToImage<D, float>(net, "Alpha", "AlphaImage",
+    BufferToImage<D, float>(&net, "Alpha", "AlphaImage",
                             kernels::BufferType::ARGUMENT);
 
     OpDefBuilder("Activation", "PreluTest")
@@ -233,7 +233,7 @@ void TestSimplePrelu() {
     net.RunOp(D);
 
     // Transfer output
-    ImageToBuffer<D, float>(net, "OutputImage", "Output",
+    ImageToBuffer<D, float>(&net, "OutputImage", "Output",
                             kernels::BufferType::IN_OUT_CHANNEL);
   } else {
     OpDefBuilder("Activation", "PreluTest")
@@ -270,7 +270,7 @@ void TestSimpleTanh() {
       {-7, 7, -6, 6, -5, 5, -4, 4, -3, 3, -2, 2, -1, 1, 0, 0});
 
   if (D == DeviceType::OPENCL) {
-    BufferToImage<D, float>(net, "Input", "InputImage",
+    BufferToImage<D, float>(&net, "Input", "InputImage",
                             kernels::BufferType::IN_OUT_CHANNEL);
 
     OpDefBuilder("Activation", "TanhTest")
@@ -283,7 +283,7 @@ void TestSimpleTanh() {
     net.RunOp(D);
 
     // Transfer output
-    ImageToBuffer<D, float>(net, "OutputImage", "Output",
+    ImageToBuffer<D, float>(&net, "OutputImage", "Output",
                             kernels::BufferType::IN_OUT_CHANNEL);
   } else {
     OpDefBuilder("Activation", "TanhTest")
@@ -321,7 +321,7 @@ void TestSimpleSigmoid() {
       {-7, 7, -6, 6, -5, 5, -4, 4, -3, 3, -2, 2, -1, 1, 0, 0});
 
   if (D == DeviceType::OPENCL) {
-    BufferToImage<D, float>(net, "Input", "InputImage",
+    BufferToImage<D, float>(&net, "Input", "InputImage",
                             kernels::BufferType::IN_OUT_CHANNEL);
 
     OpDefBuilder("Activation", "SigmoidTest")
@@ -334,7 +334,7 @@ void TestSimpleSigmoid() {
     net.RunOp(D);
 
     // Transfer output
-    ImageToBuffer<D, float>(net, "OutputImage", "Output",
+    ImageToBuffer<D, float>(&net, "OutputImage", "Output",
                             kernels::BufferType::IN_OUT_CHANNEL);
   } else {
     OpDefBuilder("Activation", "SigmoidTest")

mace/ops/addn_benchmark.cc

@@ -20,7 +20,7 @@ static void AddNBenchmark(int iters, int inputs, int n, int h, int w, int c) {
 
   if (D == DeviceType::OPENCL) {
     for (int i = 0; i < inputs; ++i) {
-      BufferToImage<D, T>(net, MakeString("Input", i).c_str(),
+      BufferToImage<D, T>(&net, MakeString("Input", i).c_str(),
                           MakeString("InputImage", i).c_str(),
                           kernels::BufferType::IN_OUT_CHANNEL);
     }

mace/ops/addn_test.cc

@@ -92,7 +92,7 @@ void RandomTest() {
 
     // run on gpu
     for (int i = 0; i < input_num; ++i) {
-      BufferToImage<D, half>(net, MakeString("Input", i),
+      BufferToImage<D, half>(&net, MakeString("Input", i),
                              MakeString("InputImage", i),
                              kernels::BufferType::IN_OUT_CHANNEL);
     }
@@ -108,7 +108,7 @@ void RandomTest() {
     // Run on device
     net.RunOp(D);
 
-    ImageToBuffer<D, float>(net, "OutputImage", "OPENCLOutput",
+    ImageToBuffer<D, float>(&net, "OutputImage", "OPENCLOutput",
                             kernels::BufferType::IN_OUT_CHANNEL);
 
     ExpectTensorNear<float>(expected, *net.GetOutput("OPENCLOutput"), 0.1);

mace/ops/batch_norm_benchmark.cc

@@ -23,15 +23,15 @@ static void BatchNorm(
   net.AddRandomInput<D, T>("Var", {channels}, true);
 
   if (D == DeviceType::OPENCL) {
-    BufferToImage<D, float>(net, "Input", "InputImage",
+    BufferToImage<D, float>(&net, "Input", "InputImage",
                             kernels::BufferType::IN_OUT_CHANNEL);
-    BufferToImage<D, float>(net, "Scale", "ScaleImage",
+    BufferToImage<D, float>(&net, "Scale", "ScaleImage",
                             kernels::BufferType::ARGUMENT);
-    BufferToImage<D, float>(net, "Offset", "OffsetImage",
+    BufferToImage<D, float>(&net, "Offset", "OffsetImage",
                             kernels::BufferType::ARGUMENT);
-    BufferToImage<D, float>(net, "Mean", "MeanImage",
+    BufferToImage<D, float>(&net, "Mean", "MeanImage",
                             kernels::BufferType::ARGUMENT);
-    BufferToImage<D, float>(net, "Var", "VarImage",
+    BufferToImage<D, float>(&net, "Var", "VarImage",
                             kernels::BufferType::ARGUMENT);
     OpDefBuilder("BatchNorm", "BatchNormBM")
         .Input("InputImage")

mace/ops/batch_norm_test.cc

@@ -22,15 +22,15 @@ void Simple() {
   net.AddInputFromArray<D, float>("Var", {1}, {11.67f});
 
   if (D == DeviceType::OPENCL) {
-    BufferToImage<D, float>(net, "Input", "InputImage",
+    BufferToImage<D, float>(&net, "Input", "InputImage",
                             kernels::BufferType::IN_OUT_CHANNEL);
-    BufferToImage<D, float>(net, "Scale", "ScaleImage",
+    BufferToImage<D, float>(&net, "Scale", "ScaleImage",
                             kernels::BufferType::ARGUMENT);
-    BufferToImage<D, float>(net, "Offset", "OffsetImage",
+    BufferToImage<D, float>(&net, "Offset", "OffsetImage",
                             kernels::BufferType::ARGUMENT);
-    BufferToImage<D, float>(net, "Mean", "MeanImage",
+    BufferToImage<D, float>(&net, "Mean", "MeanImage",
                             kernels::BufferType::ARGUMENT);
-    BufferToImage<D, float>(net, "Var", "VarImage",
+    BufferToImage<D, float>(&net, "Var", "VarImage",
                             kernels::BufferType::ARGUMENT);
 
     OpDefBuilder("BatchNorm", "BatchNormTest")
@@ -46,7 +46,7 @@ void Simple() {
     net.RunOp(D);
 
     // Transfer output
-    ImageToBuffer<D, float>(net, "OutputImage", "Output",
+    ImageToBuffer<D, float>(&net, "OutputImage", "Output",
                             kernels::BufferType::IN_OUT_CHANNEL);
   } else {
     OpDefBuilder("BatchNorm", "BatchNormTest")
@@ -111,15 +111,15 @@ TEST_F(BatchNormOpTest, SimpleRandomOPENCL) {
   expected.Copy(*net.GetOutput("Output"));
 
   // Run on opencl
-  BufferToImage<DeviceType::OPENCL, float>(net, "Input", "InputImage",
+  BufferToImage<DeviceType::OPENCL, float>(&net, "Input", "InputImage",
                                            kernels::BufferType::IN_OUT_CHANNEL);
-  BufferToImage<DeviceType::OPENCL, float>(net, "Scale", "ScaleImage",
+  BufferToImage<DeviceType::OPENCL, float>(&net, "Scale", "ScaleImage",
                                            kernels::BufferType::ARGUMENT);
-  BufferToImage<DeviceType::OPENCL, float>(net, "Offset", "OffsetImage",
+  BufferToImage<DeviceType::OPENCL, float>(&net, "Offset", "OffsetImage",
                                            kernels::BufferType::ARGUMENT);
-  BufferToImage<DeviceType::OPENCL, float>(net, "Mean", "MeanImage",
+  BufferToImage<DeviceType::OPENCL, float>(&net, "Mean", "MeanImage",
                                            kernels::BufferType::ARGUMENT);
-  BufferToImage<DeviceType::OPENCL, float>(net, "Var", "VarImage",
+  BufferToImage<DeviceType::OPENCL, float>(&net, "Var", "VarImage",
                                            kernels::BufferType::ARGUMENT);
 
   OpDefBuilder("BatchNorm", "BatchNormTest")
@@ -141,7 +141,7 @@ TEST_F(BatchNormOpTest, SimpleRandomOPENCL) {
   net.RunOp(DeviceType::OPENCL);
   net.Sync();
 
-  ImageToBuffer<DeviceType::OPENCL, float>(net, "OutputImage", "OPENCLOutput",
+  ImageToBuffer<DeviceType::OPENCL, float>(&net, "OutputImage", "OPENCLOutput",
                                            kernels::BufferType::IN_OUT_CHANNEL);
   ExpectTensorNear<float>(expected, *net.GetOutput("OPENCLOutput"), 1e-2);
 }
@@ -183,15 +183,15 @@ TEST_F(BatchNormOpTest, SimpleRandomHalfOPENCL) {
   expected.Copy(*net.GetOutput("Output"));
 
   // Run on opencl
-  BufferToImage<DeviceType::OPENCL, half>(net, "Input", "InputImage",
+  BufferToImage<DeviceType::OPENCL, half>(&net, "Input", "InputImage",
                                           kernels::BufferType::IN_OUT_CHANNEL);
-  BufferToImage<DeviceType::OPENCL, half>(net, "Scale", "ScaleImage",
+  BufferToImage<DeviceType::OPENCL, half>(&net, "Scale", "ScaleImage",
                                           kernels::BufferType::ARGUMENT);
-  BufferToImage<DeviceType::OPENCL, half>(net, "Offset", "OffsetImage",
+  BufferToImage<DeviceType::OPENCL, half>(&net, "Offset", "OffsetImage",
                                           kernels::BufferType::ARGUMENT);
-  BufferToImage<DeviceType::OPENCL, half>(net, "Mean", "MeanImage",
+  BufferToImage<DeviceType::OPENCL, half>(&net, "Mean", "MeanImage",
                                           kernels::BufferType::ARGUMENT);
-  BufferToImage<DeviceType::OPENCL, half>(net, "Var", "VarImage",
+  BufferToImage<DeviceType::OPENCL, half>(&net, "Var", "VarImage",
                                           kernels::BufferType::ARGUMENT);
 
   OpDefBuilder("BatchNorm", "BatchNormTest")
@@ -214,7 +214,7 @@ TEST_F(BatchNormOpTest, SimpleRandomHalfOPENCL) {
   net.RunOp(DeviceType::OPENCL);
   net.Sync();
 
-  ImageToBuffer<DeviceType::OPENCL, float>(net, "OutputImage", "OPENCLOutput",
+  ImageToBuffer<DeviceType::OPENCL, float>(&net, "OutputImage", "OPENCLOutput",
                                            kernels::BufferType::IN_OUT_CHANNEL);
   ExpectTensorNear<float>(expected, *net.GetOutput("OPENCLOutput"), 0.5);
 }
@@ -256,15 +256,15 @@ TEST_F(BatchNormOpTest, ComplexRandomOPENCL) {
   expected.Copy(*net.GetOutput("Output"));
 
   // Run on opencl
-  BufferToImage<DeviceType::OPENCL, float>(net, "Input", "InputImage",
+  BufferToImage<DeviceType::OPENCL, float>(&net, "Input", "InputImage",
                                            kernels::BufferType::IN_OUT_CHANNEL);
-  BufferToImage<DeviceType::OPENCL, float>(net, "Scale", "ScaleImage",
+  BufferToImage<DeviceType::OPENCL, float>(&net, "Scale", "ScaleImage",
                                            kernels::BufferType::ARGUMENT);
-  BufferToImage<DeviceType::OPENCL, float>(net, "Offset", "OffsetImage",
+  BufferToImage<DeviceType::OPENCL, float>(&net, "Offset", "OffsetImage",
                                            kernels::BufferType::ARGUMENT);
-  BufferToImage<DeviceType::OPENCL, float>(net, "Mean", "MeanImage",
+  BufferToImage<DeviceType::OPENCL, float>(&net, "Mean", "MeanImage",
                                            kernels::BufferType::ARGUMENT);
-  BufferToImage<DeviceType::OPENCL, float>(net, "Var", "VarImage",
+  BufferToImage<DeviceType::OPENCL, float>(&net, "Var", "VarImage",
                                            kernels::BufferType::ARGUMENT);
 
   OpDefBuilder("BatchNorm", "BatchNormTest")
@@ -286,7 +286,7 @@ TEST_F(BatchNormOpTest, ComplexRandomOPENCL) {
   net.RunOp(DeviceType::OPENCL);
   net.Sync();
 
-  ImageToBuffer<DeviceType::OPENCL, float>(net, "OutputImage", "OPENCLOutput",
+  ImageToBuffer<DeviceType::OPENCL, float>(&net, "OutputImage", "OPENCLOutput",
                                            kernels::BufferType::IN_OUT_CHANNEL);
   ExpectTensorNear<float>(expected, *net.GetOutput("OPENCLOutput"), 1e-2);
 }
@@ -328,15 +328,15 @@ TEST_F(BatchNormOpTest, ComplexRandomHalfOPENCL) {
   expected.Copy(*net.GetOutput("Output"));
 
   // Run on opencl
-  BufferToImage<DeviceType::OPENCL, half>(net, "Input", "InputImage",
+  BufferToImage<DeviceType::OPENCL, half>(&net, "Input", "InputImage",
                                           kernels::BufferType::IN_OUT_CHANNEL);
-  BufferToImage<DeviceType::OPENCL, half>(net, "Scale", "ScaleImage",
+  BufferToImage<DeviceType::OPENCL, half>(&net, "Scale", "ScaleImage",
                                           kernels::BufferType::ARGUMENT);
-  BufferToImage<DeviceType::OPENCL, half>(net, "Offset", "OffsetImage",
+  BufferToImage<DeviceType::OPENCL, half>(&net, "Offset", "OffsetImage",
                                           kernels::BufferType::ARGUMENT);
-  BufferToImage<DeviceType::OPENCL, half>(net, "Mean", "MeanImage",
+  BufferToImage<DeviceType::OPENCL, half>(&net, "Mean", "MeanImage",
                                           kernels::BufferType::ARGUMENT);
-  BufferToImage<DeviceType::OPENCL, half>(net, "Var", "VarImage",
+  BufferToImage<DeviceType::OPENCL, half>(&net, "Var", "VarImage",
                                           kernels::BufferType::ARGUMENT);
 
   OpDefBuilder("BatchNorm", "BatchNormTest")
@@ -359,7 +359,7 @@ TEST_F(BatchNormOpTest, ComplexRandomHalfOPENCL) {
   net.RunOp(DeviceType::OPENCL);
   net.Sync();
 
-  ImageToBuffer<DeviceType::OPENCL, float>(net, "OutputImage", "OPENCLOutput",
+  ImageToBuffer<DeviceType::OPENCL, float>(&net, "OutputImage", "OPENCLOutput",
                                            kernels::BufferType::IN_OUT_CHANNEL);
   ExpectTensorNear<float>(expected, *net.GetOutput("OPENCLOutput"), 0.5);
 }

mace/ops/batch_to_space_benchmark.cc

@@ -14,7 +14,7 @@ static void BMBatchToSpace(
 
   OpsTestNet net;
   net.AddRandomInput<D, float>("Input", {batch, height, width, channels});
-  BufferToImage<D, float>(net, "Input", "InputImage",
+  BufferToImage<D, float>(&net, "Input", "InputImage",
                           kernels::BufferType::IN_OUT_CHANNEL);
   OpDefBuilder("BatchToSpaceND", "BatchToSpaceNDTest")
       .Input("InputImage")

mace/ops/bias_add_benchmark.cc

@@ -19,9 +19,9 @@ static void BiasAdd(int iters, int batch, int channels, int height, int width) {
   net.AddRandomInput<D, T>("Bias", {channels}, true);
 
   if (D == DeviceType::OPENCL) {
-    BufferToImage<D, T>(net, "Input", "InputImage",
+    BufferToImage<D, T>(&net, "Input", "InputImage",
                         kernels::BufferType::IN_OUT_CHANNEL);
-    BufferToImage<D, T>(net, "Bias", "BiasImage",
+    BufferToImage<D, T>(&net, "Bias", "BiasImage",
                         kernels::BufferType::ARGUMENT);
     OpDefBuilder("BiasAdd", "BiasAddBM")
         .Input("InputImage")

mace/ops/bias_add_test.cc

@@ -19,9 +19,9 @@ void BiasAddSimple() {
   net.AddInputFromArray<D, float>("Bias", {1}, {0.5f});
 
   if (D == DeviceType::OPENCL) {
-    BufferToImage<D, float>(net, "Input", "InputImage",
+    BufferToImage<D, float>(&net, "Input", "InputImage",
                             kernels::BufferType::IN_OUT_CHANNEL);
-    BufferToImage<D, float>(net, "Bias", "BiasImage",
+    BufferToImage<D, float>(&net, "Bias", "BiasImage",
                             kernels::BufferType::ARGUMENT);
 
     OpDefBuilder("BiasAdd", "BiasAddTest")
@@ -33,7 +33,7 @@ void BiasAddSimple() {
     net.RunOp(D);
 
     // Transfer output
-    ImageToBuffer<D, float>(net, "OutputImage", "Output",
+    ImageToBuffer<D, float>(&net, "OutputImage", "Output",
                             kernels::BufferType::IN_OUT_CHANNEL);
   } else {
     OpDefBuilder("BiasAdd", "BiasAddTest")
@@ -89,9 +89,9 @@ TEST_F(BiasAddOpTest, SimpleRandomOPENCL) {
   expected.Copy(*net.GetOutput("Output"));
 
   // Run on opencl
-  BufferToImage<DeviceType::OPENCL, float>(net, "Input", "InputImage",
+  BufferToImage<DeviceType::OPENCL, float>(&net, "Input", "InputImage",
                                            kernels::BufferType::IN_OUT_CHANNEL);
-  BufferToImage<DeviceType::OPENCL, float>(net, "Bias", "BiasImage",
+  BufferToImage<DeviceType::OPENCL, float>(&net, "Bias", "BiasImage",
                                            kernels::BufferType::ARGUMENT);
 
   OpDefBuilder("BiasAdd", "BiasAddTest")
@@ -104,7 +104,7 @@ TEST_F(BiasAddOpTest, SimpleRandomOPENCL) {
   net.RunOp(DeviceType::OPENCL);
   net.Sync();
 
-  ImageToBuffer<DeviceType::OPENCL, float>(net, "OutputImage", "OPENCLOutput",
+  ImageToBuffer<DeviceType::OPENCL, float>(&net, "OutputImage", "OPENCLOutput",
                                            kernels::BufferType::IN_OUT_CHANNEL);
   ExpectTensorNear<float>(expected, *net.GetOutput("OPENCLOutput"), 1e-2);
 }
@@ -139,9 +139,9 @@ TEST_F(BiasAddOpTest, ComplexRandomOPENCL) {
   expected.Copy(*net.GetOutput("Output"));
 
   // Run on opencl
-  BufferToImage<DeviceType::OPENCL, float>(net, "Input", "InputImage",
+  BufferToImage<DeviceType::OPENCL, float>(&net, "Input", "InputImage",
                                            kernels::BufferType::IN_OUT_CHANNEL);
-  BufferToImage<DeviceType::OPENCL, float>(net, "Bias", "BiasImage",
+  BufferToImage<DeviceType::OPENCL, float>(&net, "Bias", "BiasImage",
                                            kernels::BufferType::ARGUMENT);
 
   OpDefBuilder("BiasAdd", "BiasAddTest")
@@ -154,7 +154,7 @@ TEST_F(BiasAddOpTest, ComplexRandomOPENCL) {
   net.RunOp(DeviceType::OPENCL);
   net.Sync();
 
-  ImageToBuffer<DeviceType::OPENCL, float>(net, "OutputImage", "OPENCLOutput",
+  ImageToBuffer<DeviceType::OPENCL, float>(&net, "OutputImage", "OPENCLOutput",
                                            kernels::BufferType::IN_OUT_CHANNEL);
   ExpectTensorNear<float>(expected, *net.GetOutput("OPENCLOutput"), 1e-2);
 }

mace/ops/channel_shuffle_benchmark.cc

@@ -19,7 +19,7 @@ static void ChannelShuffle(
   net.AddRandomInput<D, float>("Input", {batch, height, width, channels});
 
   if (D == DeviceType::OPENCL) {
-    BufferToImage<D, float>(net, "Input", "InputImage",
+    BufferToImage<D, float>(&net, "Input", "InputImage",
                             kernels::BufferType::IN_OUT_CHANNEL);
 
     OpDefBuilder("ChannelShuffle", "ChannelShuffleTest")

mace/ops/channel_shuffle_test.cc

@@ -41,7 +41,7 @@ TEST_F(ChannelShuffleOpTest, C16G4_OPENCL) {
     "Input", {1, 1, 2, 16},
     {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
      16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31});
-  BufferToImage<DeviceType::OPENCL, float>(net, "Input", "InputImage",
+  BufferToImage<DeviceType::OPENCL, float>(&net, "Input", "InputImage",
                           kernels::BufferType::IN_OUT_CHANNEL);
 
 
@@ -55,7 +55,7 @@ TEST_F(ChannelShuffleOpTest, C16G4_OPENCL) {
   net.RunOp(DeviceType::OPENCL);
 
   // Transfer output
-  ImageToBuffer<DeviceType::OPENCL, float>(net, "OutputImage", "Output",
+  ImageToBuffer<DeviceType::OPENCL, float>(&net, "OutputImage", "Output",
                           kernels::BufferType::IN_OUT_CHANNEL);
 
   // Check
@@ -64,4 +64,4 @@ TEST_F(ChannelShuffleOpTest, C16G4_OPENCL) {
     16, 20, 24, 28, 17, 21, 25, 29, 18, 22, 26, 30, 19, 23, 27, 31});
 
   ExpectTensorNear<float>(*expected, *net.GetOutput("Output"), 0.001);
-}
+}
\ No newline at end of file

mace/ops/concat_benchmark.cc

@@ -61,9 +61,9 @@ static void OpenclConcatHelper(int iters,
   net.AddRandomInput<DeviceType::OPENCL, float>("Input0", shape0);
   net.AddRandomInput<DeviceType::OPENCL, float>("Input1", shape1);
 
-  BufferToImage<DeviceType::OPENCL, T>(net, "Input0", "InputImage0",
+  BufferToImage<DeviceType::OPENCL, T>(&net, "Input0", "InputImage0",
                                        kernels::BufferType::IN_OUT_CHANNEL);
-  BufferToImage<DeviceType::OPENCL, T>(net, "Input1", "InputImage1",
+  BufferToImage<DeviceType::OPENCL, T>(&net, "Input1", "InputImage1",
                                        kernels::BufferType::IN_OUT_CHANNEL);
   OpDefBuilder("Concat", "ConcatBM")
       .Input("InputImage0")

mace/ops/concat_test.cc

@@ -22,9 +22,9 @@ TEST_F(ConcatOpTest, CPUSimpleHorizon) {
 
   std::vector<index_t> input_shape = {4, 4};
   std::vector<float> input0;
-  GenerateRandomRealTypeData(input_shape, input0);
+  GenerateRandomRealTypeData(input_shape, &input0);
   std::vector<float> input1;
-  GenerateRandomRealTypeData(input_shape, input1);
+  GenerateRandomRealTypeData(input_shape, &input1);
   // Add inputs
   net.AddInputFromArray<DeviceType::CPU, float>("Input0", input_shape, input0);
   net.AddInputFromArray<DeviceType::CPU, float>("Input1", input_shape, input1);
@@ -59,9 +59,9 @@ TEST_F(ConcatOpTest, CPUSimpleVertical) {
 
   std::vector<index_t> input_shape = {4, 4};
   std::vector<float> input0;
-  GenerateRandomRealTypeData(input_shape, input0);
+  GenerateRandomRealTypeData(input_shape, &input0);
   std::vector<float> input1;
-  GenerateRandomRealTypeData(input_shape, input1);
+  GenerateRandomRealTypeData(input_shape, &input1);
   // Add inputs
   net.AddInputFromArray<DeviceType::CPU, float>("Input0", input_shape, input0);
   net.AddInputFromArray<DeviceType::CPU, float>("Input1", input_shape, input1);
@@ -102,7 +102,7 @@ TEST_F(ConcatOpTest, CPURandom) {
       .Finalize(net.NewOperatorDef());
 
   std::vector<index_t> shape_data;
-  GenerateRandomIntTypeData<index_t>({dim}, shape_data, 1, dim);
+  GenerateRandomIntTypeData<index_t>({dim}, &shape_data, 1, dim);
   std::vector<std::vector<index_t>> input_shapes(num_inputs, shape_data);
   std::vector<std::vector<float>> inputs(num_inputs, std::vector<float>());
   std::vector<float *> input_ptrs(num_inputs, nullptr);
@@ -110,7 +110,7 @@ TEST_F(ConcatOpTest, CPURandom) {
   for (int i = 0; i < num_inputs; ++i) {
     input_shapes[i][axis] = 1 + rand() % dim;
     concat_axis_size += input_shapes[i][axis];
-    GenerateRandomRealTypeData(input_shapes[i], inputs[i]);
+    GenerateRandomRealTypeData(input_shapes[i], &inputs[i]);
     input_ptrs[i] = inputs[i].data();
     net.AddInputFromArray<DeviceType::CPU, float>(MakeString("Input", i),
                                                   input_shapes[i], inputs[i]);
@@ -152,7 +152,7 @@ void OpenclRandomTest(const std::vector<std::vector<index_t>> &shapes,
     const std::string image_name = MakeString("InputImage", i);
     concat_axis_size += shapes[i][axis];
     net.AddRandomInput<DeviceType::OPENCL, float>(input_name, shapes[i]);
-    BufferToImage<DeviceType::OPENCL, T>(net, input_name, image_name,
+    BufferToImage<DeviceType::OPENCL, T>(&net, input_name, image_name,
                                          kernels::BufferType::IN_OUT_CHANNEL);
   }
 
@@ -169,7 +169,7 @@ void OpenclRandomTest(const std::vector<std::vector<index_t>> &shapes,
   // Run
   net.RunOp(DeviceType::OPENCL);
 
-  ImageToBuffer<DeviceType::OPENCL, float>(net, "OutputImage", "Output",
+  ImageToBuffer<DeviceType::OPENCL, float>(&net, "OutputImage", "Output",
                                            kernels::BufferType::IN_OUT_CHANNEL);
 
   // Check
@@ -216,4 +216,4 @@ TEST_F(ConcatOpTest, OPENCLUnAligned) {
 TEST_F(ConcatOpTest, OPENCLAlignedMultiInput) {
   OpenclRandomTest<float>(
       {{3, 32, 32, 32}, {3, 32, 32, 32}, {3, 32, 32, 32}, {3, 32, 32, 32}}, 3);
-}
+}
\ No newline at end of file

mace/ops/conv_2d_benchmark.cc

@@ -34,11 +34,11 @@ static void Conv2d(int iters,
   net.AddRandomInput<D, float>("Bias", {output_channels});
 
   if (D == DeviceType::OPENCL) {
-    BufferToImage<D, T>(net, "Input", "InputImage",
+    BufferToImage<D, T>(&net, "Input", "InputImage",
                         kernels::BufferType::IN_OUT_CHANNEL);
-    BufferToImage<D, T>(net, "Filter", "FilterImage",
+    BufferToImage<D, T>(&net, "Filter", "FilterImage",
                         kernels::BufferType::CONV2D_FILTER);
-    BufferToImage<D, T>(net, "Bias", "BiasImage",
+    BufferToImage<D, T>(&net, "Bias", "BiasImage",
                         kernels::BufferType::ARGUMENT);
     OpDefBuilder("Conv2D", "Conv2dTest")
         .Input("InputImage")

mace/ops/conv_2d_test.cc

@@ -24,11 +24,11 @@ void TestNHWCSimple3x3VALID() {
   net.AddInputFromArray<D, T>("Bias", {1}, {0.1f});
 
   if (D == DeviceType::OPENCL) {
-    BufferToImage<D, T>(net, "Input", "InputImage",
+    BufferToImage<D, T>(&net, "Input", "InputImage",
                         kernels::BufferType::IN_OUT_CHANNEL);
-    BufferToImage<D, T>(net, "Filter", "FilterImage",
+    BufferToImage<D, T>(&net, "Filter", "FilterImage",
                         kernels::BufferType::CONV2D_FILTER);
-    BufferToImage<D, T>(net, "Bias", "BiasImage",
+    BufferToImage<D, T>(&net, "Bias", "BiasImage",
                         kernels::BufferType::ARGUMENT);
     OpDefBuilder("Conv2D", "Conv2dTest")
         .Input("InputImage")
@@ -44,7 +44,7 @@ void TestNHWCSimple3x3VALID() {
     net.RunOp(D);
 
     // Transfer output
-    ImageToBuffer<D, T>(net, "OutputImage", "Output",
+    ImageToBuffer<D, T>(&net, "OutputImage", "Output",
                         kernels::BufferType::IN_OUT_CHANNEL);
 
   } else {
@@ -81,11 +81,11 @@ void TestNHWCSimple3x3SAME() {
   net.AddInputFromArray<D, T>("Bias", {1}, {0.1f});
 
   if (D == DeviceType::OPENCL) {
-    BufferToImage<D, T>(net, "Input", "InputImage",
+    BufferToImage<D, T>(&net, "Input", "InputImage",
                         kernels::BufferType::IN_OUT_CHANNEL);
-    BufferToImage<D, T>(net, "Filter", "FilterImage",
+    BufferToImage<D, T>(&net, "Filter", "FilterImage",
                         kernels::BufferType::CONV2D_FILTER);
-    BufferToImage<D, T>(net, "Bias", "BiasImage",
+    BufferToImage<D, T>(&net, "Bias", "BiasImage",
                         kernels::BufferType::ARGUMENT);
     OpDefBuilder("Conv2D", "Conv2dTest")
         .Input("InputImage")
@@ -101,7 +101,7 @@ void TestNHWCSimple3x3SAME() {
     net.RunOp(D);
 
     // Transfer output
-    ImageToBuffer<D, T>(net, "OutputImage", "Output",
+    ImageToBuffer<D, T>(&net, "OutputImage", "Output",
                         kernels::BufferType::IN_OUT_CHANNEL);
 
   } else {
@@ -150,9 +150,9 @@ void TestNHWCSimple3x3WithoutBias() {
        1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f});
 
   if (D == DeviceType::OPENCL) {
-    BufferToImage<D, T>(net, "Input", "InputImage",
+    BufferToImage<D, T>(&net, "Input", "InputImage",
                         kernels::BufferType::IN_OUT_CHANNEL);
-    BufferToImage<D, T>(net, "Filter", "FilterImage",
+    BufferToImage<D, T>(&net, "Filter", "FilterImage",
                         kernels::BufferType::CONV2D_FILTER);
 
     OpDefBuilder("Conv2D", "Conv2dTest")
@@ -167,7 +167,7 @@ void TestNHWCSimple3x3WithoutBias() {
     // Run
     net.RunOp(D);
     // Transfer output
-    ImageToBuffer<D, T>(net, "OutputImage", "Output",
+    ImageToBuffer<D, T>(&net, "OutputImage", "Output",
                         kernels::BufferType::IN_OUT_CHANNEL);
   } else {
     OpDefBuilder("Conv2D", "Conv2dTest")
@@ -216,11 +216,11 @@ static void TestNHWCCombined3x3() {
   net.AddInputFromArray<D, T>("Bias", {2}, {0.1f, 0.2f});
 
   if (D == DeviceType::OPENCL) {
-    BufferToImage<D, T>(net, "Input", "InputImage",
+    BufferToImage<D, T>(&net, "Input", "InputImage",
                         kernels::BufferType::IN_OUT_CHANNEL);
-    BufferToImage<D, T>(net, "Filter", "FilterImage",
+    BufferToImage<D, T>(&net, "Filter", "FilterImage",
                         kernels::BufferType::CONV2D_FILTER);
-    BufferToImage<D, T>(net, "Bias", "BiasImage",
+    BufferToImage<D, T>(&net, "Bias", "BiasImage",
                         kernels::BufferType::ARGUMENT);
 
     OpDefBuilder("Conv2D", "Conv2DTest")
@@ -236,7 +236,7 @@ static void TestNHWCCombined3x3() {
     // Run
     net.RunOp(D);
 
-    ImageToBuffer<D, T>(net, "OutputImage", "Output",
+    ImageToBuffer<D, T>(&net, "OutputImage", "Output",
                         kernels::BufferType::IN_OUT_CHANNEL);
   } else {
     OpDefBuilder("Conv2D", "Conv2DTest")
@@ -289,11 +289,11 @@ void TestConv1x1() {
   net.AddInputFromArray<D, float>("Bias", {2}, {0.1f, 0.2f});
 
   if (D == DeviceType::OPENCL) {
-    BufferToImage<D, float>(net, "Input", "InputImage",
+    BufferToImage<D, float>(&net, "Input", "InputImage",
                             kernels::BufferType::IN_OUT_CHANNEL);
-    BufferToImage<D, float>(net, "Filter", "FilterImage",
+    BufferToImage<D, float>(&net, "Filter", "FilterImage",
                             kernels::BufferType::CONV2D_FILTER);
-    BufferToImage<D, float>(net, "Bias", "BiasImage",
+    BufferToImage<D, float>(&net, "Bias", "BiasImage",
                             kernels::BufferType::ARGUMENT);
 
     OpDefBuilder("Conv2D", "Conv2DTest")
@@ -308,7 +308,7 @@ void TestConv1x1() {
     // Run
     net.RunOp(D);
 
-    ImageToBuffer<D, float>(net, "OutputImage", "Output",
+    ImageToBuffer<D, float>(&net, "OutputImage", "Output",
                             kernels::BufferType::IN_OUT_CHANNEL);
   } else {
     OpDefBuilder("Conv2D", "Conv2DTest")
@@ -381,11 +381,11 @@ static void TestComplexConvNxNS12(const std::vector<index_t> &shape,
     expected.Copy(*net.GetOutput("Output"));
 
     // run on gpu
-    BufferToImage<D, T>(net, "Input", "InputImage",
+    BufferToImage<D, T>(&net, "Input", "InputImage",
                         kernels::BufferType::IN_OUT_CHANNEL);
-    BufferToImage<D, T>(net, "Filter", "FilterImage",
+    BufferToImage<D, T>(&net, "Filter", "FilterImage",
                         kernels::BufferType::CONV2D_FILTER);
-    BufferToImage<D, T>(net, "Bias", "BiasImage",
+    BufferToImage<D, T>(&net, "Bias", "BiasImage",
                         kernels::BufferType::ARGUMENT);
 
     OpDefBuilder("Conv2D", "Conv2dTest")
@@ -401,7 +401,7 @@ static void TestComplexConvNxNS12(const std::vector<index_t> &shape,
     // Run on device
     net.RunOp(D);
 
-    ImageToBuffer<D, T>(net, "OutputImage", "OPENCLOutput",
+    ImageToBuffer<D, T>(&net, "OutputImage", "OPENCLOutput",
                         kernels::BufferType::IN_OUT_CHANNEL);
     ExpectTensorNear<float>(expected, *net.GetOutput("OPENCLOutput"), 0.001);
   };
@@ -457,13 +457,13 @@ static void TestHalfComplexConvNxNS12(const std::vector<index_t> &input_shape,
 
     std::vector<float> float_input_data;
     GenerateRandomRealTypeData({batch, height, width, input_channels},
-                               float_input_data);
+                               &float_input_data);
     std::vector<float> float_filter_data;
     GenerateRandomRealTypeData(
         {kernel_h, kernel_w, output_channels, input_channels},
-        float_filter_data);
+        &float_filter_data);
     std::vector<float> float_bias_data;
-    GenerateRandomRealTypeData({output_channels}, float_bias_data);
+    GenerateRandomRealTypeData({output_channels}, &float_bias_data);
     // Add input data
     net.AddInputFromArray<D, float>(
         "Input", {batch, height, width, input_channels}, float_input_data);
@@ -479,11 +479,11 @@ static void TestHalfComplexConvNxNS12(const std::vector<index_t> &input_shape,
     expected.Copy(*net.GetOutput("Output"));
 
     // run on gpu
-    BufferToImage<D, half>(net, "Input", "InputImage",
+    BufferToImage<D, half>(&net, "Input", "InputImage",
                            kernels::BufferType::IN_OUT_CHANNEL);
-    BufferToImage<D, half>(net, "Filter", "FilterImage",
+    BufferToImage<D, half>(&net, "Filter", "FilterImage",
                            kernels::BufferType::CONV2D_FILTER);
-    BufferToImage<D, half>(net, "Bias", "BiasImage",
+    BufferToImage<D, half>(&net, "Bias", "BiasImage",
                            kernels::BufferType::ARGUMENT);
 
     OpDefBuilder("Conv2D", "Conv2dTest")
@@ -499,7 +499,7 @@ static void TestHalfComplexConvNxNS12(const std::vector<index_t> &input_shape,
     // Run on device
     net.RunOp(D);
 
-    ImageToBuffer<D, float>(net, "OutputImage", "OPENCLOutput",
+    ImageToBuffer<D, float>(&net, "OutputImage", "OPENCLOutput",
                             kernels::BufferType::IN_OUT_CHANNEL);
 
     ExpectTensorNear<float>(expected, *net.GetOutput("OPENCLOutput"), 0.5);
@@ -603,11 +603,11 @@ static void TestDilationConvNxN(const std::vector<index_t> &shape,
     expected.Copy(*net.GetOutput("Output"));
 
     // run on gpu
-    BufferToImage<D, T>(net, "Input", "InputImage",
+    BufferToImage<D, T>(&net, "Input", "InputImage",
                         kernels::BufferType::IN_OUT_CHANNEL);
-    BufferToImage<D, T>(net, "Filter", "FilterImage",
+    BufferToImage<D, T>(&net, "Filter", "FilterImage",
                         kernels::BufferType::CONV2D_FILTER);
-    BufferToImage<D, T>(net, "Bias", "BiasImage",
+    BufferToImage<D, T>(&net, "Bias", "BiasImage",
                         kernels::BufferType::ARGUMENT);
 
     OpDefBuilder("Conv2D", "Conv2dTest")
@@ -623,7 +623,7 @@ static void TestDilationConvNxN(const std::vector<index_t> &shape,
     // Run on device
     net.RunOp(D);
 
-    ImageToBuffer<D, T>(net, "OutputImage", "OPENCLOutput",
+    ImageToBuffer<D, T>(&net, "OutputImage", "OPENCLOutput",
                         kernels::BufferType::IN_OUT_CHANNEL);
     ExpectTensorNear<float>(expected, *net.GetOutput("OPENCLOutput"), 0.001);
   };
@@ -686,11 +686,11 @@ static void TestArbitraryPadConvNxN(const std::vector<index_t> &shape,
     expected.Copy(*net.GetOutput("Output"));
 
     // run on gpu
-    BufferToImage<D, T>(net, "Input", "InputImage",
+    BufferToImage<D, T>(&net, "Input", "InputImage",
                         kernels::BufferType::IN_OUT_CHANNEL);
-    BufferToImage<D, T>(net, "Filter", "FilterImage",
+    BufferToImage<D, T>(&net, "Filter", "FilterImage",
                         kernels::BufferType::CONV2D_FILTER);
-    BufferToImage<D, T>(net, "Bias", "BiasImage",
+    BufferToImage<D, T>(&net, "Bias", "BiasImage",
                         kernels::BufferType::ARGUMENT);
 
     OpDefBuilder("Conv2D", "Conv2dTest")
@@ -705,7 +705,7 @@ static void TestArbitraryPadConvNxN(const std::vector<index_t> &shape,
     // Run on device
     net.RunOp(D);
 
-    ImageToBuffer<D, T>(net, "OutputImage", "OPENCLOutput",
+    ImageToBuffer<D, T>(&net, "OutputImage", "OPENCLOutput",
                         kernels::BufferType::IN_OUT_CHANNEL);
     ExpectTensorNear<float>(expected, *net.GetOutput("OPENCLOutput"), 0.001);
   };

mace/ops/depthwise_conv2d_benchmark.cc

@@ -33,11 +33,11 @@ static void DepthwiseConv2d(int iters,
   net.AddRandomInput<D, float>("Bias", {input_channels * multiplier});
 
   if (D == DeviceType::OPENCL) {
-    BufferToImage<D, T>(net, "Input", "InputImage",
+    BufferToImage<D, T>(&net, "Input", "InputImage",
                         kernels::BufferType::IN_OUT_CHANNEL);
-    BufferToImage<D, T>(net, "Filter", "FilterImage",
+    BufferToImage<D, T>(&net, "Filter", "FilterImage",
                         kernels::BufferType::DW_CONV2D_FILTER);
-    BufferToImage<D, T>(net, "Bias", "BiasImage",
+    BufferToImage<D, T>(&net, "Bias", "BiasImage",
                         kernels::BufferType::ARGUMENT);
     OpDefBuilder("DepthwiseConv2d", "DepthwiseConv2dTest")
         .Input("InputImage")

mace/ops/depthwise_conv2d_test.cc

@@ -25,11 +25,11 @@ void SimpleValidTest() {
       "Filter", {2, 2, 2, 1}, {1.0f, 2.0f, 2.0f, 4.0f, 3.0f, 6.0f, 4.0f, 8.0f});
   net.AddInputFromArray<D, float>("Bias", {2}, {.1f, .2f});
   if (D == DeviceType::OPENCL) {
-    BufferToImage<D, T>(net, "Input", "InputImage",
+    BufferToImage<D, T>(&net, "Input", "InputImage",
                         kernels::BufferType::IN_OUT_CHANNEL);
-    BufferToImage<D, T>(net, "Filter", "FilterImage",
+    BufferToImage<D, T>(&net, "Filter", "FilterImage",
                         kernels::BufferType::DW_CONV2D_FILTER);
-    BufferToImage<D, T>(net, "Bias", "BiasImage",
+    BufferToImage<D, T>(&net, "Bias", "BiasImage",
                         kernels::BufferType::ARGUMENT);
     OpDefBuilder("DepthwiseConv2d", "DepthwiseConv2DTest")
         .Input("InputImage")
@@ -45,7 +45,7 @@ void SimpleValidTest() {
     net.RunOp(D);
 
     // Transfer output
-    ImageToBuffer<D, T>(net, "OutputImage", "Output",
+    ImageToBuffer<D, T>(&net, "OutputImage", "Output",
                         kernels::BufferType::IN_OUT_CHANNEL);
 
   } else {
@@ -129,11 +129,11 @@ void ComplexValidTest() {
   net.AddInputFromArray<D, float>("Bias", {6},
                                   {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f});
   if (D == DeviceType::OPENCL) {
-    BufferToImage<D, T>(net, "Input", "InputImage",
+    BufferToImage<D, T>(&net, "Input", "InputImage",
                         kernels::BufferType::IN_OUT_CHANNEL);
-    BufferToImage<D, T>(net, "Filter", "FilterImage",
+    BufferToImage<D, T>(&net, "Filter", "FilterImage",
                         kernels::BufferType::DW_CONV2D_FILTER);
-    BufferToImage<D, T>(net, "Bias", "BiasImage",
+    BufferToImage<D, T>(&net, "Bias", "BiasImage",
                         kernels::BufferType::ARGUMENT);
     OpDefBuilder("DepthwiseConv2d", "DepthwiseConv2DTest")
         .Input("InputImage")
@@ -149,7 +149,7 @@ void ComplexValidTest() {
     net.RunOp(D);
 
     // Transfer output
-    ImageToBuffer<D, T>(net, "OutputImage", "Output",
+    ImageToBuffer<D, T>(&net, "OutputImage", "Output",
                         kernels::BufferType::IN_OUT_CHANNEL);
 
   } else {
@@ -240,11 +240,11 @@ void TestNxNS12(const index_t height, const index_t width) {
     expected.Copy(*net.GetOutput("Output"));
 
     if (D == DeviceType::OPENCL) {
-      BufferToImage<D, T>(net, "Input", "InputImage",
+      BufferToImage<D, T>(&net, "Input", "InputImage",
                           kernels::BufferType::IN_OUT_CHANNEL);
-      BufferToImage<D, T>(net, "Filter", "FilterImage",
+      BufferToImage<D, T>(&net, "Filter", "FilterImage",
                           kernels::BufferType::DW_CONV2D_FILTER);
-      BufferToImage<D, T>(net, "Bias", "BiasImage",
+      BufferToImage<D, T>(&net, "Bias", "BiasImage",
                           kernels::BufferType::ARGUMENT);
       OpDefBuilder("DepthwiseConv2d", "DepthwiseConv2DTest")
           .Input("InputImage")
@@ -260,7 +260,7 @@ void TestNxNS12(const index_t height, const index_t width) {
       net.RunOp(D);
 
       // Transfer output
-      ImageToBuffer<D, float>(net, "OutputImage", "DeviceOutput",
+      ImageToBuffer<D, float>(&net, "OutputImage", "DeviceOutput",
                               kernels::BufferType::IN_OUT_CHANNEL);
     } else {
       OpDefBuilder("DepthwiseConv2d", "DepthwiseConv2DTest")

mace/ops/eltwise_benchmark.cc

@@ -20,9 +20,9 @@ static void EltwiseBenchmark(
   net.AddRandomInput<D, T>("Input1", {n, h, w, c});
 
   if (D == DeviceType::OPENCL) {
-    BufferToImage<D, half>(net, "Input0", "InputImg0",
+    BufferToImage<D, half>(&net, "Input0", "InputImg0",
                            kernels::BufferType::IN_OUT_CHANNEL);
-    BufferToImage<D, half>(net, "Input1", "InputImg1",
+    BufferToImage<D, half>(&net, "Input1", "InputImg1",
                            kernels::BufferType::IN_OUT_CHANNEL);
     OpDefBuilder("Eltwise", "EltwiseTest")
         .Input("InputImg0")

mace/ops/eltwise_test.cc

@@ -36,9 +36,9 @@ void Simple(const kernels::EltwiseType type,
     // Run
     net.RunOp(D);
   } else {
-    BufferToImage<D, half>(net, "Input1", "InputImg1",
+    BufferToImage<D, half>(&net, "Input1", "InputImg1",
                            kernels::BufferType::IN_OUT_CHANNEL);
-    BufferToImage<D, half>(net, "Input2", "InputImg2",
+    BufferToImage<D, half>(&net, "Input2", "InputImg2",
                            kernels::BufferType::IN_OUT_CHANNEL);
     OpDefBuilder("Eltwise", "EltwiseTest")
         .Input("InputImg1")
@@ -51,7 +51,7 @@ void Simple(const kernels::EltwiseType type,
     // Run
     net.RunOp(D);
 
-    ImageToBuffer<D, float>(net, "OutputImg", "Output",
+    ImageToBuffer<D, float>(&net, "OutputImg", "Output",
                             kernels::BufferType::IN_OUT_CHANNEL);
   }
 
@@ -120,9 +120,9 @@ void RandomTest(const kernels::EltwiseType type,
   // Run
   net.RunOp();
 
-  BufferToImage<D, T>(net, "Input1", "InputImg1",
+  BufferToImage<D, T>(&net, "Input1", "InputImg1",
                       kernels::BufferType::IN_OUT_CHANNEL);
-  BufferToImage<D, T>(net, "Input2", "InputImg2",
+  BufferToImage<D, T>(&net, "Input2", "InputImg2",
                       kernels::BufferType::IN_OUT_CHANNEL);
   OpDefBuilder("Eltwise", "EltwiseTest")
       .Input("InputImg1")
@@ -136,7 +136,7 @@ void RandomTest(const kernels::EltwiseType type,
   // Run
   net.RunOp(D);
 
-  ImageToBuffer<D, float>(net, "OutputImg", "OPENCLOutput",
+  ImageToBuffer<D, float>(&net, "OutputImg", "OPENCLOutput",
                           kernels::BufferType::IN_OUT_CHANNEL);
 
   if (DataTypeToEnum<T>::value == DT_FLOAT) {

mace/ops/folded_batch_norm_test.cc

@@ -37,11 +37,11 @@ void Simple() {
   net.AddInputFromArray<D, float>("Offset", {1}, offset);
 
   if (D == DeviceType::OPENCL) {
-    BufferToImage<D, float>(net, "Input", "InputImage",
+    BufferToImage<D, float>(&net, "Input", "InputImage",
                             kernels::BufferType::IN_OUT_CHANNEL);
-    BufferToImage<D, float>(net, "Scale", "ScaleImage",
+    BufferToImage<D, float>(&net, "Scale", "ScaleImage",
                             kernels::BufferType::ARGUMENT);
-    BufferToImage<D, float>(net, "Offset", "OffsetImage",
+    BufferToImage<D, float>(&net, "Offset", "OffsetImage",
                             kernels::BufferType::ARGUMENT);
 
     OpDefBuilder("FoldedBatchNorm", "FoldedBatchNormTest")
@@ -54,7 +54,7 @@ void Simple() {
     net.RunOp(D);
 
     // Transfer output
-    ImageToBuffer<D, float>(net, "OutputImage", "Output",
+    ImageToBuffer<D, float>(&net, "OutputImage", "Output",
                             kernels::BufferType::IN_OUT_CHANNEL);
   } else {
     OpDefBuilder("FoldedBatchNorm", "FoldedBatchNormTest")
@@ -203,11 +203,11 @@ TEST_F(FoldedBatchNormOpTest, SimpleRandomOPENCL) {
   expected.Copy(*net.GetOutput("Output"));
 
   // Run on opencl
-  BufferToImage<DeviceType::OPENCL, float>(net, "Input", "InputImage",
+  BufferToImage<DeviceType::OPENCL, float>(&net, "Input", "InputImage",
                                            kernels::BufferType::IN_OUT_CHANNEL);
-  BufferToImage<DeviceType::OPENCL, float>(net, "Scale", "ScaleImage",
+  BufferToImage<DeviceType::OPENCL, float>(&net, "Scale", "ScaleImage",
                                            kernels::BufferType::ARGUMENT);
-  BufferToImage<DeviceType::OPENCL, float>(net, "Offset", "OffsetImage",
+  BufferToImage<DeviceType::OPENCL, float>(&net, "Offset", "OffsetImage",
                                            kernels::BufferType::ARGUMENT);
 
   OpDefBuilder("FoldedBatchNorm", "FoldedBatchNormTest")
@@ -221,7 +221,7 @@ TEST_F(FoldedBatchNormOpTest, SimpleRandomOPENCL) {
   net.RunOp(DeviceType::OPENCL);
   net.Sync();
 
-  ImageToBuffer<DeviceType::OPENCL, float>(net, "OutputImage", "OPENCLOutput",
+  ImageToBuffer<DeviceType::OPENCL, float>(&net, "OutputImage", "OPENCLOutput",
                                            kernels::BufferType::IN_OUT_CHANNEL);
   ExpectTensorNear<float>(expected, *net.GetOutput("OPENCLOutput"), 1e-2);
 }
@@ -258,11 +258,11 @@ TEST_F(FoldedBatchNormOpTest, SimpleRandomHalfOPENCL) {
   expected.Copy(*net.GetOutput("Output"));
 
   // Run on opencl
-  BufferToImage<DeviceType::OPENCL, half>(net, "Input", "InputImage",
+  BufferToImage<DeviceType::OPENCL, half>(&net, "Input", "InputImage",
                                           kernels::BufferType::IN_OUT_CHANNEL);
-  BufferToImage<DeviceType::OPENCL, half>(net, "Scale", "ScaleImage",
+  BufferToImage<DeviceType::OPENCL, half>(&net, "Scale", "ScaleImage",
                                           kernels::BufferType::ARGUMENT);
-  BufferToImage<DeviceType::OPENCL, half>(net, "Offset", "OffsetImage",
+  BufferToImage<DeviceType::OPENCL, half>(&net, "Offset", "OffsetImage",
                                           kernels::BufferType::ARGUMENT);
 
   OpDefBuilder("FoldedBatchNorm", "FoldedBatchNormTest")
@@ -277,7 +277,7 @@ TEST_F(FoldedBatchNormOpTest, SimpleRandomHalfOPENCL) {
   net.RunOp(DeviceType::OPENCL);
   net.Sync();
 
-  ImageToBuffer<DeviceType::OPENCL, float>(net, "OutputImage", "OPENCLOutput",
+  ImageToBuffer<DeviceType::OPENCL, float>(&net, "OutputImage", "OPENCLOutput",
                                            kernels::BufferType::IN_OUT_CHANNEL);
   ExpectTensorNear<float>(expected, *net.GetOutput("OPENCLOutput"), 0.5);
 }
@@ -314,11 +314,11 @@ TEST_F(FoldedBatchNormOpTest, ComplexRandomOPENCL) {
   expected.Copy(*net.GetOutput("Output"));
 
   // Run on opencl
-  BufferToImage<DeviceType::OPENCL, float>(net, "Input", "InputImage",
+  BufferToImage<DeviceType::OPENCL, float>(&net, "Input", "InputImage",
                                            kernels::BufferType::IN_OUT_CHANNEL);
-  BufferToImage<DeviceType::OPENCL, float>(net, "Scale", "ScaleImage",
+  BufferToImage<DeviceType::OPENCL, float>(&net, "Scale", "ScaleImage",
                                            kernels::BufferType::ARGUMENT);
-  BufferToImage<DeviceType::OPENCL, float>(net, "Offset", "OffsetImage",
+  BufferToImage<DeviceType::OPENCL, float>(&net, "Offset", "OffsetImage",
                                            kernels::BufferType::ARGUMENT);
 
   OpDefBuilder("FoldedBatchNorm", "FoldedBatchNormTest")
@@ -331,7 +331,7 @@ TEST_F(FoldedBatchNormOpTest, ComplexRandomOPENCL) {
   // Run on opencl
   net.RunOp(DeviceType::OPENCL);
 
-  ImageToBuffer<DeviceType::OPENCL, float>(net, "OutputImage", "OPENCLOutput",
+  ImageToBuffer<DeviceType::OPENCL, float>(&net, "OutputImage", "OPENCLOutput",
                                            kernels::BufferType::IN_OUT_CHANNEL);
   ExpectTensorNear<float>(expected, *net.GetOutput("OPENCLOutput"), 1e-2);
 }
@@ -368,11 +368,11 @@ TEST_F(FoldedBatchNormOpTest, ComplexRandomHalfOPENCL) {
   expected.Copy(*net.GetOutput("Output"));
 
   // Run on opencl
-  BufferToImage<DeviceType::OPENCL, half>(net, "Input", "InputImage",
+  BufferToImage<DeviceType::OPENCL, half>(&net, "Input", "InputImage",
                                           kernels::BufferType::IN_OUT_CHANNEL);
-  BufferToImage<DeviceType::OPENCL, half>(net, "Scale", "ScaleImage",
+  BufferToImage<DeviceType::OPENCL, half>(&net, "Scale", "ScaleImage",
                                           kernels::BufferType::ARGUMENT);
-  BufferToImage<DeviceType::OPENCL, half>(net, "Offset", "OffsetImage",
+  BufferToImage<DeviceType::OPENCL, half>(&net, "Offset", "OffsetImage",
                                           kernels::BufferType::ARGUMENT);
 
   OpDefBuilder("FoldedBatchNorm", "FoldedBatchNormTest")
@@ -386,7 +386,7 @@ TEST_F(FoldedBatchNormOpTest, ComplexRandomHalfOPENCL) {
   // Run on opencl
   net.RunOp(DeviceType::OPENCL);
 
-  ImageToBuffer<DeviceType::OPENCL, float>(net, "OutputImage", "OPENCLOutput",
+  ImageToBuffer<DeviceType::OPENCL, float>(&net, "OutputImage", "OPENCLOutput",
                                            kernels::BufferType::IN_OUT_CHANNEL);
   ExpectTensorNear<float>(expected, *net.GetOutput("OPENCLOutput"), 0.5);
 }

mace/ops/fully_connected.h

@@ -5,6 +5,8 @@
 #ifndef MACE_OPS_FULLY_CONNECTED_H_
 #define MACE_OPS_FULLY_CONNECTED_H_
 
+#include <string>
+
 #include "mace/core/operator.h"
 #include "mace/kernels/fully_connected.h"
 

mace/ops/fully_connected_benchmark.cc

@@ -8,6 +8,7 @@
 #include "mace/ops/ops_test_util.h"
 
 namespace mace {
+
 template <DeviceType D, typename T>
 static void FCBenchmark(
     int iters, int batch, int height, int width, int channel, int out_channel) {
@@ -24,11 +25,11 @@ static void FCBenchmark(
   if (D == DeviceType::OPENCL) {
     const int width_size = height * width * channel;
     kernels::BufferType weight_type = kernels::BufferType::WEIGHT_WIDTH;
-    BufferToImage<D, T>(net, "Weight", "WeightImage",
+    BufferToImage<D, T>(&net, "Weight", "WeightImage",
                         weight_type);
-    BufferToImage<D, T>(net, "Input", "InputImage",
+    BufferToImage<D, T>(&net, "Input", "InputImage",
                         kernels::BufferType::IN_OUT_CHANNEL);
-    BufferToImage<D, T>(net, "Bias", "BiasImage",
+    BufferToImage<D, T>(&net, "Bias", "BiasImage",
                         kernels::BufferType::ARGUMENT);
 
     OpDefBuilder("FC", "FullyConnectedTest")

mace/ops/fully_connected_test.cc

@@ -27,11 +27,11 @@ void Simple(const std::vector<index_t> &input_shape,
   net.AddInputFromArray<D, float>("Bias", bias_shape, bias_value);
 
   if (D == DeviceType::OPENCL) {
-    BufferToImage<D, float>(net, "Input", "InputImage",
+    BufferToImage<D, float>(&net, "Input", "InputImage",
                             kernels::BufferType::IN_OUT_CHANNEL);
-    BufferToImage<D, float>(net, "Weight", "WeightImage",
+    BufferToImage<D, float>(&net, "Weight", "WeightImage",
                             kernels::BufferType::WEIGHT_HEIGHT);
-    BufferToImage<D, float>(net, "Bias", "BiasImage",
+    BufferToImage<D, float>(&net, "Bias", "BiasImage",
                             kernels::BufferType::ARGUMENT);
 
     OpDefBuilder("FC", "FullyConnectedTest")
@@ -45,7 +45,7 @@ void Simple(const std::vector<index_t> &input_shape,
     net.RunOp(D);
 
     // Transfer output
-    ImageToBuffer<D, float>(net, "OutputImage", "Output",
+    ImageToBuffer<D, float>(&net, "OutputImage", "Output",
                             kernels::BufferType::IN_OUT_CHANNEL);
   } else {
     OpDefBuilder("FC", "FullyConnectedTest")
@@ -136,11 +136,11 @@ void Complex(const index_t batch,
   expected.Copy(*net.GetOutput("Output"));
 
   // Run on opencl
-  BufferToImage<DeviceType::OPENCL, T>(net, "Input", "InputImage",
+  BufferToImage<DeviceType::OPENCL, T>(&net, "Input", "InputImage",
                                        kernels::BufferType::IN_OUT_CHANNEL);
-  BufferToImage<DeviceType::OPENCL, T>(net, "Weight", "WeightImage",
+  BufferToImage<DeviceType::OPENCL, T>(&net, "Weight", "WeightImage",
                                        kernels::BufferType::WEIGHT_HEIGHT);
-  BufferToImage<DeviceType::OPENCL, float>(net, "Bias", "BiasImage",
+  BufferToImage<DeviceType::OPENCL, float>(&net, "Bias", "BiasImage",
                                            kernels::BufferType::ARGUMENT);
 
   OpDefBuilder("FC", "FullyConnectedTest")
@@ -155,7 +155,7 @@ void Complex(const index_t batch,
   // Run on opencl
   net.RunOp(DeviceType::OPENCL);
 
-  ImageToBuffer<DeviceType::OPENCL, float>(net, "OutputImage", "OPENCLOutput",
+  ImageToBuffer<DeviceType::OPENCL, float>(&net, "OutputImage", "OPENCLOutput",
                                            kernels::BufferType::IN_OUT_CHANNEL);
   if (DataTypeToEnum<T>::value == DataType::DT_HALF) {
     ExpectTensorNear<float>(expected, *net.GetOutput("OPENCLOutput"), 1);
@@ -218,11 +218,11 @@ void TestWXFormat(const index_t batch,
   expected.Copy(*net.GetOutput("Output"));
 
   // Run on opencl
-  BufferToImage<DeviceType::OPENCL, T>(net, "Input", "InputImage",
+  BufferToImage<DeviceType::OPENCL, T>(&net, "Input", "InputImage",
                                        kernels::BufferType::IN_OUT_CHANNEL);
-  BufferToImage<DeviceType::OPENCL, T>(net, "Weight", "WeightImage",
+  BufferToImage<DeviceType::OPENCL, T>(&net, "Weight", "WeightImage",
                                        kernels::BufferType::WEIGHT_WIDTH);
-  BufferToImage<DeviceType::OPENCL, float>(net, "Bias", "BiasImage",
+  BufferToImage<DeviceType::OPENCL, float>(&net, "Bias", "BiasImage",
                                            kernels::BufferType::ARGUMENT);
 
   OpDefBuilder("FC", "FullyConnectedTest")
@@ -236,7 +236,7 @@ void TestWXFormat(const index_t batch,
   // Run on opencl
   net.RunOp(DeviceType::OPENCL);
 
-  ImageToBuffer<DeviceType::OPENCL, float>(net, "OutputImage", "OPENCLOutput",
+  ImageToBuffer<DeviceType::OPENCL, float>(&net, "OutputImage", "OPENCLOutput",
                                            kernels::BufferType::IN_OUT_CHANNEL);
   if (DataTypeToEnum<T>::value == DataType::DT_HALF) {
     ExpectTensorNear<float>(expected, *net.GetOutput("OPENCLOutput"), 1);
@@ -263,4 +263,4 @@ TEST_F(FullyConnectedOpTest, OPENCLHalfWidthFormatAligned) {
   TestWXFormat<half>(1, 16, 32, 32, 32);
 }
 
-}
+}  // namespace mace

mace/ops/fused_conv_2d.h

@@ -6,6 +6,7 @@
 #define MACE_OPS_FUSED_CONV_2D_H_
 
 #include <memory>
+#include <string>
 
 #include "mace/core/operator.h"
 #include "mace/kernels/conv_2d.h"

mace/ops/fused_conv_2d_test.cc

@@ -2,10 +2,12 @@
 // Copyright (c) 2017 XiaoMi All rights reserved.
 //
 
+#include <vector>
+
 #include "mace/ops/fused_conv_2d.h"
 #include "mace/ops/ops_test_util.h"
 
-using namespace mace;
+namespace mace {
 
 class FusedConv2dOpTest : public OpsTestBase {};
 
@@ -23,11 +25,11 @@ void TestNHWCSimple3x3VALID() {
   net.AddInputFromArray<D, T>("Bias", {1}, {-0.1f});
 
   if (D == DeviceType::OPENCL) {
-    BufferToImage<D, T>(net, "Input", "InputImage",
+    BufferToImage<D, T>(&net, "Input", "InputImage",
                         kernels::BufferType::IN_OUT_CHANNEL);
-    BufferToImage<D, T>(net, "Filter", "FilterImage",
+    BufferToImage<D, T>(&net, "Filter", "FilterImage",
                         kernels::BufferType::CONV2D_FILTER);
-    BufferToImage<D, T>(net, "Bias", "BiasImage",
+    BufferToImage<D, T>(&net, "Bias", "BiasImage",
                         kernels::BufferType::ARGUMENT);
     OpDefBuilder("FusedConv2D", "FusedConv2dTest")
         .Input("InputImage")
@@ -43,7 +45,7 @@ void TestNHWCSimple3x3VALID() {
     net.RunOp(D);
 
     // Transfer output
-    ImageToBuffer<D, T>(net, "OutputImage", "Output",
+    ImageToBuffer<D, T>(&net, "OutputImage", "Output",
                         kernels::BufferType::IN_OUT_CHANNEL);
 
   } else {
@@ -80,11 +82,11 @@ void TestNHWCSimple3x3SAME() {
   net.AddInputFromArray<D, T>("Bias", {1}, {-0.1f});
 
   if (D == DeviceType::OPENCL) {
-    BufferToImage<D, T>(net, "Input", "InputImage",
+    BufferToImage<D, T>(&net, "Input", "InputImage",
                         kernels::BufferType::IN_OUT_CHANNEL);
-    BufferToImage<D, T>(net, "Filter", "FilterImage",
+    BufferToImage<D, T>(&net, "Filter", "FilterImage",
                         kernels::BufferType::CONV2D_FILTER);
-    BufferToImage<D, T>(net, "Bias", "BiasImage",
+    BufferToImage<D, T>(&net, "Bias", "BiasImage",
                         kernels::BufferType::ARGUMENT);
     OpDefBuilder("FusedConv2D", "FusedConv2dTest")
         .Input("InputImage")
@@ -100,7 +102,7 @@ void TestNHWCSimple3x3SAME() {
     net.RunOp(D);
 
     // Transfer output
-    ImageToBuffer<D, T>(net, "OutputImage", "Output",
+    ImageToBuffer<D, T>(&net, "OutputImage", "Output",
                         kernels::BufferType::IN_OUT_CHANNEL);
 
   } else {
@@ -148,9 +150,9 @@ void TestNHWCSimple3x3WithoutBias() {
        1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f});
 
   if (D == DeviceType::OPENCL) {
-    BufferToImage<D, T>(net, "Input", "InputImage",
+    BufferToImage<D, T>(&net, "Input", "InputImage",
                         kernels::BufferType::IN_OUT_CHANNEL);
-    BufferToImage<D, T>(net, "Filter", "FilterImage",
+    BufferToImage<D, T>(&net, "Filter", "FilterImage",
                         kernels::BufferType::CONV2D_FILTER);
 
     OpDefBuilder("FusedConv2D", "FusedConv2dTest")
@@ -165,7 +167,7 @@ void TestNHWCSimple3x3WithoutBias() {
     // Run
     net.RunOp(D);
     // Transfer output
-    ImageToBuffer<D, T>(net, "OutputImage", "Output",
+    ImageToBuffer<D, T>(&net, "OutputImage", "Output",
                         kernels::BufferType::IN_OUT_CHANNEL);
   } else {
     OpDefBuilder("FusedConv2D", "FusedConv2dTest")
@@ -217,11 +219,11 @@ void TestConv1x1() {
   net.AddInputFromArray<D, float>("Bias", {2}, {0.1f, 0.2f});
 
   if (D == DeviceType::OPENCL) {
-    BufferToImage<D, float>(net, "Input", "InputImage",
+    BufferToImage<D, float>(&net, "Input", "InputImage",
                             kernels::BufferType::IN_OUT_CHANNEL);
-    BufferToImage<D, float>(net, "Filter", "FilterImage",
+    BufferToImage<D, float>(&net, "Filter", "FilterImage",
                             kernels::BufferType::CONV2D_FILTER);
-    BufferToImage<D, float>(net, "Bias", "BiasImage",
+    BufferToImage<D, float>(&net, "Bias", "BiasImage",
                             kernels::BufferType::ARGUMENT);
 
     OpDefBuilder("FusedConv2D", "FusedConv2dTest")
@@ -236,7 +238,7 @@ void TestConv1x1() {
     // Run
     net.RunOp(D);
 
-    ImageToBuffer<D, float>(net, "OutputImage", "Output",
+    ImageToBuffer<D, float>(&net, "OutputImage", "Output",
                             kernels::BufferType::IN_OUT_CHANNEL);
   } else {
     OpDefBuilder("FusedConv2D", "FusedConv2dTest")
@@ -274,14 +276,14 @@ static void TestComplexConvNxNS12(const std::vector<index_t> &shape) {
   testing::internal::LogToStderr();
   auto func = [&](int kernel_h, int kernel_w, int stride_h, int stride_w,
                   Padding type) {
-    srand(time(NULL));
+    unsigned int seed = time(NULL);
 
     // generate random input
-    index_t batch = 3 + (rand() % 10);
+    index_t batch = 3 + (rand_r(&seed) % 10);
     index_t height = shape[0];
     index_t width = shape[1];
-    index_t input_channels = shape[2] + (rand() % 10);
-    index_t output_channels = shape[3] + (rand() % 10);
+    index_t input_channels = shape[2] + (rand_r(&seed) % 10);
+    index_t output_channels = shape[3] + (rand_r(&seed) % 10);
     // Construct graph
     OpsTestNet net;
     OpDefBuilder("FusedConv2D", "FusedConv2dTest")
@@ -308,11 +310,11 @@ static void TestComplexConvNxNS12(const std::vector<index_t> &shape) {
     expected.Copy(*net.GetOutput("Output"));
 
     // run on gpu
-    BufferToImage<D, T>(net, "Input", "InputImage",
+    BufferToImage<D, T>(&net, "Input", "InputImage",
                         kernels::BufferType::IN_OUT_CHANNEL);
-    BufferToImage<D, T>(net, "Filter", "FilterImage",
+    BufferToImage<D, T>(&net, "Filter", "FilterImage",
                         kernels::BufferType::CONV2D_FILTER);
-    BufferToImage<D, T>(net, "Bias", "BiasImage",
+    BufferToImage<D, T>(&net, "Bias", "BiasImage",
                         kernels::BufferType::ARGUMENT);
 
     OpDefBuilder("FusedConv2D", "FusedConv2dTest")
@@ -328,7 +330,7 @@ static void TestComplexConvNxNS12(const std::vector<index_t> &shape) {
     // Run on device
     net.RunOp(D);
 
-    ImageToBuffer<D, T>(net, "OutputImage", "OPENCLOutput",
+    ImageToBuffer<D, T>(&net, "OutputImage", "OPENCLOutput",
                         kernels::BufferType::IN_OUT_CHANNEL);
     ExpectTensorNear<float>(expected, *net.GetOutput("OPENCLOutput"), 0.001);
   };
@@ -350,14 +352,14 @@ static void TestHalfComplexConvNxNS12(const std::vector<index_t> &shape) {
   testing::internal::LogToStderr();
   auto func = [&](int kernel_h, int kernel_w, int stride_h, int stride_w,
                   Padding type) {
-    srand(time(NULL));
+    unsigned int seed = time(NULL);
 
     // generate random input
-    index_t batch = 3 + (rand() % 10);
+    index_t batch = 3 + (rand_r(&seed) % 10);
     index_t height = shape[0];
     index_t width = shape[1];
-    index_t input_channels = shape[2] + (rand() % 10);
-    index_t output_channels = shape[3] + (rand() % 10);
+    index_t input_channels = shape[2] + (rand_r(&seed) % 10);
+    index_t output_channels = shape[3] + (rand_r(&seed) % 10);
     // Construct graph
     OpsTestNet net;
     OpDefBuilder("FusedConv2D", "FusedConv2dTest")
@@ -372,13 +374,13 @@ static void TestHalfComplexConvNxNS12(const std::vector<index_t> &shape) {
 
     std::vector<float> float_input_data;
     GenerateRandomRealTypeData({batch, height, width, input_channels},
-                               float_input_data);
+                               &float_input_data);
     std::vector<float> float_filter_data;
     GenerateRandomRealTypeData(
         {kernel_h, kernel_w, output_channels, input_channels},
-        float_filter_data);
+        &float_filter_data);
     std::vector<float> float_bias_data;
-    GenerateRandomRealTypeData({output_channels}, float_bias_data);
+    GenerateRandomRealTypeData({output_channels}, &float_bias_data);
     // Add input data
     net.AddInputFromArray<D, float>(
         "Input", {batch, height, width, input_channels}, float_input_data);
@@ -394,11 +396,11 @@ static void TestHalfComplexConvNxNS12(const std::vector<index_t> &shape) {
     expected.Copy(*net.GetOutput("Output"));
 
     // run on gpu
-    BufferToImage<D, half>(net, "Input", "InputImage",
+    BufferToImage<D, half>(&net, "Input", "InputImage",
                            kernels::BufferType::IN_OUT_CHANNEL);
-    BufferToImage<D, half>(net, "Filter", "FilterImage",
+    BufferToImage<D, half>(&net, "Filter", "FilterImage",
                            kernels::BufferType::CONV2D_FILTER);
-    BufferToImage<D, half>(net, "Bias", "BiasImage",
+    BufferToImage<D, half>(&net, "Bias", "BiasImage",
                            kernels::BufferType::ARGUMENT);
 
     OpDefBuilder("FusedConv2D", "FusedConv2dTest")
@@ -414,7 +416,7 @@ static void TestHalfComplexConvNxNS12(const std::vector<index_t> &shape) {
     // Run on device
     net.RunOp(D);
 
-    ImageToBuffer<D, float>(net, "OutputImage", "OPENCLOutput",
+    ImageToBuffer<D, float>(&net, "OutputImage", "OPENCLOutput",
                             kernels::BufferType::IN_OUT_CHANNEL);
 
     ExpectTensorNear<float>(expected, *net.GetOutput("OPENCLOutput"), 0.2);
@@ -472,11 +474,11 @@ static void TestGeneralConvNxNS12(const std::vector<index_t> &image_shape,
     expected.Copy(*net.GetOutput("Output"));
 
     // run on gpu
-    BufferToImage<D, T>(net, "Input", "InputImage",
+    BufferToImage<D, T>(&net, "Input", "InputImage",
                         kernels::BufferType::IN_OUT_CHANNEL);
-    BufferToImage<D, T>(net, "Filter", "FilterImage",
+    BufferToImage<D, T>(&net, "Filter", "FilterImage",
                         kernels::BufferType::CONV2D_FILTER);
-    BufferToImage<D, T>(net, "Bias", "BiasImage",
+    BufferToImage<D, T>(&net, "Bias", "BiasImage",
                         kernels::BufferType::ARGUMENT);
 
     OpDefBuilder("FusedConv2D", "FusedConv2dTest")
@@ -492,7 +494,7 @@ static void TestGeneralConvNxNS12(const std::vector<index_t> &image_shape,
     // Run on device
     net.RunOp(D);
 
-    ImageToBuffer<D, T>(net, "OutputImage", "OPENCLOutput",
+    ImageToBuffer<D, T>(&net, "OutputImage", "OPENCLOutput",
                         kernels::BufferType::IN_OUT_CHANNEL);
     ExpectTensorNear<float>(expected, *net.GetOutput("OPENCLOutput"), 0.001);
   };
@@ -551,11 +553,11 @@ static void TestAtrousConvNxN(const std::vector<index_t> &shape,
     expected.Copy(*net.GetOutput("Output"));
 
     // run on gpu
-    BufferToImage<D, T>(net, "Input", "InputImage",
+    BufferToImage<D, T>(&net, "Input", "InputImage",
                         kernels::BufferType::IN_OUT_CHANNEL);
-    BufferToImage<D, T>(net, "Filter", "FilterImage",
+    BufferToImage<D, T>(&net, "Filter", "FilterImage",
                         kernels::BufferType::CONV2D_FILTER);
-    BufferToImage<D, T>(net, "Bias", "BiasImage",
+    BufferToImage<D, T>(&net, "Bias", "BiasImage",
                         kernels::BufferType::ARGUMENT);
 
     OpDefBuilder("FusedConv2D", "FusedConv2dTest")
@@ -571,7 +573,7 @@ static void TestAtrousConvNxN(const std::vector<index_t> &shape,
     // Run on device
     net.RunOp(D);
 
-    ImageToBuffer<D, T>(net, "OutputImage", "OPENCLOutput",
+    ImageToBuffer<D, T>(&net, "OutputImage", "OPENCLOutput",
                         kernels::BufferType::IN_OUT_CHANNEL);
     ExpectTensorNear<float>(expected, *net.GetOutput("OPENCLOutput"), 0.001);
   };
@@ -638,11 +640,11 @@ static void TestGeneralHalfAtrousConv(const std::vector<index_t> &image_shape,
     expected.Copy(*net.GetOutput("Output"));
 
     // run on gpu
-    BufferToImage<D, half>(net, "Input", "InputImage",
+    BufferToImage<D, half>(&net, "Input", "InputImage",
                            kernels::BufferType::IN_OUT_CHANNEL);
-    BufferToImage<D, half>(net, "Filter", "FilterImage",
+    BufferToImage<D, half>(&net, "Filter", "FilterImage",
                            kernels::BufferType::CONV2D_FILTER);
-    BufferToImage<D, half>(net, "Bias", "BiasImage",
+    BufferToImage<D, half>(&net, "Bias", "BiasImage",
                            kernels::BufferType::ARGUMENT);
 
     OpDefBuilder("FusedConv2D", "FusedConv2dTest")
@@ -658,7 +660,7 @@ static void TestGeneralHalfAtrousConv(const std::vector<index_t> &image_shape,
     // Run on device
     net.RunOp(D);
 
-    ImageToBuffer<D, float>(net, "OutputImage", "OPENCLOutput",
+    ImageToBuffer<D, float>(&net, "OutputImage", "OPENCLOutput",
                             kernels::BufferType::IN_OUT_CHANNEL);
     ExpectTensorNear<float>(expected, *net.GetOutput("OPENCLOutput"), 0.7);
   };
@@ -676,3 +678,5 @@ TEST_F(FusedConv2dOpTest, OPENCL15X15AtrousConvD4) {
   TestGeneralHalfAtrousConv<DeviceType::OPENCL>({63, 71}, {15, 15, 16, 16},
                                                 {2, 2});
 }
+
+}  // namespace mace

mace/ops/global_avg_pooling.h

@@ -5,6 +5,8 @@
 #ifndef MACE_OPS_GLOBAL_AVG_POOLING_H_
 #define MACE_OPS_GLOBAL_AVG_POOLING_H_
 
+#include <vector>
+
 #include "mace/core/operator.h"
 #include "mace/kernels/global_avg_pooling.h"
 

mace/ops/global_avg_pooling_benchmark.cc

@@ -7,8 +7,8 @@
 #include "mace/core/testing/test_benchmark.h"
 #include "mace/ops/ops_test_util.h"
 
-using namespace mace;
-using namespace mace::kernels;
+namespace mace {
+namespace kernels {
 
 template <DeviceType D>
 static void GlobalAvgPooling(
@@ -53,3 +53,6 @@ static void GlobalAvgPooling(
 BM_GLOBAL_AVG_POOLING(1, 3, 7, 7);
 BM_GLOBAL_AVG_POOLING(1, 3, 64, 64);
 BM_GLOBAL_AVG_POOLING(1, 3, 256, 256);
+
+}  // namespace kernels
+}  // namespace mace

mace/ops/global_avg_pooling_test.cc

@@ -4,7 +4,7 @@
 #include "mace/core/operator.h"
 #include "mace/ops/ops_test_util.h"
 
-using namespace mace;
+namespace mace {
 
 class GlobalAvgPoolingOpTest : public OpsTestBase {};
 
@@ -31,3 +31,5 @@ TEST_F(GlobalAvgPoolingOpTest, 3x7x7_CPU) {
 
   ExpectTensorNear<float>(*expected, *net.GetOutput("Output"), 0.001);
 }
+
+}  // namespace mace

mace/ops/matmul_benchmark.cc

@@ -20,8 +20,9 @@ static void MatMulBenchmark(
   net.AddRandomInput<D, float>("B", {batch, channels, out_width, 1});
 
   if (D == DeviceType::OPENCL) {
-    BufferToImage<D, T>(net, "A", "AImage", kernels::BufferType::IN_OUT_WIDTH);
-    BufferToImage<D, T>(net, "B", "BImage", kernels::BufferType::IN_OUT_HEIGHT);
+    BufferToImage<D, T>(&net, "A", "AImage", kernels::BufferType::IN_OUT_WIDTH);
+    BufferToImage<D, T>(&net, "B", "BImage",
+                        kernels::BufferType::IN_OUT_HEIGHT);
 
     OpDefBuilder("MatMul", "MatMulBM")
         .Input("AImage")

mace/ops/matmul_test.cc

@@ -24,9 +24,9 @@ void Simple(const std::vector<index_t> &A_shape,
   net.AddInputFromArray<D, float>("B", B_shape, B_value);
 
   if (D == DeviceType::OPENCL) {
-    BufferToImage<D, float>(net, "A", "AImage",
+    BufferToImage<D, float>(&net, "A", "AImage",
                             kernels::BufferType::IN_OUT_WIDTH);
-    BufferToImage<D, float>(net, "B", "BImage",
+    BufferToImage<D, float>(&net, "B", "BImage",
                             kernels::BufferType::IN_OUT_HEIGHT);
 
     OpDefBuilder("MatMul", "MatMulTest")
@@ -38,7 +38,7 @@ void Simple(const std::vector<index_t> &A_shape,
     net.RunOp(D);
 
     // Transfer output
-    ImageToBuffer<D, float>(net, "OutputImage", "Output",
+    ImageToBuffer<D, float>(&net, "OutputImage", "Output",
                             kernels::BufferType::IN_OUT_HEIGHT);
   } else {
     OpDefBuilder("MatMul", "MatMulTest")
@@ -124,9 +124,9 @@ void Complex(const index_t batch,
   expected.Copy(*net.GetOutput("Output"));
 
   // Run on opencl
-  BufferToImage<DeviceType::OPENCL, T>(net, "A", "AImage",
+  BufferToImage<DeviceType::OPENCL, T>(&net, "A", "AImage",
                                        kernels::BufferType::IN_OUT_WIDTH);
-  BufferToImage<DeviceType::OPENCL, T>(net, "B", "BImage",
+  BufferToImage<DeviceType::OPENCL, T>(&net, "B", "BImage",
                                        kernels::BufferType::IN_OUT_HEIGHT);
 
   OpDefBuilder("MatMul", "MatMulTest")
@@ -139,7 +139,7 @@ void Complex(const index_t batch,
   // Run on opencl
   net.RunOp(DeviceType::OPENCL);
 
-  ImageToBuffer<DeviceType::OPENCL, float>(net, "OutputImage", "OPENCLOutput",
+  ImageToBuffer<DeviceType::OPENCL, float>(&net, "OutputImage", "OPENCLOutput",
                                            kernels::BufferType::IN_OUT_HEIGHT);
   if (DataTypeToEnum<T>::value == DataType::DT_HALF) {
     ExpectTensorNear<float>(expected, *net.GetOutput("OPENCLOutput"), 1e-1);
@@ -170,4 +170,4 @@ TEST_F(MatMulOpTest, OPENCLHalfUnAlignedWithBatch) {
   Complex<half>(16, 32, 64, 64);
   Complex<half>(31, 31, 61, 67);
 }
-}
+}  // namespace mace

mace/ops/ops_test_util.h

@@ -2,10 +2,16 @@
 // Copyright (c) 2017 XiaoMi All rights reserved.
 //
 
-#ifndef MACE_OPS_TEST_UTIL_H_
-#define MACE_OPS_TEST_UTIL_H_
+#ifndef MACE_OPS_OPS_TEST_UTIL_H_
+#define MACE_OPS_OPS_TEST_UTIL_H_
 
+#include <functional>
+#include <limits>
+#include <memory>
+#include <string>
 #include <type_traits>
+#include <utility>
+#include <vector>
 
 #include "gtest/gtest.h"
 #include "mace/core/net.h"
@@ -95,7 +101,7 @@ class OpDefBuilder {
 
 class OpsTestNet {
  public:
-  OpsTestNet() : op_registry_(new OperatorRegistry()){};
+  OpsTestNet() : op_registry_(new OperatorRegistry()) {}
 
   template <DeviceType D, typename T>
   void AddInputFromArray(const std::string &name,
@@ -204,37 +210,41 @@ class OpsTestBase : public ::testing::Test {
 
 template <typename T>
 void GenerateRandomRealTypeData(const std::vector<index_t> &shape,
-                                std::vector<T> &res) {
+                                std::vector<T> *res) {
+  MACE_CHECK_NOTNULL(res);
+
   std::random_device rd;
   std::mt19937 gen(rd());
   std::normal_distribution<float> nd(0, 1);
 
   index_t size = std::accumulate(shape.begin(), shape.end(), 1,
                                  std::multiplies<index_t>());
-  res.resize(size);
+  res->resize(size);
 
   if (DataTypeToEnum<T>::value == DT_HALF) {
-    std::generate(res.begin(), res.end(),
+    std::generate(res->begin(), res->end(),
                   [&gen, &nd] { return half_float::half_cast<half>(nd(gen)); });
   } else {
-    std::generate(res.begin(), res.end(), [&gen, &nd] { return nd(gen); });
+    std::generate(res->begin(), res->end(), [&gen, &nd] { return nd(gen); });
   }
 }
 
 template <typename T>
 void GenerateRandomIntTypeData(const std::vector<index_t> &shape,
-                               std::vector<T> &res,
+                               std::vector<T> *res,
                                const T a = 0,
                                const T b = std::numeric_limits<T>::max()) {
+  MACE_CHECK_NOTNULL(res);
+
   std::random_device rd;
   std::mt19937 gen(rd());
   std::uniform_int_distribution<> nd(a, b);
 
   index_t size = std::accumulate(shape.begin(), shape.end(), 1,
                                  std::multiplies<index_t>());
-  res.resize(size);
+  res->resize(size);
 
-  std::generate(res.begin(), res.end(), [&gen, &nd] { return nd(gen); });
+  std::generate(res->begin(), res->end(), [&gen, &nd] { return nd(gen); });
 }
 
 template <typename T>
@@ -377,25 +387,26 @@ void ExpectTensorNear(const Tensor &x, const Tensor &y, const double abs_err) {
 }
 
 template <DeviceType D, typename T>
-void BufferToImage(OpsTestNet &net,
+void BufferToImage(OpsTestNet *net,
                    const std::string &input_name,
                    const std::string &output_name,
                    const kernels::BufferType type) {
+  MACE_CHECK_NOTNULL(net);
   OpDefBuilder("BufferToImage", "BufferToImageTest")
       .Input(input_name)
       .Output(output_name)
       .AddIntArg("buffer_type", type)
       .AddIntArg("T", static_cast<int>(DataTypeToEnum<T>::value))
-      .Finalize(net.NewOperatorDef());
+      .Finalize(net->NewOperatorDef());
 
   // Run
-  net.RunOp(D);
+  net->RunOp(D);
 
-  net.Sync();
+  net->Sync();
 }
 
 template <DeviceType D, typename T>
-void ImageToBuffer(OpsTestNet &net,
+void ImageToBuffer(OpsTestNet *net,
                    const std::string &input_name,
                    const std::string &output_name,
                    const kernels::BufferType type) {
@@ -404,14 +415,14 @@ void ImageToBuffer(OpsTestNet &net,
       .Output(output_name)
       .AddIntArg("buffer_type", type)
       .AddIntArg("T", static_cast<int>(DataTypeToEnum<T>::value))
-      .Finalize(net.NewOperatorDef());
+      .Finalize(net->NewOperatorDef());
 
   // Run
-  net.RunOp(D);
+  net->RunOp(D);
 
-  net.Sync();
+  net->Sync();
 }
 
 }  // namespace mace
 
-#endif  // MACE_OPS_TEST_UTIL_H_
+#endif  // MACE_OPS_OPS_TEST_UTIL_H_

mace/ops/pooling.h

@@ -5,6 +5,8 @@
 #ifndef MACE_OPS_POOLING_H_
 #define MACE_OPS_POOLING_H_
 
+#include <vector>
+
 #include "mace/core/operator.h"
 #include "mace/kernels/pooling.h"
 #include "mace/ops/conv_pool_2d_base.h"
@@ -25,7 +27,7 @@ class PoolingOp : public ConvPool2dOpBase<D, T> {
                  this->strides_.data(),
                  this->padding_type_,
                  this->paddings_,
-                 this->dilations_.data()){};
+                 this->dilations_.data()) {}
 
   bool Run(StatsFuture *future) override {
     const Tensor *input = this->Input(INPUT);

mace/ops/pooling_benchmark.cc

@@ -8,8 +8,8 @@
 #include "mace/kernels/conv_pool_2d_util.h"
 #include "mace/ops/ops_test_util.h"
 
-using namespace mace;
-using namespace mace::kernels;
+namespace mace {
+namespace kernels {
 
 template <DeviceType D>
 static void Pooling(int iters,
@@ -49,18 +49,20 @@ static void Pooling(int iters,
   }
 }
 
-#define BM_POOLING_MACRO(N, C, H, W, KE, STRIDE, PA, PO, DEVICE)                    \
-  static void                                                                       \
-      BM_POOLING_##N##_##C##_##H##_##W##_K##KE##S##STRIDE##_##PA##_##PO##_##DEVICE( \
-          int iters) {                                                              \
-    const int64_t tot = static_cast<int64_t>(iters) * N * C * H * W;                \
-    mace::testing::MaccProcessed(tot);                                              \
-    mace::testing::BytesProcessed(tot *(sizeof(float)));                            \
-    Pooling<DEVICE>(iters, N, C, H, W, KE, STRIDE, Padding::PA,                     \
-                    PoolingType::PO);                                               \
-  }                                                                                 \
-  BENCHMARK(                                                                        \
-      BM_POOLING_##N##_##C##_##H##_##W##_K##KE##S##STRIDE##_##PA##_##PO##_##DEVICE)
+#define BM_POOLING_MACRO(N, C, H, W, KE, STRIDE, PA, PO, DEVICE)          \
+  static void                                                             \
+      BM_POOLING_##N##_##C##_##H##_##W##_K##KE##S##STRIDE##_##PA##_##PO##_\
+        ##DEVICE(                                                         \
+          int iters) {                                                    \
+    const int64_t tot = static_cast<int64_t>(iters) * N * C * H * W;      \
+    mace::testing::MaccProcessed(tot);                                    \
+    mace::testing::BytesProcessed(tot *(sizeof(float)));                  \
+    Pooling<DEVICE>(iters, N, C, H, W, KE, STRIDE, Padding::PA,           \
+                    PoolingType::PO);                                     \
+  }                                                                       \
+  BENCHMARK(                                                              \
+      BM_POOLING_##N##_##C##_##H##_##W##_K##KE##S##STRIDE##_##PA##_##PO##_\
+        ##DEVICE)
 
 #define BM_POOLING(N, C, H, W, K, S, PA, PO) \
   BM_POOLING_MACRO(N, C, H, W, K, S, PA, PO, CPU);
@@ -70,3 +72,6 @@ BM_POOLING(1, 3, 129, 129, 2, 2, SAME, MAX);
 BM_POOLING(1, 3, 257, 257, 2, 2, SAME, MAX);
 BM_POOLING(1, 3, 513, 513, 2, 2, SAME, MAX);
 BM_POOLING(1, 3, 1025, 1025, 2, 2, SAME, MAX);
+
+}  // namespace kernels
+}  // namespace mace

mace/ops/pooling_test.cc

@@ -9,7 +9,7 @@
 #include "mace/ops/conv_pool_2d_base.h"
 #include "mace/ops/ops_test_util.h"
 
-using namespace mace;
+namespace mace {
 
 class PoolingOpTest : public OpsTestBase {};
 
@@ -133,7 +133,7 @@ static void SimpleMaxPooling3S2() {
        14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26});
 
   if (D == DeviceType::OPENCL) {
-    BufferToImage<D, float>(net, "Input", "InputImage",
+    BufferToImage<D, float>(&net, "Input", "InputImage",
                             kernels::BufferType::IN_OUT_CHANNEL);
     OpDefBuilder("Pooling", "PoolingTest")
         .Input("InputImage")
@@ -145,7 +145,7 @@ static void SimpleMaxPooling3S2() {
         .AddIntsArg("dilations", {1, 1})
         .Finalize(net.NewOperatorDef());
     net.RunOp(D);
-    ImageToBuffer<D, float>(net, "OutputImage", "Output",
+    ImageToBuffer<D, float>(&net, "OutputImage", "Output",
                             kernels::BufferType::IN_OUT_CHANNEL);
   } else {
     // Run
@@ -198,7 +198,7 @@ static void MaxPooling3S2(const std::vector<index_t> &input_shape,
   Tensor expected;
   expected.Copy(*net.GetOutput("Output"));
 
-  BufferToImage<D, T>(net, "Input", "InputImage",
+  BufferToImage<D, T>(&net, "Input", "InputImage",
                       kernels::BufferType::IN_OUT_CHANNEL);
   OpDefBuilder("Pooling", "PoolingTest")
       .Input("InputImage")
@@ -211,7 +211,7 @@ static void MaxPooling3S2(const std::vector<index_t> &input_shape,
       .AddIntArg("T", static_cast<int>(DataTypeToEnum<T>::value))
       .Finalize(net.NewOperatorDef());
   net.RunOp(D);
-  ImageToBuffer<D, T>(net, "OutputImage", "OPENCLOutput",
+  ImageToBuffer<D, T>(&net, "OutputImage", "OPENCLOutput",
                       kernels::BufferType::IN_OUT_CHANNEL);
 
   ExpectTensorNear<T>(expected, *net.GetOutput("OPENCLOutput"), 0.001);
@@ -283,7 +283,7 @@ static void SimpleAvgPoolingTest() {
       "Input", {1, 2, 8, 1},
       {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15});
 
-  BufferToImage<D, float>(net, "Input", "InputImage",
+  BufferToImage<D, float>(&net, "Input", "InputImage",
                           kernels::BufferType::IN_OUT_CHANNEL);
   OpDefBuilder("Pooling", "PoolingTest")
       .Input("InputImage")
@@ -296,7 +296,7 @@ static void SimpleAvgPoolingTest() {
       .Finalize(net.NewOperatorDef());
   // Run
   net.RunOp(D);
-  ImageToBuffer<D, float>(net, "OutputImage", "Output",
+  ImageToBuffer<D, float>(&net, "OutputImage", "Output",
                           kernels::BufferType::IN_OUT_CHANNEL);
 
   // Check
@@ -334,7 +334,7 @@ static void AvgPoolingTest(const std::vector<index_t> &shape,
   Tensor expected;
   expected.Copy(*net.GetOutput("Output"));
 
-  BufferToImage<D, T>(net, "Input", "InputImage",
+  BufferToImage<D, T>(&net, "Input", "InputImage",
                       kernels::BufferType::IN_OUT_CHANNEL);
   OpDefBuilder("Pooling", "PoolingTest")
       .Input("InputImage")
@@ -347,7 +347,7 @@ static void AvgPoolingTest(const std::vector<index_t> &shape,
       .AddIntArg("T", static_cast<int>(DataTypeToEnum<T>::value))
       .Finalize(net.NewOperatorDef());
   net.RunOp(D);
-  ImageToBuffer<D, T>(net, "OutputImage", "OPENCLOutput",
+  ImageToBuffer<D, T>(&net, "OutputImage", "OPENCLOutput",
                       kernels::BufferType::IN_OUT_CHANNEL);
 
   ExpectTensorNear<float, T>(expected, *net.GetOutput("OPENCLOutput"), 0.01);
@@ -393,3 +393,5 @@ TEST_F(PoolingOpTest, OPENCLUnAlignedLargeKernelAvgPooling) {
   AvgPoolingTest<OPENCL, float>({3, 31, 37, 128}, {8, 8}, {8, 8},
                                 Padding::SAME);
 }
+
+}  // namespace mace

mace/ops/reshape.h

@@ -5,6 +5,8 @@
 #ifndef MACE_OPS_RESHAPE_H_
 #define MACE_OPS_RESHAPE_H_
 
+#include <vector>
+
 #include "mace/core/operator.h"
 #include "mace/kernels/reshape.h"
 

mace/ops/reshape_test.cc

@@ -6,7 +6,7 @@
 #include "mace/core/operator.h"
 #include "mace/ops/ops_test_util.h"
 
-using namespace mace;
+namespace mace {
 
 class ReshapeTest : public OpsTestBase {};
 
@@ -53,3 +53,5 @@ TEST_F(ReshapeTest, Complex) {
   TestReshape({1, 2, 3, 4}, {-1, 1}, {24, 1});
   TestReshape({1, 2, 3, 4}, {1, 3, 8}, {1, 3, 8});
 }
+
+}  // namespace mace

mace/ops/resize_bilinear.h

@@ -2,8 +2,8 @@
 // Copyright (c) 2017 XiaoMi All rights reserved.
 //
 
-#ifndef MACE_RESIZE_BILINEAR_H
-#define MACE_RESIZE_BILINEAR_H
+#ifndef MACE_OPS_RESIZE_BILINEAR_H_
+#define MACE_OPS_RESIZE_BILINEAR_H_
 
 #include "mace/core/operator.h"
 #include "mace/kernels/resize_bilinear.h"
@@ -36,4 +36,4 @@ class ResizeBilinearOp : public Operator<D, T> {
 
 }  // namespace mace
 
-#endif  // MACE_RESIZE_BILINEAR_H
+#endif  // MACE_OPS_RESIZE_BILINEAR_H_

mace/ops/resize_bilinear_benchmark.cc

@@ -26,7 +26,7 @@ static void ResizeBilinearBenchmark(int iters,
   net.AddInputFromArray<D, index_t>("OutSize", {2},
                                     {output_height, output_width});
   if (D == DeviceType::OPENCL) {
-    BufferToImage<D, T>(net, "Input", "InputImage",
+    BufferToImage<D, T>(&net, "Input", "InputImage",
                         kernels::BufferType::IN_OUT_CHANNEL);
     OpDefBuilder("ResizeBilinear", "ResizeBilinearBenchmark")
         .Input("InputImage")
@@ -57,18 +57,20 @@ static void ResizeBilinearBenchmark(int iters,
   net.Sync();
 }
 
-#define BM_RESIZE_BILINEAR_MACRO(N, C, H0, W0, H1, W1, TYPE, DEVICE)                \
-  static void                                                                       \
-      BM_RESIZE_BILINEAR_##N##_##C##_##H0##_##W0##_##H1##_##W1##_##TYPE##_##DEVICE( \
-          int iters) {                                                              \
-    const int64_t macc = static_cast<int64_t>(iters) * N * C * H1 * W1 * 3;         \
-    const int64_t tot = static_cast<int64_t>(iters) * N * C * H0 * W0;              \
-    mace::testing::MaccProcessed(macc);                                             \
-    mace::testing::BytesProcessed(tot *(sizeof(TYPE)));                             \
-    ResizeBilinearBenchmark<DEVICE, TYPE>(iters, N, C, H0, W0, H1, W1);             \
-  }                                                                                 \
-  BENCHMARK(                                                                        \
-      BM_RESIZE_BILINEAR_##N##_##C##_##H0##_##W0##_##H1##_##W1##_##TYPE##_##DEVICE)
+#define BM_RESIZE_BILINEAR_MACRO(N, C, H0, W0, H1, W1, TYPE, DEVICE)        \
+  static void                                                               \
+      BM_RESIZE_BILINEAR_##N##_##C##_##H0##_##W0##_##H1##_##W1##_##TYPE##_\
+        ##DEVICE(                                                           \
+          int iters) {                                                      \
+    const int64_t macc = static_cast<int64_t>(iters) * N * C * H1 * W1 * 3; \
+    const int64_t tot = static_cast<int64_t>(iters) * N * C * H0 * W0;      \
+    mace::testing::MaccProcessed(macc);                                     \
+    mace::testing::BytesProcessed(tot *(sizeof(TYPE)));                     \
+    ResizeBilinearBenchmark<DEVICE, TYPE>(iters, N, C, H0, W0, H1, W1);     \
+  }                                                                         \
+  BENCHMARK(                                                                \
+      BM_RESIZE_BILINEAR_##N##_##C##_##H0##_##W0##_##H1##_##W1##_##TYPE##_\
+        ##DEVICE)
 
 #define BM_RESIZE_BILINEAR(N, C, H0, W0, H1, W1)                 \
   BM_RESIZE_BILINEAR_MACRO(N, C, H0, W0, H1, W1, float, CPU);    \

mace/ops/resize_bilinear_test.cc

@@ -2,11 +2,13 @@
 // Copyright (c) 2017 XiaoMi All rights reserved.
 //
 
+#include <vector>
+
 #include "mace/ops/resize_bilinear.h"
 #include "mace/core/operator.h"
 #include "mace/ops/ops_test_util.h"
 
-using namespace mace;
+namespace mace {
 
 class ResizeBilinearTest : public OpsTestBase {};
 
@@ -61,17 +63,17 @@ TEST_F(ResizeBilinearTest, ResizeBilinearWAlignCorners) {
 
 template <DeviceType D>
 void TestRandomResizeBilinear() {
-  srand(time(nullptr));
+  unsigned int seed = time(nullptr);
   testing::internal::LogToStderr();
 
   for (int round = 0; round < 10; ++round) {
-    int batch = 1 + rand() % 5;
-    int channels = 1 + rand() % 100;
-    int height = 1 + rand() % 100;
-    int width = 1 + rand() % 100;
-    int in_height = 1 + rand() % 100;
-    int in_width = 1 + rand() % 100;
-    int align_corners = rand() % 1;
+    int batch = 1 + rand_r(&seed) % 5;
+    int channels = 1 + rand_r(&seed) % 100;
+    int height = 1 + rand_r(&seed) % 100;
+    int width = 1 + rand_r(&seed) % 100;
+    int in_height = 1 + rand_r(&seed) % 100;
+    int in_width = 1 + rand_r(&seed) % 100;
+    int align_corners = rand_r(&seed) % 1;
 
     // Construct graph
     OpsTestNet net;
@@ -91,7 +93,7 @@ void TestRandomResizeBilinear() {
     expected.Copy(*net.GetOutput("Output"));
 
     if (D == DeviceType::OPENCL) {
-      BufferToImage<D, float>(net, "Input", "InputImage",
+      BufferToImage<D, float>(&net, "Input", "InputImage",
                               kernels::BufferType::IN_OUT_CHANNEL);
 
       OpDefBuilder("ResizeBilinear", "ResizeBilinearTest")
@@ -103,10 +105,10 @@ void TestRandomResizeBilinear() {
       // Run
       net.RunOp(D);
 
-      ImageToBuffer<D, float>(net, "OutputImage", "DeviceOutput",
+      ImageToBuffer<D, float>(&net, "OutputImage", "DeviceOutput",
                               kernels::BufferType::IN_OUT_CHANNEL);
     } else {
-      // TODO support NEON
+      // TODO(yejianwu) support NEON
     }
     // Check
     ExpectTensorNear<float>(expected, *net.GetOutput("DeviceOutput"), 0.001);
@@ -122,3 +124,5 @@ TEST_F(ResizeBilinearTest, NEONRandomResizeBilinear) {
 TEST_F(ResizeBilinearTest, OPENCLRandomResizeBilinear) {
   TestRandomResizeBilinear<DeviceType::OPENCL>();
 }
+
+}  // namespace mace

mace/ops/slice.h

@@ -5,6 +5,8 @@
 #ifndef MACE_OPS_SLICE_H_
 #define MACE_OPS_SLICE_H_
 
+#include <vector>
+
 #include "mace/core/operator.h"
 #include "mace/kernels/slice.h"
 namespace mace {
@@ -16,10 +18,12 @@ class SliceOp : public Operator<D, T> {
       : Operator<D, T>(op_def, ws) {}
 
   bool Run(StatsFuture *future) override {
-    MACE_CHECK(this->OutputSize() >= 2) << "There must be at least two outputs for slicing";
+    MACE_CHECK(this->OutputSize() >= 2)
+      << "There must be at least two outputs for slicing";
     const Tensor *input = this->Input(INPUT);
     const std::vector<Tensor *> output_list = this->Outputs();
-    MACE_CHECK((input->dim(3) % this->OutputSize()) == 0) << "Outputs do not split input equally.";
+    MACE_CHECK((input->dim(3) % this->OutputSize()) == 0)
+      << "Outputs do not split input equally.";
 
     functor_(input, output_list, future);
     return true;

mace/ops/slice_benchmark.cc

@@ -16,13 +16,16 @@ static void BMSliceHelper(int iters,
   // Construct graph
   OpsTestNet net;
 
-  const index_t input_size = std::accumulate(input_shape.begin(), input_shape.end(), 1, std::multiplies<index_t>());
+  const index_t input_size = std::accumulate(input_shape.begin(),
+                                             input_shape.end(),
+                                             1,
+                                             std::multiplies<index_t>());
   std::vector<float> input_data(input_size);
-  GenerateRandomRealTypeData(input_shape, input_data);
+  GenerateRandomRealTypeData(input_shape, &input_data);
   net.AddInputFromArray<D, float>("Input", input_shape, input_data);
 
   if (D == DeviceType::OPENCL) {
-    BufferToImage<D, T>(net, "Input", "InputImage",
+    BufferToImage<D, T>(&net, "Input", "InputImage",
                         kernels::BufferType::IN_OUT_CHANNEL);
 
     auto builder = OpDefBuilder("Slice", "SliceTest");
@@ -55,14 +58,15 @@ static void BMSliceHelper(int iters,
   }
 }
 
-#define BM_SLICE_MACRO(N, H, W, C, NO, TYPE, DEVICE) \
-  static void BM_SLICE_##N##_##H##_##W##_##C##_##NO##_##TYPE##_##DEVICE(int iters) { \
-    const int64_t tot = static_cast<int64_t>(iters) * N * H * W * C;                 \
-    mace::testing::MaccProcessed(tot);                                               \
-    mace::testing::BytesProcessed(tot *(sizeof(TYPE)));                              \
-    BMSliceHelper<DEVICE, TYPE>(iters, {N, H, W, C}, NO);                            \
-  }                                                                                  \
-  BENCHMARK(BM_SLICE_##N##_##H##_##W##_##C##_##NO##_##TYPE##_##DEVICE)
+#define BM_SLICE_MACRO(N, H, W, C, NO, TYPE, DEVICE)                         \
+  static void                                                                \
+      BM_SLICE_##N##_##H##_##W##_##C##_##NO##_##TYPE##_##DEVICE(int iters) { \
+        const int64_t tot = static_cast<int64_t>(iters) * N * H * W * C;     \
+        mace::testing::MaccProcessed(tot);                                   \
+        mace::testing::BytesProcessed(tot *(sizeof(TYPE)));                  \
+        BMSliceHelper<DEVICE, TYPE>(iters, {N, H, W, C}, NO);                \
+      }                                                                      \
+      BENCHMARK(BM_SLICE_##N##_##H##_##W##_##C##_##NO##_##TYPE##_##DEVICE)
 
 #define BM_SLICE(N, H, W, C, NO)                 \
   BM_SLICE_MACRO(N, H, W, C, NO, float, CPU);    \

mace/ops/slice_test.cc

@@ -2,34 +2,40 @@
 // Copyright (c) 2017 XiaoMi All rights reserved.
 //
 
+#include <functional>
+#include <vector>
+
 #include "mace/ops/slice.h"
 #include "mace/ops/ops_test_util.h"
 #include "gmock/gmock.h"
 
-using namespace mace;
+namespace mace {
 
 class SliceOpTest : public OpsTestBase {};
 
 template<DeviceType D, typename T>
 void RandomTest(const int num_outputs) {
-  srand(time(nullptr));
-  const index_t output_channels = 4 * (1 + rand() % 10);
+  unsigned int seed = time(nullptr);
+  const index_t output_channels = 4 * (1 + rand_r(&seed) % 10);
   const index_t input_channels = num_outputs * output_channels;
-  const index_t batch = 3 + (rand() % 10);
-  const index_t height = 13 + (rand() % 10);
-  const index_t width = 17 + (rand() % 10);
+  const index_t batch = 3 + (rand_r(&seed) % 10);
+  const index_t height = 13 + (rand_r(&seed) % 10);
+  const index_t width = 17 + (rand_r(&seed) % 10);
 
   // Construct graph
   OpsTestNet net;
 
   std::vector<index_t> input_shape({batch, height, width, input_channels});
-  const index_t input_size = std::accumulate(input_shape.begin(), input_shape.end(), 1, std::multiplies<index_t>());
+  const index_t input_size = std::accumulate(input_shape.begin(),
+                                             input_shape.end(),
+                                             1,
+                                             std::multiplies<index_t>());
   std::vector<float> input_data(input_size);
-  GenerateRandomRealTypeData(input_shape, input_data);
+  GenerateRandomRealTypeData(input_shape, &input_data);
   net.AddInputFromArray<D, float>("Input", input_shape, input_data);
 
   if (D == DeviceType::OPENCL) {
-    BufferToImage<D, T>(net, "Input", "InputImage",
+    BufferToImage<D, T>(&net, "Input", "InputImage",
                         kernels::BufferType::IN_OUT_CHANNEL);
 
     auto builder = OpDefBuilder("Slice", "SliceTest");
@@ -47,7 +53,6 @@ void RandomTest(const int num_outputs) {
       builder = builder.Output(MakeString("Output", i));
     }
     builder.Finalize(net.NewOperatorDef());
-
   }
 
   // Run
@@ -55,15 +60,19 @@ void RandomTest(const int num_outputs) {
 
   if (D == DeviceType::OPENCL) {
     for (int i = 0; i < num_outputs; ++i) {
-      ImageToBuffer<D, float>(net, MakeString("OutputImage", i), MakeString("Output", i),
+      ImageToBuffer<D, float>(&net,
+                              MakeString("OutputImage", i),
+                              MakeString("Output", i),
                               kernels::BufferType::IN_OUT_CHANNEL);
     }
   }
 
   // Check
   std::vector<index_t> expected_shape({batch, height, width, output_channels});
-  const index_t outer_size = std::accumulate(expected_shape.begin(), expected_shape.end() - 1,
-                                             1, std::multiplies<index_t>());
+  const index_t outer_size = std::accumulate(expected_shape.begin(),
+                                             expected_shape.end() - 1,
+                                             1,
+                                             std::multiplies<index_t>());
   const float *input_ptr = input_data.data();
   const float *output_ptr;
   for (int i = 0; i < num_outputs; ++i) {
@@ -74,7 +83,8 @@ void RandomTest(const int num_outputs) {
     for (int outer_idx = 0; outer_idx < outer_size; ++outer_idx) {
       const int idx = outer_idx * input_channels + i * output_channels;
       for (int j = 0; j < output_channels; ++j) {
-        ASSERT_NEAR(*output_ptr++, input_ptr[idx + j], 1e-2) << "with output " << i << " index " << idx + j;
+        ASSERT_NEAR(*output_ptr++, input_ptr[idx + j], 1e-2) << "with output "
+          << i << " index " << idx + j;
       }
     }
   }
@@ -97,3 +107,5 @@ TEST_F(SliceOpTest, OPENCLHalf) {
   RandomTest<DeviceType::OPENCL, half>(4);
   RandomTest<DeviceType::OPENCL, half>(11);
 }
+
+}  // namespace mace

mace/ops/softmax.h

@@ -2,8 +2,8 @@
 // Copyright (c) 2017 XiaoMi All rights reserved.
 //
 
-#ifndef MACE_SOFTMAX_H_
-#define MACE_SOFTMAX_H_
+#ifndef MACE_OPS_SOFTMAX_H_
+#define MACE_OPS_SOFTMAX_H_
 
 #include "mace/core/operator.h"
 #include "mace/kernels/softmax.h"
@@ -36,4 +36,4 @@ class SoftmaxOp : public Operator<D, T> {
 
 }  // namespace mace
 
-#endif  // MACE_SOFTMAX_H_
+#endif  // MACE_OPS_SOFTMAX_H_

mace/ops/softmax_benchmark.cc

@@ -19,7 +19,7 @@ static void SoftmaxBenchmark(
   net.AddRandomInput<D, float>("Input", {batch, height, width, channels});
 
   if (D == DeviceType::OPENCL) {
-    BufferToImage<D, float>(net, "Input", "InputImage",
+    BufferToImage<D, float>(&net, "Input", "InputImage",
                             kernels::BufferType::IN_OUT_CHANNEL);
 
     OpDefBuilder("Softmax", "SoftmaxBM")

mace/ops/softmax_test.cc

@@ -18,7 +18,7 @@ void Simple() {
                                   {1, 1, 1, 1, 1, 2, 3, 4});
 
   if (D == DeviceType::OPENCL) {
-    BufferToImage<D, float>(net, "Input", "InputImage",
+    BufferToImage<D, float>(&net, "Input", "InputImage",
                             kernels::BufferType::IN_OUT_CHANNEL);
 
     OpDefBuilder("Softmax", "SoftmaxTest")
@@ -30,7 +30,7 @@ void Simple() {
     net.RunOp(D);
 
     // Transfer output
-    ImageToBuffer<D, float>(net, "OutputImage", "Output",
+    ImageToBuffer<D, float>(&net, "OutputImage", "Output",
                             kernels::BufferType::IN_OUT_CHANNEL);
   } else {
     OpDefBuilder("Softmax", "SoftmaxTest")
@@ -69,7 +69,7 @@ void Complex(const std::vector<index_t> &logits_shape) {
   Tensor expected;
   expected.Copy(*net.GetOutput("Output"));
 
-  BufferToImage<D, float>(net, "Input", "InputImage",
+  BufferToImage<D, float>(&net, "Input", "InputImage",
                           kernels::BufferType::IN_OUT_CHANNEL);
 
   OpDefBuilder("Softmax", "SoftmaxTest")
@@ -81,7 +81,7 @@ void Complex(const std::vector<index_t> &logits_shape) {
   net.RunOp(D);
 
   // Transfer output
-  ImageToBuffer<D, float>(net, "OutputImage", "OPENCLOutput",
+  ImageToBuffer<D, float>(&net, "OutputImage", "OPENCLOutput",
                           kernels::BufferType::IN_OUT_CHANNEL);
 
   ExpectTensorNear<float>(expected, *net.GetOutput("OPENCLOutput"), 1e-5);

mace/ops/space_to_batch.h

@@ -6,6 +6,7 @@
 #define MACE_OPS_SPACE_TO_BATCH_H_
 
 #include <memory>
+#include <vector>
 
 #include "mace/core/operator.h"
 #include "mace/kernels/space_to_batch.h"

mace/ops/space_to_batch_benchmark.cc

@@ -15,7 +15,7 @@ static void BMSpaceToBatch(
   OpsTestNet net;
   net.AddRandomInput<D, float>("Input", {batch, height, width, channels});
 
-  BufferToImage<D, float>(net, "Input", "InputImage",
+  BufferToImage<D, float>(&net, "Input", "InputImage",
                           kernels::BufferType::IN_OUT_CHANNEL);
   OpDefBuilder("SpaceToBatchND", "SpaceToBatchNDTest")
       .Input("InputImage")

mace/ops/space_to_batch_test.cc

@@ -6,7 +6,7 @@
 #include "gtest/gtest.h"
 #include "mace/ops/ops_test_util.h"
 
-using namespace mace;
+namespace mace {
 
 template <DeviceType D>
 void RunSpaceToBatch(const std::vector<index_t> &input_shape,
@@ -17,7 +17,7 @@ void RunSpaceToBatch(const std::vector<index_t> &input_shape,
   OpsTestNet net;
   net.AddInputFromArray<D, float>("Input", input_shape, input_data);
 
-  BufferToImage<D, float>(net, "Input", "InputImage",
+  BufferToImage<D, float>(&net, "Input", "InputImage",
                           kernels::BufferType::IN_OUT_CHANNEL);
   OpDefBuilder("SpaceToBatchND", "SpaceToBatchNDTest")
       .Input("InputImage")
@@ -29,7 +29,7 @@ void RunSpaceToBatch(const std::vector<index_t> &input_shape,
   // Run
   net.RunOp(D);
 
-  ImageToBuffer<D, float>(net, "OutputImage", "Output",
+  ImageToBuffer<D, float>(&net, "OutputImage", "Output",
                           kernels::BufferType::IN_OUT_CHANNEL);
   // Check
   ExpectTensorNear<float>(*expected, *net.GetOutput("Output"), 1e-8);
@@ -45,7 +45,7 @@ void RunBatchToSpace(const std::vector<index_t> &input_shape,
   // Add input data
   net.AddInputFromArray<D, float>("Input", input_shape, input_data);
 
-  BufferToImage<D, float>(net, "Input", "InputImage",
+  BufferToImage<D, float>(&net, "Input", "InputImage",
                           kernels::BufferType::IN_OUT_CHANNEL);
   OpDefBuilder("BatchToSpaceND", "BatchToSpaceNDTest")
       .Input("InputImage")
@@ -57,7 +57,7 @@ void RunBatchToSpace(const std::vector<index_t> &input_shape,
   // Run
   net.RunOp(D);
 
-  ImageToBuffer<D, float>(net, "OutputImage", "Output",
+  ImageToBuffer<D, float>(&net, "OutputImage", "Output",
                           kernels::BufferType::IN_OUT_CHANNEL);
   // Check
   ExpectTensorNear<float>(*expected, *net.GetOutput("Output"), 1e-8);
@@ -216,3 +216,5 @@ TEST(SpaceToBatchTest, MultiBatchAndChannelData) {
 //                                      {2, 2, 2, 2},
 //                                      space_tensor.get());
 //}
+
+}  // namespace mace

mace/ops/winograd_convolution_test.cc

@@ -13,8 +13,9 @@ class WinogradConvlutionTest : public OpsTestBase {};
 
 void TransposeFilter(const std::vector<float> &input,
                      const std::vector<index_t> &input_shape,
-                     std::vector<float> &output) {
-  output.resize(input.size());
+                     std::vector<float> *output) {
+  MACE_CHECK_NOTNULL(output);
+  output->resize(input.size());
 
   const float *input_ptr = input.data();
   for (index_t h = 0; h < input_shape[0]; ++h) {
@@ -24,7 +25,7 @@ void TransposeFilter(const std::vector<float> &input,
           int offset = ((oc * input_shape[3] + ic) * input_shape[0] + h) *
                            input_shape[1] +
                        w;
-          output[offset] = *input_ptr;
+          (*output)[offset] = *input_ptr;
           ++input_ptr;
         }
       }
@@ -46,16 +47,16 @@ void WinogradConvolution(const index_t batch,
   // Add input data
   std::vector<float> filter_data;
   std::vector<index_t> filter_shape = {3, 3, out_channels, in_channels};
-  GenerateRandomRealTypeData<float>(filter_shape, filter_data);
+  GenerateRandomRealTypeData<float>(filter_shape, &filter_data);
   net.AddRandomInput<D, float>("Input", {batch, height, width, in_channels});
   net.AddInputFromArray<D, float>("Filter", filter_shape, filter_data);
   net.AddRandomInput<D, T>("Bias", {out_channels});
 
-  BufferToImage<D, T>(net, "Input", "InputImage",
+  BufferToImage<D, T>(&net, "Input", "InputImage",
                       kernels::BufferType::IN_OUT_CHANNEL);
-  BufferToImage<D, T>(net, "Filter", "FilterImage",
+  BufferToImage<D, T>(&net, "Filter", "FilterImage",
                       kernels::BufferType::CONV2D_FILTER);
-  BufferToImage<D, T>(net, "Bias", "BiasImage", kernels::BufferType::ARGUMENT);
+  BufferToImage<D, T>(&net, "Bias", "BiasImage", kernels::BufferType::ARGUMENT);
   OpDefBuilder("Conv2D", "Conv2dTest")
       .Input("InputImage")
       .Input("FilterImage")
@@ -69,7 +70,7 @@ void WinogradConvolution(const index_t batch,
   net.RunOp(D);
 
   // Transfer output
-  ImageToBuffer<D, T>(net, "OutputImage", "ConvOutput",
+  ImageToBuffer<D, T>(&net, "OutputImage", "ConvOutput",
                       kernels::BufferType::IN_OUT_CHANNEL);
   Tensor expected;
   expected.Copy(*net.GetOutput("ConvOutput"));
@@ -78,10 +79,10 @@ void WinogradConvolution(const index_t batch,
   // Winograd convolution
   // transform filter
   std::vector<float> wino_filter_data;
-  TransposeFilter(filter_data, filter_shape, wino_filter_data);
+  TransposeFilter(filter_data, filter_shape, &wino_filter_data);
   net.AddInputFromArray<D, float>(
       "WinoFilterData", {out_channels, in_channels, 3, 3}, wino_filter_data);
-  BufferToImage<D, T>(net, "WinoFilterData", "WinoFilter",
+  BufferToImage<D, T>(&net, "WinoFilterData", "WinoFilter",
                       kernels::BufferType::WINOGRAD_FILTER);
 
   // transform input
@@ -119,7 +120,7 @@ void WinogradConvolution(const index_t batch,
   net.RunOp(D);
   net.Sync();
 
-  ImageToBuffer<D, float>(net, "WinoOutputImage", "WinoOutput",
+  ImageToBuffer<D, float>(&net, "WinoOutputImage", "WinoOutput",
                           kernels::BufferType::IN_OUT_CHANNEL);
   if (DataTypeToEnum<T>::value == DataType::DT_HALF) {
     ExpectTensorNear<float>(expected, *net.GetOutput("WinoOutput"), 1e-1);
@@ -163,16 +164,16 @@ void WinogradConvolutionWithPad(const index_t batch,
   // Add input data
   std::vector<float> filter_data;
   std::vector<index_t> filter_shape = {3, 3, out_channels, in_channels};
-  GenerateRandomRealTypeData<float>(filter_shape, filter_data);
+  GenerateRandomRealTypeData<float>(filter_shape, &filter_data);
   net.AddRandomInput<D, float>("Input", {batch, height, width, in_channels});
   net.AddInputFromArray<D, float>("Filter", filter_shape, filter_data);
   net.AddRandomInput<D, T>("Bias", {out_channels});
 
-  BufferToImage<D, T>(net, "Input", "InputImage",
+  BufferToImage<D, T>(&net, "Input", "InputImage",
                       kernels::BufferType::IN_OUT_CHANNEL);
-  BufferToImage<D, T>(net, "Filter", "FilterImage",
+  BufferToImage<D, T>(&net, "Filter", "FilterImage",
                       kernels::BufferType::CONV2D_FILTER);
-  BufferToImage<D, T>(net, "Bias", "BiasImage", kernels::BufferType::ARGUMENT);
+  BufferToImage<D, T>(&net, "Bias", "BiasImage", kernels::BufferType::ARGUMENT);
   OpDefBuilder("Conv2D", "Conv2dTest")
       .Input("InputImage")
       .Input("FilterImage")
@@ -186,7 +187,7 @@ void WinogradConvolutionWithPad(const index_t batch,
   net.RunOp(D);
 
   // Transfer output
-  ImageToBuffer<D, T>(net, "OutputImage", "ConvOutput",
+  ImageToBuffer<D, T>(&net, "OutputImage", "ConvOutput",
                       kernels::BufferType::IN_OUT_CHANNEL);
   Tensor expected;
   expected.Copy(*net.GetOutput("ConvOutput"));
@@ -195,10 +196,10 @@ void WinogradConvolutionWithPad(const index_t batch,
   // Winograd convolution
   // transform filter
   std::vector<float> wino_filter_data;
-  TransposeFilter(filter_data, filter_shape, wino_filter_data);
+  TransposeFilter(filter_data, filter_shape, &wino_filter_data);
   net.AddInputFromArray<D, float>(
       "WinoFilterData", {out_channels, in_channels, 3, 3}, wino_filter_data);
-  BufferToImage<D, T>(net, "WinoFilterData", "WinoFilter",
+  BufferToImage<D, T>(&net, "WinoFilterData", "WinoFilter",
                       kernels::BufferType::WINOGRAD_FILTER);
 
   // transform input
@@ -236,7 +237,7 @@ void WinogradConvolutionWithPad(const index_t batch,
   net.RunOp(D);
   net.Sync();
 
-  ImageToBuffer<D, float>(net, "WinoOutputImage", "WinoOutput",
+  ImageToBuffer<D, float>(&net, "WinoOutputImage", "WinoOutput",
                           kernels::BufferType::IN_OUT_CHANNEL);
   if (DataTypeToEnum<T>::value == DataType::DT_HALF) {
     ExpectTensorNear<float>(expected, *net.GetOutput("WinoOutput"), 1e-1);
@@ -250,4 +251,4 @@ TEST_F(WinogradConvlutionTest, UnAlignedConvolutionPad2) {
   WinogradConvolutionWithPad<DeviceType::OPENCL, float>(1, 32, 32, 96, 109, 2);
 }
 
-}
+}  // namespace mace

mace/ops/winograd_inverse_transform.h

@@ -6,6 +6,7 @@
 #define MACE_OPS_WINOGRAD_INVERSE_TRANSFORM_H_
 
 #include <memory>
+#include <string>
 
 #include "mace/core/operator.h"
 #include "mace/kernels/activation.h"

mace/ops/winograd_transform_benchmark.cc

@@ -15,7 +15,7 @@ static void BMWinogradTransform(
   OpsTestNet net;
   net.AddRandomInput<D, float>("Input", {batch, height, width, channels});
 
-  BufferToImage<D, T>(net, "Input", "InputImage",
+  BufferToImage<D, T>(&net, "Input", "InputImage",
                       kernels::BufferType::IN_OUT_CHANNEL);
   OpDefBuilder("WinogradTransform", "WinogradTransformTest")
       .Input("InputImage")
@@ -62,7 +62,7 @@ static void BMWinogradInverseTransform(
   OpsTestNet net;
   net.AddRandomInput<D, float>("Input", {16, channels, p, 1});
 
-  BufferToImage<D, T>(net, "Input", "InputImage",
+  BufferToImage<D, T>(&net, "Input", "InputImage",
                       kernels::BufferType::IN_OUT_HEIGHT);
   OpDefBuilder("WinogradInverseTransform", "WinogradInverseTransformTest")
       .Input("InputImage")