fix code style

core/general-server/op/general_dist_kv_infer_op.cpp

@@ -38,9 +38,7 @@ using baidu::paddle_serving::predictor::general_model::FetchInst;
 using baidu::paddle_serving::predictor::InferManager;
 using baidu::paddle_serving::predictor::PaddleGeneralModelConfig;
 
-int GeneralDistKVInferOp::inference() {
-  return 0;
-}
+int GeneralDistKVInferOp::inference() { return 0; }
 DEFINE_OP(GeneralDistKVInferOp);
 
 }  // namespace serving

core/general-server/op/general_infer_op.cpp

@@ -44,8 +44,7 @@ int GeneralInferOp::inference() {
                << pre_node_names.size();
     return -1;
   }
-  if (InferManager::instance().infer(
-          engine_name().c_str())) {
+  if (InferManager::instance().infer(engine_name().c_str())) {
     return -1;
   }
   std::cout << "Infer Success" << std::endl;

core/general-server/op/general_reader_op.cpp

@@ -75,7 +75,7 @@ int GeneralReaderOp::inference() {
   // reade request from client
   // TODO: only support one engine here
   std::string engine_name = "general_infer_0";
-  const Request *req = dynamic_cast<const Request*>(get_request_message());
+  const Request *req = dynamic_cast<const Request *>(get_request_message());
   uint64_t log_id = req->log_id();
   int input_var_num = 0;
   std::vector<int64_t> elem_type;
@@ -91,8 +91,9 @@ int GeneralReaderOp::inference() {
   capacity.resize(var_num);
   for (int i = 0; i < var_num; ++i) {
     std::string tensor_name = model_config->_feed_name[i];
-    std::cout << "START Tensor Name: " <<tensor_name << std::endl;
-    auto lod_tensor = InferManager::instance().GetInputHandle(engine_name.c_str(), tensor_name.c_str());
+    std::cout << "START Tensor Name: " << tensor_name << std::endl;
+    auto lod_tensor = InferManager::instance().GetInputHandle(
+        engine_name.c_str(), tensor_name.c_str());
     std::cout << "PICK lod tensor. " << std::endl;
     std::vector<std::vector<size_t>> lod;
     std::vector<int> shape;
@@ -112,8 +113,7 @@ int GeneralReaderOp::inference() {
       }
       VLOG(2) << "(logid=" << log_id << ") var[" << i
               << "] is tensor, capacity: " << capacity[i];
-    }
-    else {
+    } else {
       capacity[i] = 1;
       for (int k = 0; k < req->insts(0).tensor_array(i).shape_size(); ++k) {
         int dim = req->insts(0).tensor_array(i).shape(k);
@@ -127,35 +127,36 @@ int GeneralReaderOp::inference() {
     }
     lod_tensor->SetLoD(lod);
     lod_tensor->Reshape(shape);
-    std::cout << "FINI Set Lod and Reshape, and elem type: "<< elem_type[i] << std::endl;
+    std::cout << "FINI Set Lod and Reshape, and elem type: " << elem_type[i]
+              << std::endl;
     // insert data here
     if (req->insts(0).tensor_array(i).elem_type() == 0) {
       // TODO: Copy twice here, can optimize
       int elem_num = req->insts(0).tensor_array(i).int64_data_size();
       std::vector<int64_t> data(elem_num);
-      int64_t* dst_ptr = data.data();
+      int64_t *dst_ptr = data.data();
       for (int k = 0; k < elem_num; ++k) {
         dst_ptr[k] = req->insts(0).tensor_array(i).int64_data(k);
       }
       lod_tensor->CopyFromCpu(dst_ptr);
-    } else if(req->insts(0).tensor_array(i).elem_type() == 1) {
+    } else if (req->insts(0).tensor_array(i).elem_type() == 1) {
       int elem_num = req->insts(0).tensor_array(i).float_data_size();
       std::vector<float> data(elem_num);
-      float* dst_ptr = data.data();
+      float *dst_ptr = data.data();
       for (int k = 0; k < elem_num; ++k) {
         dst_ptr[k] = req->insts(0).tensor_array(i).float_data(k);
       }
       lod_tensor->CopyFromCpu(dst_ptr);
-    } else if(req->insts(0).tensor_array(i).elem_type()== 2) {
+    } else if (req->insts(0).tensor_array(i).elem_type() == 2) {
       int elem_num = req->insts(0).tensor_array(i).int_data_size();
       std::vector<int32_t> data(elem_num);
-      int32_t* dst_ptr = data.data();
+      int32_t *dst_ptr = data.data();
       for (int k = 0; k < elem_num; ++k) {
         dst_ptr[k] = req->insts(0).tensor_array(i).int_data(k);
       }
       lod_tensor->CopyFromCpu(dst_ptr);
     }
-    std::cout << "FINISH Tensor Name: " <<tensor_name << std::endl;
+    std::cout << "FINISH Tensor Name: " << tensor_name << std::endl;
   }
   return 0;
 }

core/general-server/op/general_response_op.cpp

@@ -52,34 +52,39 @@ int GeneralResponseOp::inference() {
   ModelOutput *output = res->add_outputs();
   FetchInst *fetch_inst = output->add_insts();
   FetchInst *fetch_p = output->mutable_insts(0);
-  std::vector<std::string> outs = InferManager::instance().GetOutputNames(engine_name.c_str());
+  std::vector<std::string> outs =
+      InferManager::instance().GetOutputNames(engine_name.c_str());
   for (int i = 0; i < req->fetch_var_names_size(); ++i) {
     Tensor *tensor = fetch_inst->add_tensor_array();
     std::string tensor_name = outs[i];
-    auto lod_tensor = InferManager::instance().GetOutputHandle(engine_name.c_str(), tensor_name.c_str());
+    auto lod_tensor = InferManager::instance().GetOutputHandle(
+        engine_name.c_str(), tensor_name.c_str());
     std::vector<int> shape = lod_tensor->shape();
-    for (int k = 0; k < shape.size(); ++k) { 
+    for (int k = 0; k < shape.size(); ++k) {
       capacity[i] *= shape[k];
       tensor->add_shape(shape[k]);
     }
     auto dtype = lod_tensor->type();
     if (dtype == paddle::PaddleDType::INT64) {
       std::vector<int64_t> datas(capacity[i]);
-      int64_t* data_ptr = datas.data();
+      int64_t *data_ptr = datas.data();
       lod_tensor->CopyToCpu(data_ptr);
-      google::protobuf::RepeatedField<int64_t> tmp_data(data_ptr, data_ptr + capacity[i]);
+      google::protobuf::RepeatedField<int64_t> tmp_data(data_ptr,
+                                                        data_ptr + capacity[i]);
       tensor->mutable_int64_data()->Swap(&tmp_data);
     } else if (dtype == paddle::PaddleDType::FLOAT32) {
       std::vector<float> datas(capacity[i]);
-      float* data_ptr = datas.data();
+      float *data_ptr = datas.data();
       lod_tensor->CopyToCpu(data_ptr);
-      google::protobuf::RepeatedField<float> tmp_data(data_ptr, data_ptr + capacity[i]);
+      google::protobuf::RepeatedField<float> tmp_data(data_ptr,
+                                                      data_ptr + capacity[i]);
       tensor->mutable_float_data()->Swap(&tmp_data);
     } else if (dtype == paddle::PaddleDType::INT32) {
       std::vector<int32_t> datas(capacity[i]);
-      int32_t* data_ptr = datas.data();
+      int32_t *data_ptr = datas.data();
       lod_tensor->CopyToCpu(data_ptr);
-      google::protobuf::RepeatedField<int32_t> tmp_data(data_ptr, data_ptr + capacity[i]);
+      google::protobuf::RepeatedField<int32_t> tmp_data(data_ptr,
+                                                        data_ptr + capacity[i]);
       tensor->mutable_int_data()->Swap(&tmp_data);
     }
     std::vector<std::vector<size_t>> lod = lod_tensor->lod();

core/predictor/framework/infer.h

@@ -104,9 +104,7 @@ class InferEngine {
   virtual int thrd_initialize() { return thrd_initialize_impl(); }
   virtual int thrd_clear() { return thrd_clear_impl(); }
   virtual int thrd_finalize() { return thrd_finalize_impl(); }
-  virtual int infer() {
-    return infer_impl();
-  }
+  virtual int infer() { return infer_impl(); }
 
   virtual int reload() = 0;
 
@@ -121,8 +119,10 @@ class InferEngine {
   virtual int proc_finalize_impl() = 0;
   virtual std::vector<std::string> GetInputNames() = 0;
   virtual std::vector<std::string> GetOutputNames() = 0;
-  virtual std::unique_ptr<paddle_infer::Tensor> GetInputHandle(const std::string& name) = 0;
-  virtual std::unique_ptr<paddle_infer::Tensor> GetOutputHandle(const std::string& name) = 0;
+  virtual std::unique_ptr<paddle_infer::Tensor> GetInputHandle(
+      const std::string& name) = 0;
+  virtual std::unique_ptr<paddle_infer::Tensor> GetOutputHandle(
+      const std::string& name) = 0;
   virtual int infer_impl() = 0;
   // end: framework inner call
 };
@@ -201,9 +201,7 @@ class ReloadableInferEngine : public InferEngine {
     return 0;
   }
 
-  int infer() {
-      return infer_impl();
-  }
+  int infer() { return infer_impl(); }
 
   int thrd_initialize() {
     if (_infer_thread_num > 0) {
@@ -489,7 +487,6 @@ class CloneDBReloadableInferEngine
   }
 
   virtual int thrd_initialize_impl() {
-
     ModelData<EngineCore>* md = new (std::nothrow) ModelData<EngineCore>;
     if (!md || load_data(md, _pd->cores[_pd->current_idx]) != 0) {
       LOG(ERROR) << "Failed clone thread data, origin_core["
@@ -517,7 +514,8 @@ class FluidInferEngine : public CloneDBReloadableInferEngine<FluidFamilyCore> {
   FluidInferEngine() {}
   ~FluidInferEngine() {}
   std::vector<std::string> GetInputNames() {
-    FluidFamilyCore* core = DBReloadableInferEngine<FluidFamilyCore>::get_core();
+    FluidFamilyCore* core =
+        DBReloadableInferEngine<FluidFamilyCore>::get_core();
     if (!core || !core->get()) {
       LOG(ERROR) << "Failed get fluid core in GetInputHandle()";
     }
@@ -525,23 +523,28 @@ class FluidInferEngine : public CloneDBReloadableInferEngine<FluidFamilyCore> {
   }
 
   std::vector<std::string> GetOutputNames() {
-    FluidFamilyCore* core = DBReloadableInferEngine<FluidFamilyCore>::get_core();
+    FluidFamilyCore* core =
+        DBReloadableInferEngine<FluidFamilyCore>::get_core();
     if (!core || !core->get()) {
       LOG(ERROR) << "Failed get fluid core in GetInputHandle()";
     }
     return core->GetOutputNames();
   }
 
-  std::unique_ptr<paddle_infer::Tensor> GetInputHandle(const std::string& name) {
-    FluidFamilyCore* core = DBReloadableInferEngine<FluidFamilyCore>::get_core();
+  std::unique_ptr<paddle_infer::Tensor> GetInputHandle(
+      const std::string& name) {
+    FluidFamilyCore* core =
+        DBReloadableInferEngine<FluidFamilyCore>::get_core();
     if (!core || !core->get()) {
       LOG(ERROR) << "Failed get fluid core in GetInputHandle()";
     }
     return core->GetInputHandle(name);
   }
 
-  std::unique_ptr<paddle_infer::Tensor> GetOutputHandle(const std::string& name) {
-    FluidFamilyCore* core = DBReloadableInferEngine<FluidFamilyCore>::get_core();
+  std::unique_ptr<paddle_infer::Tensor> GetOutputHandle(
+      const std::string& name) {
+    FluidFamilyCore* core =
+        DBReloadableInferEngine<FluidFamilyCore>::get_core();
     if (!core || !core->get()) {
       LOG(ERROR) << "Failed get fluid core in GetOutputHandle()";
     }
@@ -549,7 +552,8 @@ class FluidInferEngine : public CloneDBReloadableInferEngine<FluidFamilyCore> {
   }
 
   int infer_impl() {
-    FluidFamilyCore* core = DBReloadableInferEngine<FluidFamilyCore>::get_core();
+    FluidFamilyCore* core =
+        DBReloadableInferEngine<FluidFamilyCore>::get_core();
     if (!core || !core->get()) {
       LOG(ERROR) << "Failed get fluid core in infer_impl()";
       return -1;
@@ -709,7 +713,8 @@ class VersionedInferEngine : public InferEngine {
     }
     return engine->GetOutputNames();
   }
-  std::unique_ptr<paddle_infer::Tensor> GetInputHandle(const std::string& name) {
+  std::unique_ptr<paddle_infer::Tensor> GetInputHandle(
+      const std::string& name) {
     InferEngine* engine = default_engine();
     if (!engine) {
       LOG(WARNING) << "fail to get default engine";
@@ -717,7 +722,8 @@ class VersionedInferEngine : public InferEngine {
     return engine->GetInputHandle(name);
   }
 
-  std::unique_ptr<paddle_infer::Tensor> GetOutputHandle(const std::string& name) {
+  std::unique_ptr<paddle_infer::Tensor> GetOutputHandle(
+      const std::string& name) {
     InferEngine* engine = default_engine();
     if (!engine) {
       LOG(WARNING) << "fail to get default engine";
@@ -754,7 +760,7 @@ class VersionedInferEngine : public InferEngine {
     auto iter = _versions.find(version);
     if (iter == _versions.end()) {
       LOG(ERROR) << "Not found version engine: " << version;
-    } 
+    }
     return iter->second->GetInputNames();
   }
 
@@ -766,7 +772,8 @@ class VersionedInferEngine : public InferEngine {
     return iter->second->GetOutputNames();
   }
 
-  std::unique_ptr<paddle_infer::Tensor> GetInputHandle(uint64_t version, const std::string& name) {
+  std::unique_ptr<paddle_infer::Tensor> GetInputHandle(
+      uint64_t version, const std::string& name) {
     auto iter = _versions.find(version);
     if (iter == _versions.end()) {
       LOG(ERROR) << "Not found version engine: " << version;
@@ -774,7 +781,8 @@ class VersionedInferEngine : public InferEngine {
     return iter->second->GetInputHandle(name);
   }
 
-  std::unique_ptr<paddle_infer::Tensor> GetOutputHandle(uint64_t version, const std::string& name) {
+  std::unique_ptr<paddle_infer::Tensor> GetOutputHandle(
+      uint64_t version, const std::string& name) {
     auto iter = _versions.find(version);
     if (iter == _versions.end()) {
       LOG(ERROR) << "Not found version engine: " << version;
@@ -806,9 +814,7 @@ class VersionedInferEngine : public InferEngine {
   int thrd_finalize_impl() { return -1; }
   int thrd_clear_impl() { return -1; }
   int proc_finalize_impl() { return -1; }
-  int infer_impl() {
-    return -1;
-  }
+  int infer_impl() { return -1; }
 
  private:
   boost::unordered_map<uint64_t, InferEngine*> _versions;
@@ -929,14 +935,16 @@ class InferManager {
     }
     return it->second->GetOutputNames();
   }
-  std::unique_ptr<paddle_infer::Tensor> GetInputHandle(const char* model_name, const std::string& name) {
+  std::unique_ptr<paddle_infer::Tensor> GetInputHandle(
+      const char* model_name, const std::string& name) {
     auto it = _map.find(model_name);
     if (it == _map.end()) {
       LOG(WARNING) << "Cannot find engine in map, model name:" << model_name;
     }
     return it->second->GetInputHandle(name);
   }
-  std::unique_ptr<paddle_infer::Tensor> GetOutputHandle(const char* model_name, const std::string& name) {
+  std::unique_ptr<paddle_infer::Tensor> GetOutputHandle(
+      const char* model_name, const std::string& name) {
     auto it = _map.find(model_name);
     if (it == _map.end()) {
       LOG(WARNING) << "Cannot find engine in map, model name:" << model_name;
@@ -961,8 +969,7 @@ class InferManager {
   }
 
   // Versioned inference interface
-  int infer(const char* model_name,
-            uint64_t version) {
+  int infer(const char* model_name, uint64_t version) {
     auto it = _map.find(model_name);
     if (it == _map.end()) {
       LOG(WARNING) << "Cannot find engine in map, model name:" << model_name;
@@ -970,7 +977,8 @@ class InferManager {
     }
     return it->second->infer(version);
   }
-  std::vector<std::string> GetInputNames(const char* model_name, uint64_t version) {
+  std::vector<std::string> GetInputNames(const char* model_name,
+                                         uint64_t version) {
     auto it = _map.find(model_name);
     if (it == _map.end()) {
       LOG(WARNING) << "Cannot find engine in map, model name:" << model_name;
@@ -978,7 +986,8 @@ class InferManager {
     return it->second->GetInputNames(version);
   }
 
-  std::vector<std::string> GetOutputNames(const char* model_name, uint64_t version) {
+  std::vector<std::string> GetOutputNames(const char* model_name,
+                                          uint64_t version) {
     auto it = _map.find(model_name);
     if (it == _map.end()) {
       LOG(WARNING) << "Cannot find engine in map, model name:" << model_name;
@@ -986,14 +995,16 @@ class InferManager {
     return it->second->GetOutputNames(version);
   }
 
-  std::unique_ptr<paddle_infer::Tensor> GetInputHandle(const char* model_name, uint64_t version, const std::string& name) {
+  std::unique_ptr<paddle_infer::Tensor> GetInputHandle(
+      const char* model_name, uint64_t version, const std::string& name) {
     auto it = _map.find(model_name);
     if (it == _map.end()) {
       LOG(WARNING) << "Cannot find engine in map, model name:" << model_name;
     }
     return it->second->GetInputHandle(version, name);
   }
-  std::unique_ptr<paddle_infer::Tensor> GetOutputHandle(const char* model_name, uint64_t version, const std::string& name) {
+  std::unique_ptr<paddle_infer::Tensor> GetOutputHandle(
+      const char* model_name, uint64_t version, const std::string& name) {
     auto it = _map.find(model_name);
     if (it == _map.end()) {
       LOG(WARNING) << "Cannot find engine in map, model name:" << model_name;

java/README.md

@@ -71,5 +71,3 @@ The second is to deploy GPU Serving and Java Client separately. If they are on t
 **It should be noted that in the example, all models need to use `--use_multilang` to start GRPC multi-programming language support, and the port number is 9393. If you need another port, you need to modify it in the java file**
 
 **Currently Serving has launched the Pipeline mode (see [Pipeline Serving](../doc/PIPELINE_SERVING.md) for details). The next version (0.4.1) of the Pipeline Serving Client for Java will be released. **
-
-

java/README_CN.md

@@ -71,5 +71,3 @@ java -cp paddle-serving-sdk-java-examples-0.0.1-jar-with-dependencies.jar Paddle
 **需要注意的是，在示例中，所有模型都需要使用`--use_multilang`来启动GRPC多编程语言支持，以及端口号都是9393，如果需要别的端口，需要在java文件里修改**
 
 **目前Serving已推出Pipeline模式（详见[Pipeline Serving](../doc/PIPELINE_SERVING_CN.md)），下个版本（0.4.1）面向Java的Pipeline Serving Client将会发布，敬请期待。**
-
-

paddle_inference/inferencer-fluid-cpu/include/fluid_cpu_engine.h

@@ -69,7 +69,7 @@ class FluidFamilyCore {
   }
 
   virtual std::unique_ptr<Tensor> GetInputHandle(const std::string& name) {
-      return _core->GetInputHandle(name);
+    return _core->GetInputHandle(name);
   }
 
   virtual std::vector<std::string> GetOutputNames() {
@@ -77,7 +77,7 @@ class FluidFamilyCore {
   }
 
   virtual std::unique_ptr<Tensor> GetOutputHandle(const std::string& name) {
-      return _core->GetOutputHandle(name);
+    return _core->GetOutputHandle(name);
   }
 
   virtual bool Run() {
@@ -95,8 +95,7 @@ class FluidFamilyCore {
       LOG(ERROR) << "origin paddle Predictor is null.";
       return -1;
     }
-    Predictor* p_predictor =
-        (Predictor*)origin_core;
+    Predictor* p_predictor = (Predictor*)origin_core;
     _core = p_predictor->Clone();
     if (_core.get() == NULL) {
       LOG(ERROR) << "fail to clone paddle predictor: " << origin_core;

paddle_inference/inferencer-fluid-gpu/include/fluid_gpu_engine.h

@@ -75,7 +75,7 @@ class FluidFamilyCore {
   }
 
   virtual std::unique_ptr<Tensor> GetInputHandle(const std::string& name) {
-      return _core->GetInputHandle(name);
+    return _core->GetInputHandle(name);
   }
 
   virtual std::vector<std::string> GetOutputNames() {
@@ -83,7 +83,7 @@ class FluidFamilyCore {
   }
 
   virtual std::unique_ptr<Tensor> GetOutputHandle(const std::string& name) {
-      return _core->GetOutputHandle(name);
+    return _core->GetOutputHandle(name);
   }
 
   virtual bool Run() {
@@ -101,8 +101,7 @@ class FluidFamilyCore {
       LOG(ERROR) << "origin paddle Predictor is null.";
       return -1;
     }
-    Predictor* p_predictor =
-        (Predictor*)origin_core;
+    Predictor* p_predictor = (Predictor*)origin_core;
     _core = p_predictor->Clone();
     if (_core.get() == NULL) {
       LOG(ERROR) << "fail to clone paddle predictor: " << origin_core;
@@ -173,13 +172,12 @@ class FluidGpuAnalysisDirCore : public FluidFamilyCore {
     int max_batch = 32;
     int min_subgraph_size = 3;
     if (params.use_trt()) {
-      config.EnableTensorRtEngine(
-          1 << 20,
-          max_batch,
-          min_subgraph_size,
-          Config::Precision::kFloat32,
-          false,
-          false);
+      config.EnableTensorRtEngine(1 << 20,
+                                  max_batch,
+                                  min_subgraph_size,
+                                  Config::Precision::kFloat32,
+                                  false,
+                                  false);
       LOG(INFO) << "create TensorRT predictor";
     } else {
       if (params.enable_memory_optimization()) {
@@ -204,7 +202,6 @@ class FluidGpuAnalysisDirCore : public FluidFamilyCore {
   }
 };
 
-
 class Parameter {
  public:
   Parameter() : _row(0), _col(0), _params(NULL) {}