Merge remote-tracking branch 'upstream/develop' into develop

src/common/log.h

@@ -85,18 +85,18 @@ struct Print {
 
  private:
   void print(LogLevel level) {
-    buffer_ << std::endl;
+    // buffer_ << std::endl;
     if (level == kLOG_ERROR) {
-      std::cerr << buffer_.str();
+      std::cerr << buffer_.str() << std::endl;
     } else {
-      std::cout << buffer_.str();
+      std::cout << buffer_.str() << std::endl;
     }
   }
   std::ostringstream buffer_;
 };
 
 struct ToLog {
-  ToLog(LogLevel level = kLOG_DEBUG, const std::string &info = "")
+  explicit ToLog(LogLevel level = kLOG_DEBUG, const std::string &info = "")
       : level_(level) {
     unsigned blanks =
         (unsigned)(level > kLOG_DEBUG ? (level - kLOG_DEBUG) * 4 : 1);
@@ -175,11 +175,8 @@ struct Print {
   friend struct ToLog;
   template <typename T>
   Print &operator<<(T const &value) {
-    Print p = Print();
-    return p;
+    return *this;
   }
-
- private:
 };
 
 struct ToLog {

src/common/types.cpp

@@ -77,6 +77,12 @@ const char *G_OP_TYPE_CAST = "cast";
 const char *G_OP_TYPE_LOG = "log";
 const char *G_OP_TYPE_LOD_RESET = "lod_reset";
 const char *G_OP_TYPE_LESS_THAN = "less_than";
+const char *G_OP_TYPE_LOGICAL_AND = "logical_and";
+const char *G_OP_TYPE_LOGICAL_OR = "logical_or";
+const char *G_OP_TYPE_LOGICAL_NOT = "logical_not";
+const char *G_OP_TYPE_LOGICAL_XOR = "logical_xor";
+const char *G_OP_TYPE_WRITE_TO_ARRAY = "write_to_array";
+const char *G_OP_TYPE_READ_FROM_ARRAY = "read_from_array";
 
 const char *G_OP_TYPE_QUANTIZE = "quantize";
 const char *G_OP_TYPE_DEQUANTIZE = "dequantize";
@@ -181,5 +187,11 @@ std::unordered_map<
         {G_OP_TYPE_NORM, {{"X"}, {"Out", "Norm"}}},
         {G_OP_TYPE_LOG, {{"X"}, {"Out"}}},
         {G_OP_TYPE_LOD_RESET, {{"X", "Y"}, {"Out"}}},
-        {G_OP_TYPE_LESS_THAN, {{"X", "Y"}, {"Out"}}}};
+        {G_OP_TYPE_LESS_THAN, {{"X", "Y"}, {"Out"}}},
+        {G_OP_TYPE_LOGICAL_AND, {{"X", "Y"}, {"Out"}}},
+        {G_OP_TYPE_LOGICAL_OR, {{"X", "Y"}, {"Out"}}},
+        {G_OP_TYPE_LOGICAL_XOR, {{"X", "Y"}, {"Out"}}},
+        {G_OP_TYPE_LOGICAL_NOT, {{"X"}, {"Out"}}},
+        {G_OP_TYPE_WRITE_TO_ARRAY, {{"X", "I"}, {"Out"}}},
+        {G_OP_TYPE_READ_FROM_ARRAY, {{"X", "I"}, {"Out"}}}};
 }  // namespace paddle_mobile

src/common/types.h

@@ -131,9 +131,12 @@ extern const char *G_OP_TYPE_FUSION_CONV_BN_ADD_RELU;
 extern const char *G_OP_TYPE_FUSION_DWCONV_BN_RELU;
 extern const char *G_OP_TYPE_FUSION_CONV_BN_RELU;
 
+extern const char *G_OP_TYPE_GRU;
+extern const char *G_OP_TYPE_GRU_UNIT;
 extern const char *G_OP_TYPE_LRN;
 extern const char *G_OP_TYPE_MUL;
 extern const char *G_OP_TYPE_MULTICLASS_NMS;
+extern const char *G_OP_TYPE_NORM;
 extern const char *G_OP_TYPE_POOL2D;
 extern const char *G_OP_TYPE_PRIOR_BOX;
 extern const char *G_OP_TYPE_RELU;
@@ -163,6 +166,12 @@ extern const char *G_OP_TYPE_CAST;
 extern const char *G_OP_TYPE_LOG;
 extern const char *G_OP_TYPE_LOD_RESET;
 extern const char *G_OP_TYPE_LESS_THAN;
+extern const char *G_OP_TYPE_LOGICAL_AND;
+extern const char *G_OP_TYPE_LOGICAL_OR;
+extern const char *G_OP_TYPE_LOGICAL_NOT;
+extern const char *G_OP_TYPE_LOGICAL_XOR;
+extern const char *G_OP_TYPE_WRITE_TO_ARRAY;
+extern const char *G_OP_TYPE_READ_FROM_ARRAY;
 
 extern const char *G_OP_TYPE_QUANTIZE;
 extern const char *G_OP_TYPE_DEQUANTIZE;

src/framework/attribute.h

@@ -90,6 +90,10 @@ class Attribute {
         attr.Set<int64_t>(attr_desc->l);
         break;
       }
+      case PADDLE_MOBILE__FRAMEWORK__PROTO__ATTR_TYPE__BLOCK: {
+        attr.Set<int>(attr_desc->block_idx);
+        break;
+      }
       default:
         PADDLE_MOBILE_THROW_EXCEPTION("attr type not support");
     }

src/framework/executor.cpp

