Doing C-API

Author: reyoung

paddle/capi/CMakeLists.txt

@@ -35,7 +35,8 @@ target_link_libraries(paddle_capi
   ${CBLAS_LIBS}
   ${ZLIB_LIBRARIES}
   ${INTERAL_LIBS}
-  ${CMAKE_DL_LIBS})
+  ${CMAKE_DL_LIBS}
+  ${PYTHON_LIBRARIES})
 
 
 set(PADDLE_CAPI_INC_PATH

paddle/capi/GradientMachine.cpp

@@ -0,0 +1,48 @@
+#include "PaddleCAPI.h"
+#include "PaddleCAPIPrivate.h"
+#include "paddle/gserver/gradientmachines/NeuralNetwork.h"
+
+#define cast(v) paddle::capi::cast<paddle::capi::CGradientMachine>(v)
+
+enum GradientMatchineCreateMode {
+  CREATE_MODE_NORMAL = 0,
+  CREATE_MODE_TESTING = 4
+};
+
+namespace paddle {
+
+class MyNeuralNetwork : public NeuralNetwork {
+public:
+  MyNeuralNetwork(const std::string& name, NeuralNetwork* network)
+      : NeuralNetwork(name, network) {}
+};
+
+NeuralNetwork* newCustomNerualNetwork(const std::string& name,
+                                      NeuralNetwork* network) {
+  return new MyNeuralNetwork(name, network);
+}
+}
+
+extern "C" {
+int PDGradientMachineCreateForPredict(PD_GradiemtMachine* machine,
+                                      void* modelConfigProtobuf,
+                                      int size) {
+  if (modelConfigProtobuf == nullptr) return PD_NULLPTR;
+  paddle::ModelConfig config;
+  if (!config.ParseFromArray(modelConfigProtobuf, size) ||
+      !config.IsInitialized()) {
+    return PD_PROTOBUF_ERROR;
+  }
+
+  auto ptr = new paddle::capi::CGradientMachine();
+  ptr->machine.reset(paddle::GradientMachine::create(
+      config, CREATE_MODE_TESTING, {paddle::PARAMETER_VALUE}));
+  *machine = ptr;
+  return PD_NO_ERROR;
+}
+
+int PDGradientMachineDestroy(PD_GradiemtMachine machine) {
+  delete cast(machine);
+  return PD_NO_ERROR;
+}
+}

paddle/capi/Main.cpp

@@ -0,0 +1,43 @@
+#include <fenv.h>
+#include <stdlib.h>
+#include <string.h>
+#include <vector>
+#include "PaddleCAPI.h"
+#include "PaddleCAPIPrivate.h"
+#include "paddle/trainer/TrainerConfigHelper.h"
+#include "paddle/utils/Excepts.h"
+#include "paddle/utils/PythonUtil.h"
+
+static void initPaddle(int argc, char** argv) {
+  paddle::initMain(argc, argv);
+  paddle::initPython(argc, argv);
+  feenableexcept(FE_INVALID | FE_DIVBYZERO | FE_OVERFLOW);
+}
+
+extern "C" {
+int PDInit(int argc, char** argv) {
+  std::vector<char*> realArgv;
+  realArgv.reserve(argc + 1);
+  realArgv.push_back(strdup(""));
+  for (int i = 0; i < argc; ++i) {
+    realArgv.push_back(argv[i]);
+  }
+  initPaddle(argc + 1, realArgv.data());
+  free(realArgv[0]);
+  return PD_NO_ERROR;
+}
+
+int PDParseTrainerConfigFromFile(char* filename,
+                                 void** modelConfigProtobuf,
+                                 int* size) {
+  if (filename == nullptr || modelConfigProtobuf == nullptr || size == nullptr)
+    return PD_NULLPTR;
+  paddle::TrainerConfigHelper conf(filename);
+  if (!conf.getConfig().IsInitialized()) return PD_PROTOBUF_ERROR;
+  *size = conf.getConfig().ByteSize();
+  *modelConfigProtobuf = malloc(*size);
+  if (!conf.getConfig().SerializeToArray(*modelConfigProtobuf, *size))
+    return PD_PROTOBUF_ERROR;
+  return PD_NO_ERROR;
+}
+}

paddle/capi/PaddleCAPI.h

@@ -7,10 +7,13 @@
 extern "C" {
 #endif
 
-#define PD_NO_ERROR 0
-#define PD_NULLPTR 1
-#define PD_OUT_OF_RANGE 2
-#define PD_UNDEFINED_ERROR -1
+typedef enum {
+  PD_NO_ERROR = 0,
+  PD_NULLPTR = 1,
+  PD_OUT_OF_RANGE = 2,
+  PD_PROTOBUF_ERROR = 3,
+  PD_UNDEFINED_ERROR = -1,
+} PD_Error;
 
 typedef void* PD_Vector;
 
@@ -48,6 +51,20 @@ int PDArgsSetValue(PD_Arguments args, uint64_t ID, PD_Matrix mat);
 
 int PDArgsGetValue(PD_Arguments args, uint64_t ID, PD_Matrix mat);
 
+typedef void* PD_GradiemtMachine;
+
+int PDGradientMachineCreateForPredict(PD_GradiemtMachine* machine,
+                                      void* modelConfigProtobuf,
+                                      int size);
+
+int PDGradientMachineDestroy(PD_GradiemtMachine machine);
+
+int PDInit(int argc, char** argv);
+
+int PDParseTrainerConfigFromFile(char* filename,
+                                 void** modelConfigProtobuf,
+                                 int* size);
+
 #ifdef __cplusplus
 }
 #endif

paddle/capi/PaddleCAPIPrivate.h

@@ -1,4 +1,5 @@
 #include "PaddleCAPI.h"
+#include "paddle/gserver/gradientmachines/GradientMachine.h"
 #include "paddle/math/Matrix.h"
 #include "paddle/math/Vector.h"
 #include "paddle/parameter/Argument.h"
@@ -19,6 +20,10 @@ struct CArguments {
   std::vector<paddle::Argument> args;
 };
 
+struct CGradientMachine {
+  paddle::GradientMachinePtr machine;
+};
+
 template <typename T>
 inline T* cast(void* ptr) {
   return reinterpret_cast<T*>(ptr);

paddle/capi/tests/CMakeLists.txt

@@ -1,15 +1,36 @@
-function(add_capi_unittest TARGET_NAME)
+function(add_capi_unittest_without_exec TARGET_NAME)
+  set(with_test_main ON)
+  set(sources)
+  foreach(source_file ${ARGN})
+    if (${source_file} STREQUAL "NO_MAIN")
+      set(with_test_main OFF)
+    else()
+      list(APPEND sources ${source_file})
+    endif()
+  endforeach()
+
   add_executable(
     ${TARGET_NAME}
-    ${ARGN})
+    ${sources})
+
+
   target_link_libraries(
     ${TARGET_NAME}
     paddle_capi
-    paddle_test_main
     ${GTEST_LIBRARIES})
+
+  if (with_test_main)
+    target_link_libraries(
+      ${TARGET_NAME} paddle_test_main)
+  endif()
   target_include_directories(${TARGET_NAME} PUBLIC ${PADDLE_CAPI_INC_PATH})
-  add_test(NAME ${TARGET_NAME} COMMAND ${TARGET_NAME})
 endfunction()
 
+function(add_capi_unittest TARGET_NAME)
+  add_capi_unittest_without_exec(${TARGET_NAME} ${ARGN})
+  add_test(NAME ${TARGET_NAME} COMMAND ${TARGET_NAME})
+endfunction()
 add_capi_unittest(capi_test_mats test_Vector.cpp
   test_Matrix.cpp test_Arguments.cpp)
+
+add_capi_unittest(capi_test_gradientMachine NO_MAIN test_GradientMachine.cpp)

paddle/capi/tests/test_GradientMachine.cpp

@@ -0,0 +1,24 @@
+#include <gtest/gtest.h>
+#include <stdlib.h>
+#include <string.h>
+#include "PaddleCAPI.h"
+
+TEST(GradientMachine, load) {
+  void* buf;
+  int size;
+  ASSERT_EQ(
+      PD_NO_ERROR,
+      PDParseTrainerConfigFromFile(strdup("./vgg_16_cifar.py"), &buf, &size));
+  free(buf);
+}
+
+int main(int argc, char** argv) {
+  testing::InitGoogleTest(&argc, argv);
+  std::vector<char*> argvs;
+  argvs.push_back(strdup("--use_gpu=false"));
+  PDInit((int)argvs.size(), argvs.data());
+  for (auto each : argvs) {
+    free(each);
+  }
+  return RUN_ALL_TESTS();
+}

paddle/capi/tests/test_Init.cpp

@@ -0,0 +1 @@
+../../../demo/image_classification/vgg_16_cifar.py