@@ -65,6 +65,7 @@ Executor<Device, T>::Executor(const Program<Device> &program,
     for (int j = 0; j < ops.size(); ++j) {
       std::shared_ptr<OpDesc> op_desc = ops[j];
       DLOG << "create op: " << op_desc->Type();
+
       auto op_handler = OpRegistry<Device>::CreateOp(
           op_desc->Type(), op_desc->GetInputs(), op_desc->GetOutputs(),
           op_desc->GetAttrMap(), program_.scope);

src/framework/load_ops.h

@@ -168,6 +168,9 @@ LOAD_FUSION_MATCHER(fusion_conv_bn_relu);
 #ifdef GRU_OP
 LOAD_OP1(gru, CPU);
 #endif
+#ifdef GRU_UNIT_OP
+LOAD_OP1(gru_unit, CPU);
+#endif
 #ifdef FUSION_CONVADDBN_OP
 LOAD_OP2(fusion_conv_add_bn, CPU, FPGA);
 LOAD_FUSION_MATCHER(fusion_conv_add_bn);
@@ -189,6 +192,9 @@ LOAD_OP1(crf_decoding, CPU);
 #ifdef MUL_OP
 LOAD_OP2(mul, CPU, MALI_GPU);
 #endif
+#ifdef NORM_OP
+LOAD_OP1(norm, CPU);
+#endif
 #ifdef RELU_OP
 LOAD_OP2(relu, CPU, MALI_GPU);
 LOAD_OP1(relu6, CPU);
@@ -279,3 +285,24 @@ LOAD_OP1(lod_reset, CPU);
 #ifdef LESS_THAN_OP
 LOAD_OP1(less_than, CPU);
 #endif
+#ifdef LOGICAL_AND_OP
+LOAD_OP1(logical_and, CPU);
+#endif
+#ifdef LOGICAL_OR_OP
+LOAD_OP1(logical_or, CPU);
+#endif
+#ifdef LOGICAL_NOT_OP
+LOAD_OP1(logical_not, CPU);
+#endif
+#ifdef LOGICAL_XOR_OP
+LOAD_OP1(logical_xor, CPU);
+#endif
+#ifdef WHILE_OP
+LOAD_OP1(while, CPU);
+#endif
+#ifdef WRITE_TO_ARRAY_OP
+LOAD_OP1(write_to_array, CPU);
+#endif
+#ifdef READ_FROM_ARRAY_OP
+LOAD_OP1(read_from_array, CPU);
+#endif

src/framework/lod_tensor.h

@@ -176,6 +176,8 @@ LoDTensor LodExpand(const LoDTensor &source, const LoD &lod, size_t level) {
   return tensor;
 }
 
+using LoDTensorArray = std::vector<LoDTensor>;
+
 // Get the absolute offset of a lod[start_level][start_idx:end_idx] and
 // relative length of details for every levels(i.e., [start_level: ]).
 //

src/framework/program/op_desc.cpp

@@ -41,9 +41,7 @@ OpDesc::OpDesc(PaddleMobile__Framework__Proto__OpDesc *desc) {
   for (int k = 0; k < desc->n_attrs; ++k) {
     PaddleMobile__Framework__Proto__OpDesc__Attr *attr = desc->attrs[k];
     std::string attr_name(attr->name);
-    if (attr->type != PADDLE_MOBILE__FRAMEWORK__PROTO__ATTR_TYPE__BLOCK) {
-      attrs_[attr_name] = Attribute::GetAttrValue(attr);
-    }
+    attrs_[attr_name] = Attribute::GetAttrValue(attr);
   }
 }
 

src/io/ios_io/PaddleMobileCPU.h

@@ -44,6 +44,11 @@
  */
 @property  (assign, nonatomic) BOOL optimize;
 
+/**
+ @b 是否预测时初始化内存，用于处理可变输入
+ */
+@property  (assign, nonatomic) BOOL loadWhenPredict;
+
 @end
 
 @interface PaddleMobileCPU : NSObject

src/io/ios_io/PaddleMobileCPU.mm

@@ -73,6 +73,8 @@ static std::mutex shared_mutex;
 
 - (instancetype)initWithConfig:(PaddleMobileCPUConfig *)config {
   if (self = [super init]) {
+    paddle_mobile::PaddleMobileConfigInternal configInternal;
+    configInternal.load_when_predict = config.loadWhenPredict;
     pam_ = new paddle_mobile::PaddleMobile<paddle_mobile::CPU, float>();
     _config = config;
   }

src/io/jni/PML.java

@@ -7,15 +7,7 @@ public class PML {
      * @param modelDir model dir
      * @return isloadsuccess
      */
-    public static native boolean load(String modelDir);
-
-    /**
-     * load seperated model
-     *
-     * @param modelDir model dir
-     * @return isloadsuccess
-     */
-    public static native boolean loadnlp(String modelDir);
+    public static native boolean load(String modelDir, Boolean lodMode);
 
     /**
      * load combined model
@@ -24,7 +16,7 @@ public class PML {
      * @param paramPath param file path
      * @return isloadsuccess
      */
-    public static native boolean loadCombined(String modelPath, String paramPath);
+    public static native boolean loadCombined(String modelPath, String paramPath, Boolean lodMode);
 
     /**
      * load model and qualified params
@@ -32,7 +24,7 @@ public class PML {
      * @param modelDir qualified model dir
      * @return isloadsuccess
      */
-    public static native boolean loadQualified(String modelDir);
+    public static native boolean loadQualified(String modelDir, Boolean lodMode);
 
     /**
      * load model and qualified combined params
@@ -41,7 +33,7 @@ public class PML {
      * @param paramPath qualified param path
      * @return isloadsuccess
      */
-    public static native boolean loadCombinedQualified(String modelPath, String paramPath);
+    public static native boolean loadCombinedQualified(String modelPath, String paramPath, Boolean lodMode);
 
     /**
      * predict image
@@ -52,9 +44,12 @@ public class PML {
      */
     public static native float[] predictImage(float[] buf, int[] ddims);
 
-
     public static native float[] predictYuv(byte[] buf, int imgWidth, int imgHeight, int[] ddims, float[] meanValues);
 
+    // predict with variable length input
+    // support only one input and one output currently
+    public static native float[] predictLod(float[] buf);
+
     /**
      * clear model data
      */
@@ -66,6 +61,4 @@ public class PML {
      * @param threadCount threadCount
      */
     public static native void setThread(int threadCount);
-
-
 }

src/io/jni/paddle_mobile_jni.cpp

@@ -39,7 +39,7 @@ using framework::Tensor;
 using paddle_mobile::CPU;
 using std::string;
 
-extern const char *ANDROID_LOG_TAG =
+const char *ANDROID_LOG_TAG =
     "paddle_mobile LOG built on " __DATE__ " " __TIME__;
 paddle_mobile::PaddleMobile<paddle_mobile::CPU> paddle_mobile;
 static std::mutex shared_mutex;
@@ -55,51 +55,31 @@ string jstring2cppstring(JNIEnv *env, jstring jstr) {
 
 JNIEXPORT jboolean JNICALL Java_com_baidu_paddle_PML_load(JNIEnv *env,
                                                           jclass thiz,
-                                                          jstring modelPath) {
+                                                          jstring modelPath,
+                                                          jboolean lodMode) {
   std::lock_guard<std::mutex> lock(shared_mutex);
   ANDROIDLOGI("load invoked");
   bool optimize = true;
   bool isLoadOk = false;
-
 #ifdef ENABLE_EXCEPTION
   try {
     isLoadOk = getPaddleMobileInstance()->Load(
-        jstring2cppstring(env, modelPath), optimize);
+        jstring2cppstring(env, modelPath), optimize, false, 1,
+        static_cast<bool>(lodMode));
   } catch (paddle_mobile::PaddleMobileException &e) {
     ANDROIDLOGE("jni got an PaddleMobileException! ", e.what());
     isLoadOk = false;
   }
 #else
   isLoadOk = getPaddleMobileInstance()->Load(jstring2cppstring(env, modelPath),
-                                             optimize);
-#endif
-  return static_cast<jboolean>(isLoadOk);
-}
-
-JNIEXPORT jboolean JNICALL
-Java_com_baidu_paddle_PML_loadnlp(JNIEnv *env, jclass thiz, jstring modelPath) {
-  std::lock_guard<std::mutex> lock(shared_mutex);
-  ANDROIDLOGI("load invoked");
-  bool optimize = true;
-  bool isLoadOk = false;
-
-#ifdef ENABLE_EXCEPTION
-  try {
-    isLoadOk = getPaddleMobileInstance()->Load(
-        jstring2cppstring(env, modelPath), optimize, false, 1, true);
-  } catch (paddle_mobile::PaddleMobileException &e) {
-    ANDROIDLOGE("jni got an PaddleMobileException! ", e.what());
-    isLoadOk = false;
-  }
-#else
-  isLoadOk = getPaddleMobileInstance()->Load(jstring2cppstring(env, modelPath),
-                                             optimize, false, 1, true);
+                                             optimize, false, 1,
+                                             static_cast<bool>(lodMode));
 #endif
   return static_cast<jboolean>(isLoadOk);
 }
 
 JNIEXPORT jboolean JNICALL Java_com_baidu_paddle_PML_loadQualified(
-    JNIEnv *env, jclass thiz, jstring modelPath) {
+    JNIEnv *env, jclass thiz, jstring modelPath, jboolean lodMode) {
   std::lock_guard<std::mutex> lock(shared_mutex);
 
   ANDROIDLOGI("loadQualified invoked");
@@ -110,21 +90,24 @@ JNIEXPORT jboolean JNICALL Java_com_baidu_paddle_PML_loadQualified(
 #ifdef ENABLE_EXCEPTION
   try {
     isLoadOk = getPaddleMobileInstance()->Load(
-        jstring2cppstring(env, modelPath), optimize, qualified);
+        jstring2cppstring(env, modelPath), optimize, qualified, 1,
+        static_cast<bool>(lodMode));
   } catch (paddle_mobile::PaddleMobileException &e) {
     ANDROIDLOGE("jni got an PaddleMobileException! ", e.what());
     isLoadOk = false;
   }
 #else
   isLoadOk = getPaddleMobileInstance()->Load(jstring2cppstring(env, modelPath),
-                                             optimize, qualified);
+                                             optimize, qualified, 1,
+                                             static_cast<bool>(lodMode));
 #endif
 
   return static_cast<jboolean>(isLoadOk);
 }
 
 JNIEXPORT jboolean JNICALL Java_com_baidu_paddle_PML_loadCombined(
-    JNIEnv *env, jclass thiz, jstring modelPath, jstring paramPath) {
+    JNIEnv *env, jclass thiz, jstring modelPath, jstring paramPath,
+    jboolean lodMode) {
   std::lock_guard<std::mutex> lock(shared_mutex);
   ANDROIDLOGI("loadCombined invoked");
   bool optimize = true;
@@ -134,21 +117,22 @@ JNIEXPORT jboolean JNICALL Java_com_baidu_paddle_PML_loadCombined(
   try {
     isLoadOk = getPaddleMobileInstance()->Load(
         jstring2cppstring(env, modelPath), jstring2cppstring(env, paramPath),
-        optimize);
+        optimize, false, 1, static_cast<bool>(lodMode));
   } catch (paddle_mobile::PaddleMobileException &e) {
     ANDROIDLOGE("jni got an PaddleMobileException! ", e.what());
     isLoadOk = false;
   }
 #else
-  isLoadOk = getPaddleMobileInstance()->Load(jstring2cppstring(env, modelPath),
-                                             jstring2cppstring(env, paramPath),
-                                             optimize);
+  isLoadOk = getPaddleMobileInstance()->Load(
+      jstring2cppstring(env, modelPath), jstring2cppstring(env, paramPath),
+      optimize, false, 1, static_cast<bool>(lodMode));
 #endif
   return static_cast<jboolean>(isLoadOk);
 }
 
 JNIEXPORT jboolean JNICALL Java_com_baidu_paddle_PML_loadCombinedQualified(
-    JNIEnv *env, jclass thiz, jstring modelPath, jstring paramPath) {
+    JNIEnv *env, jclass thiz, jstring modelPath, jstring paramPath,
+    jboolean lodMode) {
   std::lock_guard<std::mutex> lock(shared_mutex);
   ANDROIDLOGI("loadCombinedQualified invoked");
   bool optimize = true;
@@ -159,15 +143,15 @@ JNIEXPORT jboolean JNICALL Java_com_baidu_paddle_PML_loadCombinedQualified(
   try {
     isLoadOk = getPaddleMobileInstance()->Load(
         jstring2cppstring(env, modelPath), jstring2cppstring(env, paramPath),
-        optimize, qualified);
+        optimize, qualified, 1, static_cast<bool>(lodMode));
   } catch (paddle_mobile::PaddleMobileException &e) {
     ANDROIDLOGE("jni got an PaddleMobileException! ", e.what());
     isLoadOk = false;
   }
 #else
-  isLoadOk = getPaddleMobileInstance()->Load(jstring2cppstring(env, modelPath),
-                                             jstring2cppstring(env, paramPath),
-                                             optimize, qualified);
+  isLoadOk = getPaddleMobileInstance()->Load(
+      jstring2cppstring(env, modelPath), jstring2cppstring(env, paramPath),
+      optimize, qualified, 1, static_cast<bool>(lodMode));
 #endif
   return static_cast<jboolean>(isLoadOk);
 }

src/io/jni/paddle_mobile_jni.h

@@ -26,24 +26,27 @@ namespace jni {
  */
 JNIEXPORT jboolean JNICALL Java_com_baidu_paddle_PML_load(JNIEnv *env,
                                                           jclass thiz,
-                                                          jstring modelPath);
+                                                          jstring modelPath,
+                                                          jboolean lodMode);
 
 /**
  * load separated qualified model for android
  */
 JNIEXPORT jboolean JNICALL Java_com_baidu_paddle_PML_loadQualified(
-    JNIEnv *env, jclass thiz, jstring modelPath);
+    JNIEnv *env, jclass thiz, jstring modelPath, jboolean lodMode);
 /**
  * load combined model  for android
  */
 JNIEXPORT jboolean JNICALL Java_com_baidu_paddle_PML_loadCombined(
-    JNIEnv *env, jclass thiz, jstring modelPath, jstring paramPath);
+    JNIEnv *env, jclass thiz, jstring modelPath, jstring paramPath,
+    jboolean lodMode);
 
 /**
  * load combined qualified model for android
  */
 JNIEXPORT jboolean JNICALL Java_com_baidu_paddle_PML_loadCombinedQualified(
-    JNIEnv *env, jclass thiz, jstring modelPath, jstring paramPath);
+    JNIEnv *env, jclass thiz, jstring modelPath, jstring paramPath,
+    jboolean lodMode);
 
 /**
  * object detection for anroid
@@ -61,8 +64,8 @@ JNIEXPORT jfloatArray JNICALL Java_com_baidu_paddle_PML_predictYuv(
 /**
  * object detection for anroid
  */
-JNIEXPORT jfloatArray JNICALL
-Java_com_baidu_paddle_PML_predict(JNIEnv *env, jclass thiz, jfloatArray buf);
+JNIEXPORT jlongArray JNICALL
+Java_com_baidu_paddle_PML_predictLod(JNIEnv *env, jclass thiz, jlongArray buf);
 
 /**
  * setThreadCount for multithread

src/operators/controlflow/tensor_array_read_write_op.cpp

+/* Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License. */
+
+#include "operators/controlflow/tensor_array_read_write_op.h"
+
+namespace paddle_mobile {
+namespace operators {
+
+#ifdef WRITE_TO_ARRAY_OP
+template <typename Dtype, typename T>
+void WriteToArrayOp<Dtype, T>::InferShape() const {}
+#endif  // WRITE_TO_ARRAY_OP
+
+#ifdef READ_FROM_ARRAY_OP
+template <typename Dtype, typename T>
+void ReadFromArrayOp<Dtype, T>::InferShape() const {}
+#endif  // READ_FROM_ARRAY_OP
+
+}  // namespace operators
+}  // namespace paddle_mobile
+
+namespace ops = paddle_mobile::operators;
+
+#ifdef PADDLE_MOBILE_CPU
+#ifdef WRITE_TO_ARRAY_OP
+REGISTER_OPERATOR_CPU(write_to_array, ops::WriteToArrayOp);
+#endif  // WRITE_TO_ARRAY_OP
+
+#ifdef READ_FROM_ARRAY_OP
+REGISTER_OPERATOR_CPU(read_from_array, ops::ReadFromArrayOp);
+#endif  // READ_FROM_ARRAY_OP
+#endif

src/operators/controlflow/tensor_array_read_write_op.h

+/* Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License. */
+
+#pragma once
+
+#include <string>
+#include "framework/operator.h"
+#include "operators/kernel/tensor_array_read_write_kernel.h"
+#include "operators/op_param.h"
+
+namespace paddle_mobile {
+namespace operators {
+
+#ifdef WRITE_TO_ARRAY_OP
+DECLARE_OPERATOR(WriteToArray, WriteToArrayParam, WriteToArrayKernel);
+#endif  // WRITE_TO_ARRAY_OP
+
+#ifdef READ_FROM_ARRAY_OP
+DECLARE_OPERATOR(ReadFromArray, ReadFromArrayParam, ReadFromArrayKernel);
+#endif  // WRITE_TO_ARRAY_OP
+
+}  // namespace operators
+}  // namespace paddle_mobile

src/operators/controlflow/while_op.cpp

+/* Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License. */
+
+#include "operators/controlflow/while_op.h"
+
+namespace paddle_mobile {
+namespace operators {
+
+#ifdef WHILE_OP
+template <typename Dtype, typename T>
+void WhileOp<Dtype, T>::InferShape() const {
+  // TODO(hjchen2)
+}
+#endif  // WHILE_OP
+
+}  // namespace operators
+}  // namespace paddle_mobile
+
+namespace ops = paddle_mobile::operators;
+
+#ifdef PADDLE_MOBILE_CPU
+#ifdef WHILE_OP
+REGISTER_OPERATOR_CPU(while, ops::WhileOp);
+#endif  // WHILE_OP
+#endif

src/operators/controlflow/while_op.h

+/* Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License. */
+
+#pragma once
+
+#include <string>
+#include "framework/operator.h"
+#include "operators/kernel/while_kernel.h"
+#include "operators/op_param.h"
+
+namespace paddle_mobile {
+namespace operators {
+
+#ifdef WHILE_OP
+DECLARE_OPERATOR(While, WhileParam, WhileKernel);
+#endif  // WHILE_OP
+
+}  // namespace operators
+}  // namespace paddle_mobile

src/operators/kernel/arm/conv_add_bn_relu_kernel.cpp

@@ -15,7 +15,7 @@ limitations under the License. */
 #ifdef FUSION_CONVADDBNRELU_OP
 
 #include "operators/kernel/conv_add_bn_relu_kernel.h"
-#include <math.h>
+#include <cmath>
 #include "operators/kernel/central-arm-func/conv_add_bn_relu_arm_func.h"
 
 namespace paddle_mobile {

src/operators/kernel/arm/conv_bn_add_relu_kernel.cpp

@@ -15,6 +15,7 @@ limitations under the License. */
 #ifdef FUSION_CONVBNADDRELU_OP
 
 #include "operators/kernel/conv_bn_add_relu_kernel.h"
+#include <cmath>
 #include "operators/kernel/central-arm-func/conv_bn_add_relu_arm_func.h"
 
 namespace paddle_mobile {

src/operators/kernel/arm/conv_bn_relu_kernel.cpp

@@ -15,6 +15,7 @@ limitations under the License. */
 #ifdef FUSION_CONVBNRELU_OP
 
 #include "operators/kernel/conv_bn_relu_kernel.h"
+#include <cmath>
 #include "operators/kernel/central-arm-func/conv_bn_relu_arm_func.h"
 
 namespace paddle_mobile {

src/operators/kernel/arm/dwconv_bn_relu_kernel.cpp

@@ -15,6 +15,7 @@ limitations under the License. */
 #ifdef FUSION_DWCONVBNRELU_OP
 
 #include "operators/kernel/dwconv_bn_relu_kernel.h"
+#include <cmath>
 #include "operators/kernel/central-arm-func/dwconv_bn_relu_arm_func.h"
 
 namespace paddle_mobile {

src/operators/kernel/arm/logical_kernel.cpp

+/* Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License. */
+
+#include "operators/kernel/logical_kernel.h"
+
+namespace paddle_mobile {
+namespace operators {
+
+template <typename T>
+struct LogicalAndFunctor {
+  bool operator()(const T& a, const T& b) const { return a && b; }
+};
+
+template <typename T>
+struct LogicalOrFunctor {
+  bool operator()(const T& a, const T& b) const { return a || b; }
+};
+
+template <typename T>
+struct LogicalNotFunctor {
+  bool operator()(const T& a) const { return !a; }
+};
+
+template <typename T>
+struct LogicalXorFunctor {
+  bool operator()(const T& a, const T& b) const {
+    return (a || b) && !(a && b);
+  }
+};
+
+template <typename T, typename Functor>
+void UnaryLogicalCompute(const Tensor* inputX, Tensor* output) {
+  Functor func;
+  std::transform(inputX->data<T>(), inputX->data<T>() + inputX->numel(),
+                 output->data<T>(), func);
+}
+
+template <typename T, typename Functor>
+void BinaryLogicalCompute(const Tensor* inputX, const Tensor* inputY,
+                          Tensor* output) {
+  Functor func;
+  std::transform(inputX->data<T>(), inputX->data<T>() + inputX->numel(),
+                 inputY->data<T>(), output->data<T>(), func);
+}
+
+#ifdef LOGICAL_AND_OP
+template <>
+bool LogicalAndKernel<CPU, float>::Init(LogicalBinaryParam<CPU>* param) {
+  return true;
+}
+
+template <>
+void LogicalAndKernel<CPU, float>::Compute(
+    const LogicalBinaryParam<CPU>& param) {
+  auto* inputX = param.InputX();
+  auto* inputY = param.InputY();
+  auto* out = param.Out();
+  out->mutable_data<bool>();
+  BinaryLogicalCompute<bool, LogicalAndFunctor<bool>>(inputX, inputY, out);
+}
+#endif
+
+#ifdef LOGICAL_OR_OP
+template <>
+bool LogicalOrKernel<CPU, float>::Init(LogicalBinaryParam<CPU>* param) {
+  return true;
+}
+
+template <>
+void LogicalOrKernel<CPU, float>::Compute(
+    const LogicalBinaryParam<CPU>& param) {
+  auto* inputX = param.InputX();
+  auto* inputY = param.InputY();
+  auto* out = param.Out();
+  out->mutable_data<bool>();
+  BinaryLogicalCompute<bool, LogicalOrFunctor<bool>>(inputX, inputY, out);
+}
+#endif
+
+#ifdef LOGICAL_NOT_OP
+template <>
+bool LogicalNotKernel<CPU, float>::Init(LogicalUnaryParam<CPU>* param) {
+  return true;
+}
+
+template <>
+void LogicalNotKernel<CPU, float>::Compute(
+    const LogicalUnaryParam<CPU>& param) {
+  auto* inputX = param.InputX();
+  auto* out = param.Out();
+  out->mutable_data<bool>();
+  UnaryLogicalCompute<bool, LogicalNotFunctor<bool>>(inputX, out);
+}
+#endif
+
+#ifdef LOGICAL_XOR_OP
+template <>
+bool LogicalXorKernel<CPU, float>::Init(LogicalBinaryParam<CPU>* param) {
+  return true;
+}
+
+template <>
+void LogicalXorKernel<CPU, float>::Compute(
+    const LogicalBinaryParam<CPU>& param) {
+  auto* inputX = param.InputX();
+  auto* inputY = param.InputY();
+  auto* out = param.Out();
+  out->mutable_data<bool>();
+  BinaryLogicalCompute<bool, LogicalXorFunctor<bool>>(inputX, inputY, out);
+}
+#endif
+
+}  // namespace operators
+}  // namespace paddle_mobile

src/operators/kernel/arm/quantize_kernel.cpp

@@ -167,7 +167,7 @@ float find_abs_max(const Tensor *input) {
   max_abs = vmaxvq_f32(__max);
 #endif
   for (size_t i = 0; i < remain; ++i) {
-    max_abs = std::max(max_abs, std::abs(x[i]));
+    max_abs = std::max(max_abs, fabs(x[i]));
   }
   return max_abs;
 }

src/operators/kernel/arm/tensor_array_read_write_kernel.cpp

+/* Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License. */
+
+#include "operators/kernel/tensor_array_read_write_kernel.h"
+
+namespace paddle_mobile {
+namespace operators {
+
+#ifdef WRITE_TO_ARRAY_OP
+template <>
+bool WriteToArrayKernel<CPU, float>::Init(WriteToArrayParam<CPU> *param) {
+  return true;
+}
+
+template <>
+void WriteToArrayKernel<CPU, float>::Compute(
+    const WriteToArrayParam<CPU> &param) {
+  int64_t offset = param.index_->data<int64_t>()[0];
+  if (offset >= param.output_->size()) {
+    param.output_->resize(offset);
+  }
+  framework::LoDTensor *out_tensor = &(param.output_->at(offset));
+  out_tensor->set_lod(param.input_->lod());
+  if (param.input_->memory_size() > 0) {
+    TensorCopy(*(param.input_), out_tensor);
+  }
+}
+#endif  // WRITE_TO_ARRAY_OP
+
+#ifdef READ_FROM_ARRAY_OP
+template <>
+bool ReadFromArrayKernel<CPU, float>::Init(ReadFromArrayParam<CPU> *param) {
+  return true;
+}
+
+template <>
+void ReadFromArrayKernel<CPU, float>::Compute(
+    const ReadFromArrayParam<CPU> &param) {
+  int64_t offset = param.index_->data<int64_t>()[0];
+  if (offset < param.input_->size()) {
+    TensorCopy(param.input_->at(offset), param.output_);
+  }
+}
+#endif  // READ_FROM_ARRAY_OP
+
+}  // namespace operators
+}  // namespace paddle_mobile

src/operators/kernel/arm/while_kernel.cpp

+/* Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License. */
+
+#include "operators/kernel/while_kernel.h"
+
+namespace paddle_mobile {
+namespace operators {
+
+#ifdef WHILE_OP
+template <>
+bool WhileKernel<CPU, float>::Init(WhileParam<CPU> *param) {
+  return true;
+}
+
+template <>
+void WhileKernel<CPU, float>::Compute(const WhileParam<CPU> &param) {
+  // TODO(hjchen2)
+}
+#endif  // WHILE_OP
+
+}  // namespace operators
+}  // namespace paddle_mobile

src/operators/kernel/central-arm-func/gru_unit_arm_func.h

@@ -21,6 +21,7 @@ limitations under the License. */
 #include "operators/math/gemm.h"
 #include "operators/math/math_function.h"
 #include "operators/op_param.h"
+
 namespace paddle_mobile {
 namespace operators {
 

src/operators/kernel/cl/batchnorm_kernel.cpp

@@ -15,6 +15,7 @@ limitations under the License. */
 #ifdef BATCHNORM_OP
 
 #include "operators/kernel/batchnorm_kernel.h"
+#include <cmath>
 
 namespace paddle_mobile {
 namespace operators {

src/operators/kernel/cl/conv_add_bn_relu_kernel.cpp

@@ -15,6 +15,7 @@ limitations under the License. */
 #ifdef FUSION_CONVADDBNRELU_OP
 
 #include "operators/kernel/conv_add_bn_relu_kernel.h"
+#include <cmath>
 #include "framework/cl/cl_image.h"
 #include "framework/cl/cl_tool.h"
 

src/operators/kernel/cl/conv_bn_add_relu_kernel.cpp

@@ -15,6 +15,7 @@ limitations under the License. */
 #ifdef FUSION_CONVBNADDRELU_OP
 
 #include "operators/kernel/conv_bn_add_relu_kernel.h"
+#include <cmath>
 
 namespace paddle_mobile {
 namespace operators {

src/operators/kernel/cl/conv_bn_relu_kernel.cpp

@@ -15,6 +15,7 @@ limitations under the License. */
 #ifdef FUSION_CONVBNRELU_OP
 
 #include "operators/kernel/conv_bn_relu_kernel.h"
+#include <cmath>
 
 namespace paddle_mobile {
 namespace operators {

src/operators/kernel/cl/dwconv_bn_relu_kernel.cpp

@@ -15,6 +15,7 @@ limitations under the License. */
 #ifdef FUSION_DWCONVBNRELU_OP
 
 #include "operators/kernel/dwconv_bn_relu_kernel.h"
+#include <cmath>
 
 namespace paddle_mobile {
 namespace operators {

src/operators/kernel/cl/relu_kernel.cpp

@@ -13,7 +13,7 @@ See the License for the specific language governing permissions and
 limitations under the License. */
 #ifdef RELU_OP
 
-#include "operators/kernel/relu_kernel.h"
+#include "operators/kernel/activation_kernel.h"
 
 namespace paddle_mobile {
 namespace operators {

src/operators/kernel/fpga/V1/conv_add_bn_kernel.cpp

@@ -15,7 +15,8 @@ limitations under the License. */
 #ifdef FUSION_CONVADDBN_OP
 
 #include "operators/kernel/conv_add_bn_kernel.h"
-#include <math.h>
+#include <cmath>
+
 namespace paddle_mobile {
 namespace operators {
 

src/operators/kernel/fpga/V1/conv_add_bn_relu_kernel.cpp

@@ -15,7 +15,7 @@ limitations under the License. */
 #ifdef FUSION_CONVADDBNRELU_OP
 
 #include "operators/kernel/conv_add_bn_relu_kernel.h"
-#include <math.h>
+#include <cmath>
 
 namespace paddle_mobile {
 namespace operators {

src/operators/kernel/fpga/V2/conv_add_bn_kernel.cpp

@@ -15,6 +15,7 @@ limitations under the License. */
 #ifdef FUSION_CONVADDBN_OP
 
 #include "operators/kernel/conv_add_bn_kernel.h"
+#include <cmath>
 
 namespace paddle_mobile {
 namespace operators {

src/operators/kernel/fpga/V2/conv_add_bn_relu_kernel.cpp

@@ -15,6 +15,7 @@ limitations under the License. */
 #ifdef FUSION_CONVADDBNRELU_OP
 
 #include "operators/kernel/conv_add_bn_relu_kernel.h"
+#include <cmath>
 
 namespace paddle_mobile {
 namespace operators {

src/operators/kernel/fpga/V2/conv_bn_kernel.cpp

@@ -15,6 +15,7 @@ limitations under the License. */
 #ifdef FUSION_CONVBN_OP
 
 #include "operators/kernel/conv_bn_kernel.h"
+#include <cmath>
 
 namespace paddle_mobile {
 namespace operators {

src/operators/kernel/fpga/V2/conv_bn_relu_kernel.cpp

@@ -15,6 +15,7 @@ limitations under the License. */
 #ifdef FUSION_CONVBNRELU_OP
 
 #include "operators/kernel/conv_bn_relu_kernel.h"
+#include <cmath>
 #include "fpga/V2/filter.h"
 
 namespace paddle_mobile {

src/operators/kernel/logical_kernel.h

+/* Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License. */
+
+#pragma once
+
+#include "framework/operator.h"
+#include "operators/op_param.h"
+
+namespace paddle_mobile {
+namespace operators {
+
+#ifdef LOGICAL_AND_OP
+DECLARE_KERNEL(LogicalAnd, LogicalBinaryParam);
+#endif
+
+#ifdef LOGICAL_OR_OP
+DECLARE_KERNEL(LogicalOr, LogicalBinaryParam);
+#endif
+
+#ifdef LOGICAL_NOT_OP
+DECLARE_KERNEL(LogicalNot, LogicalUnaryParam);
+#endif
+
+#ifdef LOGICAL_XOR_OP
+DECLARE_KERNEL(LogicalXor, LogicalBinaryParam);
+#endif
+
+}  // namespace operators
+}  // namespace paddle_mobile

src/operators/kernel/tensor_array_read_write_kernel.h

+/* Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License. */
+
+#pragma once
+
+#include "framework/operator.h"
+#include "operators/op_param.h"
+
+namespace paddle_mobile {
+namespace operators {
+
+#ifdef WRITE_TO_ARRAY_OP
+DECLARE_KERNEL(WriteToArray, WriteToArrayParam);
+#endif  // WRITE_TO_ARRAY_OP
+
+#ifdef READ_FROM_ARRAY_OP
+DECLARE_KERNEL(ReadFromArray, ReadFromArrayParam);
+#endif  // READ_FROM_ARRAY_OP
+
+}  // namespace operators
+}  // namespace paddle_mobile

src/operators/kernel/while_kernel.h

+/* Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License. */
+
+#pragma once
+
+#include "framework/operator.h"
+#include "operators/op_param.h"
+
+namespace paddle_mobile {
+namespace operators {
+
+#ifdef WHILE_OP
+template <typename Dtype>
+class WhileParam : public OpParam {
+ public:
+  WhileParam(const VariableNameMap &inputs, const VariableNameMap &outputs,
+             const AttributeMap &attrs, const Scope &scope)
+      : inputs_(inputs), outputs_(outputs), scope_(scope) {
+    cond_ =
+        OpParam::GetVarValue<framework::LoDTensor>("Condition", inputs, scope);
+    sub_block_ = OpParam::GetAttr<int>("sub_block", attrs);
+  }
+
+ public:
+  framework::LoDTensor *cond_;
+  int sub_block_;
+  const VariableNameMap inputs_;
+  const VariableNameMap outputs_;
+  const Scope scope_;
+};
+
+DECLARE_KERNEL(While, WhileParam);
+#endif  // WHILE_OP
+
+}  // namespace operators
+}  // namespace paddle_mobile

src/operators/logical_op.cpp

+/* Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License. */
+
+#include "operators/logical_op.h"
+
+namespace paddle_mobile {
+namespace operators {
+
+#define DEFINE_LOGICAL_INFERSHAPE(OpName)                   \
+  template <typename Dtype, typename T>                     \
+  void OpName##Op<Dtype, T>::InferShape() const {           \
+    const auto &input_dims = this->param_.InputX()->dims(); \
+    this->param_.Out()->Resize(input_dims);                 \
+  }
+
+#ifdef LOGICAL_AND_OP
+DEFINE_LOGICAL_INFERSHAPE(LogicalAnd);
+#endif  // TLOGICAL_AND_OP
+
+#ifdef LOGICAL_OR_OP
+DEFINE_LOGICAL_INFERSHAPE(LogicalOr);
+#endif  // TLOGICAL_OR_OP
+
+#ifdef LOGICAL_NOT_OP
+DEFINE_LOGICAL_INFERSHAPE(LogicalNot);
+#endif  // LOGICAL_NOT_OP
+
+#ifdef LOGICAL_XOR_OP
+DEFINE_LOGICAL_INFERSHAPE(LogicalXor);
+#endif  // TLOGICAL_XOR_OP
+
+}  // namespace operators
+}  // namespace paddle_mobile
+
+namespace ops = paddle_mobile::operators;
+#ifdef LOGICAL_AND_OP
+#ifdef PADDLE_MOBILE_CPU
+REGISTER_OPERATOR_CPU(logical_and, ops::LogicalAndOp);
+#endif
+#endif  // LOGICAL_AND_OP
+
+#ifdef LOGICAL_OR_OP
+#ifdef PADDLE_MOBILE_CPU
+REGISTER_OPERATOR_CPU(logical_or, ops::LogicalOrOp);
+#endif
+#endif  // LOGICAL_OR_OP
+
+#ifdef LOGICAL_NOT_OP
+#ifdef PADDLE_MOBILE_CPU
+REGISTER_OPERATOR_CPU(logical_not, ops::LogicalNotOp);
+#endif
+#endif  // LOGICAL_NOT_OP
+
+#ifdef LOGICAL_XOR_OP
+#ifdef PADDLE_MOBILE_CPU
+REGISTER_OPERATOR_CPU(logical_xor, ops::LogicalXorOp);
+#endif
+#endif  // LOGICAL_XOR_OP

src/operators/logical_op.h

+/* Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License. */
+
+#pragma once
+
+#include <string>
+#include "framework/operator.h"
+#include "operators/kernel/logical_kernel.h"
+#include "operators/op_param.h"
+
+namespace paddle_mobile {
+namespace operators {
+
+#ifdef LOGICAL_AND_OP
+DECLARE_OPERATOR(LogicalAnd, LogicalBinaryParam, LogicalAndKernel);
+#endif
+
+#ifdef LOGICAL_OR_OP
+DECLARE_OPERATOR(LogicalOr, LogicalBinaryParam, LogicalOrKernel);
+#endif
+
+#ifdef LOGICAL_NOT_OP
+DECLARE_OPERATOR(LogicalNot, LogicalUnaryParam, LogicalNotKernel);
+#endif
+
+#ifdef LOGICAL_XOR_OP
+DECLARE_OPERATOR(LogicalXor, LogicalBinaryParam, LogicalXorKernel);
+#endif
+
+}  // namespace operators
+}  // namespace paddle_mobile

src/operators/math/gemm.h

@@ -13,6 +13,7 @@ See the License for the specific language governing permissions and
 limitations under the License. */
 
 #pragma once
+#include <cstring>
 #include <string>
 #include "common/log.h"
 #include "memory/t_malloc.h"

src/operators/math/quantize.h

@@ -40,8 +40,8 @@ template <>
 inline int8_t Round<ROUND_NEAREST_TO_EVEN>(const float &x) {
   float v = std::round(x);
   int32_t q = static_cast<int32_t>(v);
-  if (std::abs(std::abs(q - v) - 0.5) <= 0) {
-    if (std::abs(q) % 2 != 0) {
+  if (fabs(fabs(q - v) - 0.5) <= 0) {
+    if (abs(q) % 2 != 0) {
       q = q + ((q > 0) ? -1 : 1);
     }
   }

src/operators/op_param.h

@@ -2949,5 +2949,112 @@ class CompareParam : public OpParam {
 };
 #endif  // LESS_THAN_OP
 
+#if defined(LOGICAL_AND_OP) || defined(LOGICAL_OR_OP) || defined(LOGICAL_XOR_OP)
+template <typename Dtype>
+class LogicalBinaryParam : public OpParam {
+  typedef typename DtypeTensorTrait<Dtype>::gtype GType;
+  typedef typename DtypeTensorTrait<Dtype>::rtype RType;
+
+ public:
+  LogicalBinaryParam(const VariableNameMap &inputs,
+                     const VariableNameMap &outputs, const AttributeMap &attrs,
+                     const Scope &scope) {
+    input_x_ = InputXFrom<GType>(inputs, scope);
+    input_y_ = InputYFrom<GType>(inputs, scope);
+    output_ = OutFrom<GType>(outputs, scope);
+  }
+
+  const GType *InputX() const { return input_x_; }
+  const GType *InputY() const { return input_y_; }
+  GType *Out() const { return output_; }
+
+ public:
+  GType *input_x_;
+  GType *input_y_;
+  GType *output_;
+};
+#endif  // LOGICAL_AND_OP LOGICAL_OR_OP LOGICAL_XOR_OP
+
+#ifdef LOGICAL_NOT_OP
+template <typename Dtype>
+class LogicalUnaryParam : public OpParam {
+  typedef typename DtypeTensorTrait<Dtype>::gtype GType;
+  typedef typename DtypeTensorTrait<Dtype>::rtype RType;
+
+ public:
+  LogicalUnaryParam(const VariableNameMap &inputs,
+                    const VariableNameMap &outputs, const AttributeMap &attrs,
+                    const Scope &scope) {
+    input_x_ = InputXFrom<GType>(inputs, scope);
+    output_ = OutFrom<GType>(outputs, scope);
+  }
+
+  const GType *InputX() const { return input_x_; }
+  GType *Out() const { return output_; }
+
+ public:
+  GType *input_x_;
+  GType *output_;
+};
+#endif  // LOGICAL_NOT_OP
+
+// #ifdef WHILE_OP
+// template <typename Dtype>
+// class WhileParam : public OpParam {
+//  public:
+//   WhileParam(const VariableNameMap &inputs,
+//              const VariableNameMap &outputs, const AttributeMap &attrs,
+//              const Scope &scope) {
+//     cond_ = OpParam::GetVarValue<framework::LoDTensor>("Condition", inputs,
+//     scope); block_desc_ = OpParam::GetAttr<framework::BlockDesc
+//     *>("sub_block", attrs);
+//   }
+//
+//  public:
+//   framework::LoDTensor *cond_;
+//   const framework::BlockDesc *block_desc_;
+// };
+// #endif  // WHILE_OP
+
+#ifdef WRITE_TO_ARRAY_OP
+template <typename Dtype>
+class WriteToArrayParam : public OpParam {
+ public:
+  WriteToArrayParam(const VariableNameMap &inputs,
+                    const VariableNameMap &outputs, const AttributeMap &attrs,
+                    const Scope &scope) {
+    input_ = OpParam::GetVarValue<framework::LoDTensor>("X", inputs, scope);
+    index_ = OpParam::GetVarValue<framework::LoDTensor>("I", inputs, scope);
+    output_ =
+        OpParam::GetVarValue<framework::LoDTensorArray>("Out", outputs, scope);
+  }
+
+ public:
+  framework::LoDTensor *input_;
+  framework::LoDTensor *index_;
+  framework::LoDTensorArray *output_;
+};
+#endif
+
+#ifdef READ_FROM_ARRAY_OP
+template <typename Dtype>
+class ReadFromArrayParam : public OpParam {
+ public:
+  ReadFromArrayParam(const VariableNameMap &inputs,
+                     const VariableNameMap &outputs, const AttributeMap &attrs,
+                     const Scope &scope) {
+    input_ =
+        OpParam::GetVarValue<framework::LoDTensorArray>("X", inputs, scope);
+    index_ = OpParam::GetVarValue<framework::LoDTensor>("I", inputs, scope);
+    output_ = OpParam::GetVarValue<framework::LoDTensor>("Out", outputs, scope);
+  }
+
+ public:
+  framework::LoDTensorArray *input_;
+  framework::LoDTensor *index_;
+  framework::LoDTensor *output_;
+};
+#endif
+
 }  // namespace operators
 }  // namespace paddle_mobile

test/CMakeLists.txt

@@ -30,6 +30,10 @@ if (CON GREATER -1)
     target_link_libraries(test-mobilenet-combine paddle-mobile)
     set(FOUND_MATCH ON)
 
+    # gen test
+    ADD_EXECUTABLE(test-mobilenetgpu  net/test_mobilenet_GPU.cpp test_helper.h  test_include.h)
+    target_link_libraries(test-mobilenetgpu paddle-mobile)
+
 endif ()
 
 list(FIND NET "yolo" CON)
@@ -417,4 +421,20 @@ if (NOT FOUND_MATCH)
     ADD_EXECUTABLE(test-vgg16ssd net/test_vgg16ssd.cpp test_helper.h test_include.h)
     target_link_libraries(test-vgg16ssd paddle-mobile)
 
+    # gen test
+    ADD_EXECUTABLE(test-logical-and-op operators/test_logical_and_op.cpp test_helper.h test_include.h)
+    target_link_libraries(test-logical-and-op paddle-mobile)
+
+    # gen test
+    ADD_EXECUTABLE(test-logical-or-op operators/test_logical_or_op.cpp test_helper.h test_include.h)
+    target_link_libraries(test-logical-or-op paddle-mobile)
+
+    # gen test
+    ADD_EXECUTABLE(test-logical-not-op operators/test_logical_not_op.cpp test_helper.h test_include.h)
+    target_link_libraries(test-logical-not-op paddle-mobile)
+
+    # gen test
+    ADD_EXECUTABLE(test-logical-xor-op operators/test_logical_xor_op.cpp test_helper.h test_include.h)
+    target_link_libraries(test-logical-xor-op paddle-mobile)
+
 endif ()

test/net/test_mobilenet_GPU.cpp

@@ -25,11 +25,11 @@ int main() {
   paddle_mobile.SetCLPath("/data/local/tmp/bin");
 #endif
 
-  auto isok =
-      paddle_mobile.Load(std::string(g_mobilenet_mul) + "/model",
-                         std::string(g_mobilenet_mul) + "/params", true);
+  //  auto isok =
+  //      paddle_mobile.Load(std::string(g_mobilenet_mul) + "/model",
+  //                         std::string(g_mobilenet_mul) + "/params", true);
 
-  //  auto isok = paddle_mobile.Load(std::string(g_mobilenet_mul), true);
+  auto isok = paddle_mobile.Load(std::string(g_mobilenet), true);
   if (isok) {
     auto time2 = paddle_mobile::time();
     std::cout << "load cost :" << paddle_mobile::time_diff(time1, time2) << "ms"

test/operators/test_logical_and_op.cpp

+/* Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License. */
+
+#include "../test_include.h"
+#include "operators/logical_op.h"
+
+namespace paddle_mobile {
+
+void LogicalAnd(const framework::Tensor *inputX,
+                const framework::Tensor *inputY, framework::Tensor *output) {
+  auto x_data = inputX->data<bool>();
+  auto y_data = inputY->data<bool>();
+  auto output_data = output->data<bool>();
+  for (int i = 0; i < inputX->numel(); ++i) {
+    *output_data = *x_data && *y_data;
+    x_data++;
+    y_data++;
+    output_data++;
+  }
+}
+
+int TestLogicalAndOp(const std::vector<int> input_shape) {
+  framework::DDim input_dims = framework::make_ddim(input_shape);
+  VariableNameMap inputs;
+  VariableNameMap outputs;
+  auto scope = std::make_shared<framework::Scope>();
+  inputs["X"] = std::vector<std::string>({"inputX"});
+  inputs["Y"] = std::vector<std::string>({"inputY"});
+  outputs["Out"] = std::vector<std::string>({"output"});
+
+  auto x_var = scope.get()->Var("inputX");
+  auto x = x_var->template GetMutable<framework::LoDTensor>();
+  SetupTensor<bool>(x, input_dims, 0, 1);
+
+  auto y_var = scope.get()->Var("inputY");
+  auto y = y_var->template GetMutable<framework::LoDTensor>();
+  SetupTensor<bool>(y, input_dims, 0, 1);
+
+  auto output_var = scope.get()->Var("output");
+  framework::AttributeMap attrs;
+
+  auto *op = new operators::LogicalAndOp<CPU, float>("logical_and", inputs,
+                                                     outputs, attrs, scope);
+
+  op->InferShape();
+  op->Init();
+  op->Run();
+
+  auto output = output_var->template Get<framework::LoDTensor>();
+  framework::Tensor output_cmp;
+  bool *output_cmp_data = output_cmp.mutable_data<bool>(output->dims());
+  LogicalAnd(x, y, &output_cmp);
+
+  const bool *output_data = output->data<bool>();
+  for (int i = 0; i < output->numel(); ++i) {
+    if (output_data[i] != output_cmp_data[i]) {
+      LOG(kLOG_INFO) << "output_data[" << i << "] = " << output_data[i]
+                     << ", output_cmp_data[" << i
+                     << "] = " << output_cmp_data[i];
+      delete op;
+      exit(1);
+    }
+  }
+}
+}  // namespace paddle_mobile
+
+int main() {
+  paddle_mobile::TestLogicalAndOp({1, 1, 2, 3});
+  paddle_mobile::TestLogicalAndOp({1, 3, 11, 12});
+  paddle_mobile::TestLogicalAndOp({1, 16, 32, 32});
+  DLOG << "test logical_and op pass.";
+  return 0;
+}

test/operators/test_logical_not_op.cpp

+/* Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License. */
+
+#include "../test_include.h"
+#include "operators/logical_op.h"
+
+namespace paddle_mobile {
+
+void LogicalNot(const framework::Tensor *inputX, framework::Tensor *output) {
+  auto x_data = inputX->data<bool>();
+  auto output_data = output->data<bool>();
+  for (int i = 0; i < inputX->numel(); ++i) {
+    *output_data = !*x_data;
+    x_data++;
+    output_data++;
+  }
+}
+
+int TestLogicalNotOp(const std::vector<int> input_shape) {
+  framework::DDim input_dims = framework::make_ddim(input_shape);
+  VariableNameMap inputs;
+  VariableNameMap outputs;
+  auto scope = std::make_shared<framework::Scope>();
+  inputs["X"] = std::vector<std::string>({"inputX"});
+  outputs["Out"] = std::vector<std::string>({"output"});
+
+  auto x_var = scope.get()->Var("inputX");
+  auto x = x_var->template GetMutable<framework::LoDTensor>();
+  SetupTensor<bool>(x, input_dims, 0, 1);
+
+  auto output_var = scope.get()->Var("output");
+  framework::AttributeMap attrs;
+
+  auto *op = new operators::LogicalNotOp<CPU, float>("logical_not", inputs,
+                                                     outputs, attrs, scope);
+
+  op->InferShape();
+  op->Init();
+  op->Run();
+
+  auto output = output_var->template Get<framework::LoDTensor>();
+  framework::Tensor output_cmp;
+  bool *output_cmp_data = output_cmp.mutable_data<bool>(output->dims());
+  LogicalNot(x, &output_cmp);
+
+  const bool *output_data = output->data<bool>();
+  for (int i = 0; i < output->numel(); ++i) {
+    if (output_data[i] != output_cmp_data[i]) {
+      LOG(kLOG_INFO) << "output_data[" << i << "] = " << output_data[i]
+                     << ", output_cmp_data[" << i
+                     << "] = " << output_cmp_data[i];
+      delete op;
+      exit(1);
+    }
+  }
+}
+}  // namespace paddle_mobile
+
+int main() {
+  paddle_mobile::TestLogicalNotOp({1, 1, 2, 3});
+  paddle_mobile::TestLogicalNotOp({1, 3, 11, 12});
+  paddle_mobile::TestLogicalNotOp({1, 16, 32, 32});
+  DLOG << "test logical_not op pass.";
+  return 0;
+}

test/operators/test_logical_or_op.cpp

+/* Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License. */
+
+#include "../test_include.h"
+#include "operators/logical_op.h"
+
+namespace paddle_mobile {
+
+void LogicalOr(const framework::Tensor *inputX, const framework::Tensor *inputY,
+               framework::Tensor *output) {
+  auto x_data = inputX->data<bool>();
+  auto y_data = inputY->data<bool>();
+  auto output_data = output->data<bool>();
+  for (int i = 0; i < inputX->numel(); ++i) {
+    *output_data = *x_data || *y_data;
+    x_data++;
+    y_data++;
+    output_data++;
+  }
+}
+
+int TestLogicalOrOp(const std::vector<int> input_shape) {
+  framework::DDim input_dims = framework::make_ddim(input_shape);
+  VariableNameMap inputs;
+  VariableNameMap outputs;
+  auto scope = std::make_shared<framework::Scope>();
+  inputs["X"] = std::vector<std::string>({"inputX"});
+  inputs["Y"] = std::vector<std::string>({"inputY"});
+  outputs["Out"] = std::vector<std::string>({"output"});
+
+  auto x_var = scope.get()->Var("inputX");
+  auto x = x_var->template GetMutable<framework::LoDTensor>();
+  SetupTensor<bool>(x, input_dims, 0, 1);
+
+  auto y_var = scope.get()->Var("inputY");
+  auto y = y_var->template GetMutable<framework::LoDTensor>();
+  SetupTensor<bool>(y, input_dims, 0, 1);
+
+  auto output_var = scope.get()->Var("output");
+  framework::AttributeMap attrs;
+
+  auto *op = new operators::LogicalOrOp<CPU, float>("logical_or", inputs,
+                                                    outputs, attrs, scope);
+
+  op->InferShape();
+  op->Init();
+  op->Run();
+
+  auto output = output_var->template Get<framework::LoDTensor>();
+  framework::Tensor output_cmp;
+  bool *output_cmp_data = output_cmp.mutable_data<bool>(output->dims());
+  LogicalOr(x, y, &output_cmp);
+
+  const bool *output_data = output->data<bool>();
+  for (int i = 0; i < output->numel(); ++i) {
+    if (output_data[i] != output_cmp_data[i]) {
+      LOG(kLOG_INFO) << "output_data[" << i << "] = " << output_data[i]
+                     << ", output_cmp_data[" << i
+                     << "] = " << output_cmp_data[i];
+      delete op;
+      exit(1);
+    }
+  }
+}
+}  // namespace paddle_mobile
+
+int main() {
+  paddle_mobile::TestLogicalOrOp({1, 1, 2, 3});
+  paddle_mobile::TestLogicalOrOp({1, 3, 11, 12});
+  paddle_mobile::TestLogicalOrOp({1, 16, 32, 32});
+  DLOG << "test logical_or op pass.";
+  return 0;
+}

test/operators/test_logical_xor_op.cpp

+/* Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License. */
+
+#include "../test_include.h"
+#include "operators/logical_op.h"
+
+namespace paddle_mobile {
+
+void LogicalXor(const framework::Tensor *inputX,
+                const framework::Tensor *inputY, framework::Tensor *output) {
+  auto x_data = inputX->data<bool>();
+  auto y_data = inputY->data<bool>();
+  auto output_data = output->data<bool>();
+  for (int i = 0; i < inputX->numel(); ++i) {
+    bool x = *x_data;
+    bool y = *y_data;
+    *output_data = (x || y) && !(x && y);
+    x_data++;
+    y_data++;
+    output_data++;
+  }
+}
+
+int TestLogicalXorOp(const std::vector<int> input_shape) {
+  framework::DDim input_dims = framework::make_ddim(input_shape);
+  VariableNameMap inputs;
+  VariableNameMap outputs;
+  auto scope = std::make_shared<framework::Scope>();
+  inputs["X"] = std::vector<std::string>({"inputX"});
+  inputs["Y"] = std::vector<std::string>({"inputY"});
+  outputs["Out"] = std::vector<std::string>({"output"});
+
+  auto x_var = scope.get()->Var("inputX");
+  auto x = x_var->template GetMutable<framework::LoDTensor>();
+  SetupTensor<bool>(x, input_dims, 0, 1);
+
+  auto y_var = scope.get()->Var("inputY");
+  auto y = y_var->template GetMutable<framework::LoDTensor>();
+  SetupTensor<bool>(y, input_dims, 0, 1);
+
+  auto output_var = scope.get()->Var("output");
+  framework::AttributeMap attrs;
+
+  auto *op = new operators::LogicalXorOp<CPU, float>("logical_xor", inputs,
+                                                     outputs, attrs, scope);
+
+  op->InferShape();
+  op->Init();
+  op->Run();
+
+  auto output = output_var->template Get<framework::LoDTensor>();
+  framework::Tensor output_cmp;
+  bool *output_cmp_data = output_cmp.mutable_data<bool>(output->dims());
+  LogicalXor(x, y, &output_cmp);
+
+  const bool *output_data = output->data<bool>();
+  for (int i = 0; i < output->numel(); ++i) {
+    if (output_data[i] != output_cmp_data[i]) {
+      LOG(kLOG_INFO) << "output_data[" << i << "] = " << output_data[i]
+                     << ", output_cmp_data[" << i
+                     << "] = " << output_cmp_data[i];
+      delete op;
+      exit(1);
+    }
+  }
+}
+}  // namespace paddle_mobile
+
+int main() {
+  paddle_mobile::TestLogicalXorOp({1, 1, 2, 3});
+  paddle_mobile::TestLogicalXorOp({1, 3, 11, 12});
+  paddle_mobile::TestLogicalXorOp({1, 16, 32, 32});
+  DLOG << "test logical_xor op pass.";
+  return 0;
+}

test/test_helper.h

@@ -83,6 +83,26 @@ void SetupTensor(paddle_mobile::framework::Tensor *input,
   }
 }
 
+template <>
+void SetupTensor<bool>(paddle_mobile::framework::Tensor *input,
+                       paddle_mobile::framework::DDim dims, bool lower,
+                       bool upper) {
+  static unsigned int seed = 100;
+  std::mt19937 rng(seed++);
+  std::uniform_real_distribution<double> uniform_dist(0, 1);
+
+  bool *input_ptr = input->mutable_data<bool>(dims);
+  if (lower == upper) {
+    for (int i = 0; i < input->numel(); ++i) {
+      input_ptr[i] = lower;
+    }
+  } else {
+    for (int i = 0; i < input->numel(); ++i) {
+      input_ptr[i] = uniform_dist(rng) > 0.5;
+    }
+  }
+}
+
 template <typename T>
 T *CreateInput(Tensor *input, DDim dims, T low, T up) {
   SetupTensor<T>(input, dims, static_cast<float>(low), static_cast<float>(up));

tools/ci_build.sh

@@ -26,6 +26,7 @@ function print_usage() {
   ${BLUE}ios${NONE}: run build for apple ios platform
   ${BLUE}linux_armv7${NONE}: run build for linux armv7 platform
   ${BLUE}linux_armv8${NONE}: run build for linux armv8 platform
+  ${BLUE}fpga${NONE}: run build for fpga platform
   "
   echo "\n${RED}Network${NONE}: optional, for deep compressing the framework size
   ${BLUE}googlenet${NONE}: build only googlenet support
@@ -146,6 +147,7 @@ function build_ios_armv8_cpu_only() {
     -DIOS_PLATFORM=OS \
     -DIOS_ARCH="${IOS_ARCH}" \
     -DIS_IOS=true \
+    -DUSE_OPENMP=OFF \
     -DGPU_MALI=OFF \
     -DGPU_CL=OFF \
     -DFPGA=OFF
@@ -163,6 +165,7 @@ function build_ios_armv8_gpu() {
     -DIOS_PLATFORM=OS \
     -DIOS_ARCH="${IOS_ARCH}" \
     -DIS_IOS=true \
+    -DUSE_OPENMP=OFF \
     -DGPU_MALI=OFF \
     -DGPU_CL=ON \
     -DFPGA=OFF
@@ -217,11 +220,19 @@ function build_ios() {
 }
 
 function build_linux_armv7() {
-  check_ndk
   build_linux_armv7_cpu_only
   # build_linux_armv7_gpu
 }
 
+function build_linux_fpga() {
+  cd ..
+  image=`docker images paddle-mobile:dev | grep 'paddle-mobile'`
+  if [[ "x"$image == "x" ]]; then
+    docker build -t paddle-mobile:dev - < Dockerfile
+  fi
+  docker run --rm -v `pwd`:/workspace paddle-mobile:dev bash /workspace/tools/docker_build_fpga.sh
+}
+
 function main() {
   local CMD=$1
   init
@@ -238,6 +249,9 @@ function main() {
     linux_armv7)
       build_linux_armv7
       ;;
+    fpga)
+      build_linux_fpga
+      ;;
     *)
       print_usage
       exit 0

tools/docker_build_fpga.sh

+apt-get update
+apt-get install -y gcc g++ cmake
+
+cd /workspace && mkdir build
+cd build && cmake .. -DCPU=OFF -DFPGA=ON && make -j4
+

tools/op.cmake

@@ -281,6 +281,13 @@ if(NOT FOUND_MATCH)
   set(TANH_OP ON)
   set(LOD_RESET_OP ON)
   set(LESS_THAN_OP ON)
+  set(LOGICAL_AND_OP ON)
+  set(LOGICAL_OR_OP ON)
+  set(LOGICAL_NOT_OP ON)
+  set(LOGICAL_XOR_OP ON)
+  set(WHILE_OP ON)
+  set(WRITE_TO_ARRAY_OP ON)
+  set(READ_FROM_ARRAY_OP ON)
 endif()
 
   # option(BATCHNORM_OP "" ON)
@@ -530,6 +537,18 @@ endif()
 if (LESS_THAN_OP)
   add_definitions(-DLESS_THAN_OP)
 endif()
+if (LOGICAL_AND_OP)
+  add_definitions(-DLOGICAL_AND_OP)
+endif()
+if (LOGICAL_OR_OP)
+  add_definitions(-DLOGICAL_OR_OP)
+endif()
+if (LOGICAL_NOT_OP)
+  add_definitions(-DLOGICAL_NOT_OP)
+endif()
+if (LOGICAL_XOR_OP)
+  add_definitions(-DLOGICAL_XOR_OP)
+endif()
 
 if (TANH_OP)
   add_definitions(-DTANH_OP)
@@ -543,3 +562,13 @@ endif()
 if (FUSION_DECONVADDRELU_OP)
   add_definitions(-DFUSION_DECONVADDRELU_OP)
 endif()
+
+if (WHILE_OP)
+  add_definitions(-DWHILE_OP)
+endif()
+if (WRITE_TO_ARRAY_OP)
+  add_definitions(-DWRITE_TO_ARRAY_OP)
+endif()
+if (READ_FROM_ARRAY_OP)
+  add_definitions(-DREAD_FROM_ARRAY_OP)
+endif()