diff --git a/paddle/capi/Arguments.cpp b/paddle/capi/Arguments.cpp index 3d60165962d5d53e0df9053c0698fa90c69c1e94..29aa0858dd83316be7c1453b061baf0f08b8f800 100644 --- a/paddle/capi/Arguments.cpp +++ b/paddle/capi/Arguments.cpp @@ -23,25 +23,25 @@ using paddle::capi::cast; extern "C" { PD_Arguments PDArgsCreateNone() { return new paddle::capi::CArguments(); } -PD_Error PDArgsDestroy(PD_Arguments args) { +paddle_error PDArgsDestroy(PD_Arguments args) { if (args == nullptr) return kPD_NULLPTR; delete castArg(args); return kPD_NO_ERROR; } -PD_Error PDArgsGetSize(PD_Arguments args, uint64_t* size) { +paddle_error PDArgsGetSize(PD_Arguments args, uint64_t* size) { if (args == nullptr || size == nullptr) return kPD_NULLPTR; *size = castArg(args)->args.size(); return kPD_NO_ERROR; } -PD_Error PDArgsResize(PD_Arguments args, uint64_t size) { +paddle_error PDArgsResize(PD_Arguments args, uint64_t size) { if (args == nullptr) return kPD_NULLPTR; castArg(args)->args.resize(size); return kPD_NO_ERROR; } -PD_Error PDArgsSetValue(PD_Arguments args, uint64_t ID, PD_Matrix mat) { +paddle_error PDArgsSetValue(PD_Arguments args, uint64_t ID, paddle_matrix mat) { if (args == nullptr || mat == nullptr) return kPD_NULLPTR; auto m = paddle::capi::cast(mat); if (m->mat == nullptr) return kPD_NULLPTR; @@ -51,7 +51,7 @@ PD_Error PDArgsSetValue(PD_Arguments args, uint64_t ID, PD_Matrix mat) { return kPD_NO_ERROR; } -PD_Error PDArgsGetValue(PD_Arguments args, uint64_t ID, PD_Matrix mat) { +paddle_error PDArgsGetValue(PD_Arguments args, uint64_t ID, paddle_matrix mat) { if (args == nullptr || mat == nullptr) return kPD_NULLPTR; auto m = paddle::capi::cast(mat); auto a = castArg(args); @@ -60,7 +60,7 @@ PD_Error PDArgsGetValue(PD_Arguments args, uint64_t ID, PD_Matrix mat) { return kPD_NO_ERROR; } -PD_Error PDArgsGetIds(PD_Arguments args, uint64_t ID, PD_IVector ids) { +paddle_error PDArgsGetIds(PD_Arguments args, uint64_t ID, paddle_ivector ids) { if (args == nullptr || ids == nullptr) return kPD_NULLPTR; auto iv = castIVec(ids); auto a = castArg(args); @@ -69,7 +69,7 @@ PD_Error PDArgsGetIds(PD_Arguments args, uint64_t ID, PD_IVector ids) { return kPD_NO_ERROR; } -PD_Error PDArgsSetIds(PD_Arguments args, uint64_t ID, PD_IVector ids) { +paddle_error PDArgsSetIds(PD_Arguments args, uint64_t ID, paddle_ivector ids) { //! TODO(lizhao): Complete this method. if (args == nullptr || ids == nullptr) return kPD_NULLPTR; auto iv = paddle::capi::cast(ids); @@ -80,9 +80,9 @@ PD_Error PDArgsSetIds(PD_Arguments args, uint64_t ID, PD_IVector ids) { return kPD_NO_ERROR; } -PD_Error PDArgsSetSequenceStartPos(PD_Arguments args, - uint64_t ID, - PD_IVector seqPos) { +paddle_error PDArgsSetSequenceStartPos(PD_Arguments args, + uint64_t ID, + paddle_ivector seqPos) { if (args == nullptr || seqPos == nullptr) return kPD_NULLPTR; auto iv = paddle::capi::cast(seqPos); if (iv->vec == nullptr) return kPD_NULLPTR; @@ -93,9 +93,9 @@ PD_Error PDArgsSetSequenceStartPos(PD_Arguments args, return kPD_NO_ERROR; } -PD_Error PDArgsSetSubSequenceStartPos(PD_Arguments args, - uint64_t ID, - PD_IVector subSeqPos) { +paddle_error PDArgsSetSubSequenceStartPos(PD_Arguments args, + uint64_t ID, + paddle_ivector subSeqPos) { if (args == nullptr || subSeqPos == nullptr) return kPD_NULLPTR; auto iv = paddle::capi::cast(subSeqPos); if (iv->vec == nullptr) return kPD_NULLPTR; @@ -106,9 +106,9 @@ PD_Error PDArgsSetSubSequenceStartPos(PD_Arguments args, return kPD_NO_ERROR; } -PD_Error PDArgsGetSequenceStartPos(PD_Arguments args, - uint64_t ID, - PD_IVector seqPos) { +paddle_error PDArgsGetSequenceStartPos(PD_Arguments args, + uint64_t ID, + paddle_ivector seqPos) { if (args == nullptr || seqPos == nullptr) return kPD_NULLPTR; auto iv = castIVec(seqPos); auto a = castArg(args); @@ -118,9 +118,9 @@ PD_Error PDArgsGetSequenceStartPos(PD_Arguments args, return kPD_NO_ERROR; } -PD_Error PDArgsGetSubSequenceStartPos(PD_Arguments args, - uint64_t ID, - PD_IVector subSeqPos) { +paddle_error PDArgsGetSubSequenceStartPos(PD_Arguments args, + uint64_t ID, + paddle_ivector subSeqPos) { if (args == nullptr || subSeqPos == nullptr) return kPD_NULLPTR; auto iv = castIVec(subSeqPos); auto a = castArg(args); diff --git a/paddle/capi/CMakeLists.txt b/paddle/capi/CMakeLists.txt index 7fd15e10377f861800e1809532d77d7179f0c66f..a2b1929e4b747d002d309cea559257e73842c557 100644 --- a/paddle/capi/CMakeLists.txt +++ b/paddle/capi/CMakeLists.txt @@ -12,14 +12,14 @@ configure_file(config.h.in config.h @ONLY) # PaddleCAPI.h is the only header we exposed. It currently only used for model # inference. -set(CAPI_HEADER PaddleCAPI.h) - - +file(GLOB CAPI_HEADERS *.h) set(CAPI_PRIVATE_HEADER PaddleCAPIPrivate.h) +list(REMOVE_ITEM CAPI_HEADERS ${CAPI_PRIVATE_HEADER}) file(GLOB CAPI_SOURCES *.cpp) # building paddle_capi -add_library(paddle_capi STATIC ${CAPI_SOURCES}) +add_library(paddle_capi STATIC ${CAPI_HEADERS} ${CAPI_PRIVATE_HEADER} + ${CAPI_SOURCES}) target_include_directories(paddle_capi PUBLIC ${CMAKE_CURRENT_BINARY_DIR}) diff --git a/paddle/capi/GradientMachine.cpp b/paddle/capi/GradientMachine.cpp index ed0cfd884093512fe2440efe558cb9aad252b505..6ca3cf7e4d8dc3f1c57ba4131d39415adbfdd85a 100644 --- a/paddle/capi/GradientMachine.cpp +++ b/paddle/capi/GradientMachine.cpp @@ -38,9 +38,9 @@ NeuralNetwork* newCustomNerualNetwork(const std::string& name, } // namespace paddle extern "C" { -PD_Error PDGradientMachineCreateForPredict(PD_GradientMachine* machine, - void* modelConfigProtobuf, - int size) { +paddle_error PDGradientMachineCreateForPredict(PD_GradientMachine* machine, + void* modelConfigProtobuf, + int size) { if (modelConfigProtobuf == nullptr) return kPD_NULLPTR; paddle::ModelConfig config; if (!config.ParseFromArray(modelConfigProtobuf, size) || @@ -55,13 +55,13 @@ PD_Error PDGradientMachineCreateForPredict(PD_GradientMachine* machine, return kPD_NO_ERROR; } -PD_Error PDGradientMachineDestroy(PD_GradientMachine machine) { +paddle_error PDGradientMachineDestroy(PD_GradientMachine machine) { delete cast(machine); return kPD_NO_ERROR; } -PD_Error PDGradientMachineLoadParameterFromDisk(PD_GradientMachine machine, - const char* path) { +paddle_error PDGradientMachineLoadParameterFromDisk(PD_GradientMachine machine, + const char* path) { auto m = cast(machine); if (m == nullptr || path == nullptr || m->machine == nullptr) return kPD_NULLPTR; @@ -69,10 +69,10 @@ PD_Error PDGradientMachineLoadParameterFromDisk(PD_GradientMachine machine, return kPD_NO_ERROR; } -PD_Error PDGradientMachineForward(PD_GradientMachine machine, - PD_Arguments inArgs, - PD_Arguments outArgs, - bool isTrain) { +paddle_error PDGradientMachineForward(PD_GradientMachine machine, + PD_Arguments inArgs, + PD_Arguments outArgs, + bool isTrain) { auto m = cast(machine); auto in = paddle::capi::cast(inArgs); auto out = paddle::capi::cast(outArgs); @@ -83,10 +83,10 @@ PD_Error PDGradientMachineForward(PD_GradientMachine machine, return kPD_NO_ERROR; } -PD_Error PDGradientMachineCreateSharedParam(PD_GradientMachine origin, - void* modelConfigProtobuf, - int size, - PD_GradientMachine* slave) { +paddle_error PDGradientMachineCreateSharedParam(PD_GradientMachine origin, + void* modelConfigProtobuf, + int size, + PD_GradientMachine* slave) { auto o = cast(origin); if (origin == nullptr || slave == nullptr || o->machine == nullptr) { return kPD_NULLPTR; diff --git a/paddle/capi/Main.cpp b/paddle/capi/Main.cpp index 9314071b4bcf973ea0d4ed87caba67f90089e8dc..5051dff845ab5690247197abe7e67efcfa0f07c2 100644 --- a/paddle/capi/Main.cpp +++ b/paddle/capi/Main.cpp @@ -29,7 +29,7 @@ static void initPaddle(int argc, char** argv) { } extern "C" { -PD_Error PDInit(int argc, char** argv) { +paddle_error PDInit(int argc, char** argv) { std::vector realArgv; realArgv.reserve(argc + 1); realArgv.push_back(strdup("")); diff --git a/paddle/capi/Matrix.cpp b/paddle/capi/Matrix.cpp index bc25f84344c1b61c2464e705c6a7bb448c1c60fd..fe60832d70a48aa759d9c4e4acc197309fa45d43 100644 --- a/paddle/capi/Matrix.cpp +++ b/paddle/capi/Matrix.cpp @@ -18,22 +18,28 @@ limitations under the License. */ #define cast(v) paddle::capi::cast(v) extern "C" { -PD_Matrix PDMatCreate(uint64_t height, uint64_t width, bool useGpu) { +paddle_matrix paddle_matrix_create(uint64_t height, + uint64_t width, + bool useGpu) { auto ptr = new paddle::capi::CMatrix(); ptr->mat = paddle::Matrix::create(height, width, false, useGpu); return ptr; } -PD_Matrix PDMatCreateNone() { return new paddle::capi::CMatrix(); } +paddle_matrix paddle_matrix_create_none() { + return new paddle::capi::CMatrix(); +} -PD_Error PDMatDestroy(PD_Matrix mat) { +paddle_error paddle_matrix_destroy(paddle_matrix mat) { if (mat == nullptr) return kPD_NULLPTR; auto ptr = cast(mat); delete ptr; return kPD_NO_ERROR; } -PD_Error PDMatCopyToRow(PD_Matrix mat, uint64_t rowID, pd_real* rowArray) { +paddle_error paddle_matrix_set_row(paddle_matrix mat, + uint64_t rowID, + pd_real* rowArray) { if (mat == nullptr) return kPD_NULLPTR; auto ptr = cast(mat); if (ptr->mat == nullptr) return kPD_NULLPTR; @@ -48,7 +54,9 @@ PD_Error PDMatCopyToRow(PD_Matrix mat, uint64_t rowID, pd_real* rowArray) { return kPD_NO_ERROR; } -PD_Error PDMatGetRow(PD_Matrix mat, uint64_t rowID, pd_real** rawRowBuffer) { +paddle_error paddle_matrix_get_row(paddle_matrix mat, + uint64_t rowID, + pd_real** rawRowBuffer) { if (mat == nullptr) return kPD_NULLPTR; auto ptr = cast(mat); if (ptr->mat == nullptr) return kPD_NULLPTR; @@ -57,7 +65,9 @@ PD_Error PDMatGetRow(PD_Matrix mat, uint64_t rowID, pd_real** rawRowBuffer) { return kPD_NO_ERROR; } -PD_Error PDMatGetShape(PD_Matrix mat, uint64_t* height, uint64_t* width) { +paddle_error paddle_matrix_get_shape(paddle_matrix mat, + uint64_t* height, + uint64_t* width) { if (mat == nullptr) return kPD_NULLPTR; if (height != nullptr) { *height = cast(mat)->mat->getHeight(); diff --git a/paddle/capi/PaddleCAPI.h b/paddle/capi/PaddleCAPI.h index 94a9fc497f93ae1141e89386a8aa4c0e63090df2..37dfb13814b05091fd01295e1b4724e35c501294 100644 --- a/paddle/capi/PaddleCAPI.h +++ b/paddle/capi/PaddleCAPI.h @@ -17,10 +17,9 @@ limitations under the License. */ #include #include #include "config.h" - -// Since we only support linux and macos in compile, always use clang or -// gcc 4.8+. DLL_IMPORT/DLL_EXPORT is as simple as below. -#define PD_API __attribute__((visibility("default"))) +#include "error.h" +#include "matrix.h" +#include "vector.h" #ifdef __cplusplus extern "C" { @@ -33,132 +32,6 @@ extern "C" { * NOTE: This is an experimental API, it could be changed. */ -/** - * Error Type for Paddle API. - */ -typedef enum { - kPD_NO_ERROR = 0, - kPD_NULLPTR = 1, - kPD_OUT_OF_RANGE = 2, - kPD_PROTOBUF_ERROR = 3, - kPD_UNDEFINED_ERROR = -1, -} PD_Error; - -/** - * Int Vector Functions. Return will be a PD_Error type. - */ -typedef void* PD_IVector; - -/** - * @brief Create an none int vector. It just a handler and store nothing. Used - * to get output from other api. - * @return None int vector. - */ -PD_API PD_IVector PDIVecCreateNone(); - -/** - * @brief PDIVectorCreate create a paddle int vector - * @param array: input array. - * @param size: input array size. - * @param copy: memory copy or just use same memory. True if copy. - * @param useGPU: True if use GPU - * @return PD_Error - */ -PD_API PD_IVector PDIVectorCreate(int* array, - uint64_t size, - bool copy, - bool useGPU); - -/** - * @brief PDIVecDestroy destory an int vector. - * @param ivec vector to be destoried. - * @return PD_Error - */ -PD_API PD_Error PDIVecDestroy(PD_IVector ivec); - -/** - * @brief PDIVectorGet get raw buffer stored inside this int vector. It could be - * GPU memory if this int vector is stored in GPU. - * @param [in] ivec int vector - * @param [out] buffer the return buffer pointer. - * @return PD_Error - */ -PD_API PD_Error PDIVectorGet(PD_IVector ivec, int** buffer); - -/** - * @brief PDIVectorResize resize the int vector. - * @param [in] ivec: int vector - * @param [in] size: size to change - * @return PD_Error - */ -PD_API PD_Error PDIVectorResize(PD_IVector ivec, uint64_t size); - -/** - * @brief PDIVectorGetSize get the size of int vector. - * @param [in] ivec: int vector - * @param [out] size: return size of this int vector. - * @return PD_Error - */ -PD_API PD_Error PDIVectorGetSize(PD_IVector ivec, uint64_t* size); - -/** - * Matrix functions. Return will be a PD_Error type. - */ -typedef void* PD_Matrix; - -/** - * @brief PDMatCreate Create a dense matrix - * @param height matrix height. - * @param width matrix width - * @param useGpu use GPU of not - * @return Matrix handler - */ -PD_API PD_Matrix PDMatCreate(uint64_t height, uint64_t width, bool useGpu); - -/** - * @brief PDMatDestroy Destroy a matrix. - * @param mat - * @return PD_Error - */ -PD_API PD_Error PDMatDestroy(PD_Matrix mat); - -/** - * @brief PDMatCopyToRow Copy a row to matrix. - * @param mat Target Matrix - * @param rowID Index of row - * @param rowArray Row data. - * @return PD_Error - */ -PD_API PD_Error PDMatCopyToRow(PD_Matrix mat, - uint64_t rowID, - pd_real* rowArray); - -/** - * @brief PDMatGetRow Get raw row buffer from matrix - * @param [in] mat Target matrix - * @param [in] rowID Index of row. - * @param [out] rawRowBuffer Row Buffer - * @return PD_Error - */ -PD_API PD_Error PDMatGetRow(PD_Matrix mat, - uint64_t rowID, - pd_real** rawRowBuffer); - -/** - * @brief PDMatCreateNone Create None Matrix - * @return - */ -PD_API PD_Matrix PDMatCreateNone(); - -/** - * @brief PDMatGetShape get the shape of matrix - * @param mat target matrix - * @param height The height of matrix - * @param width The width of matrix - * @return PD_Error - */ -PD_API PD_Error PDMatGetShape(PD_Matrix mat, uint64_t* height, uint64_t* width); - /** * Arguments functions. Each argument means layer output. Arguments means a * array of arguemnt. @@ -174,25 +47,25 @@ PD_API PD_Arguments PDArgsCreateNone(); /** * @brief PDArgsDestroy Destroy the arguments * @param args arguments to destroy - * @return PD_Error + * @return paddle_error */ -PD_API PD_Error PDArgsDestroy(PD_Arguments args); +PD_API paddle_error PDArgsDestroy(PD_Arguments args); /** * @brief PDArgsGetSize Get size of arguments array * @param [in] args arguments array * @param [out] size array size - * @return PD_Error + * @return paddle_error */ -PD_API PD_Error PDArgsGetSize(PD_Arguments args, uint64_t* size); +PD_API paddle_error PDArgsGetSize(PD_Arguments args, uint64_t* size); /** * @brief PDArgsResize Resize a arguments array. * @param args arguments array. * @param size target size of array - * @return PD_Error + * @return paddle_error */ -PD_API PD_Error PDArgsResize(PD_Arguments args, uint64_t size); +PD_API paddle_error PDArgsResize(PD_Arguments args, uint64_t size); /** * @brief PDArgsSetValue Set value matrix of one argument in array, which index @@ -200,9 +73,11 @@ PD_API PD_Error PDArgsResize(PD_Arguments args, uint64_t size); * @param args arguments array * @param ID array index * @param mat matrix pointer - * @return PD_Error + * @return paddle_error */ -PD_API PD_Error PDArgsSetValue(PD_Arguments args, uint64_t ID, PD_Matrix mat); +PD_API paddle_error PDArgsSetValue(PD_Arguments args, + uint64_t ID, + paddle_matrix mat); /** * @brief PDArgsGetValue Get value matrix of one argument in array, which index @@ -210,9 +85,11 @@ PD_API PD_Error PDArgsSetValue(PD_Arguments args, uint64_t ID, PD_Matrix mat); * @param [in] args arguments array * @param [in] ID array index * @param [out] mat matrix pointer - * @return PD_Error + * @return paddle_error */ -PD_API PD_Error PDArgsGetValue(PD_Arguments args, uint64_t ID, PD_Matrix mat); +PD_API paddle_error PDArgsGetValue(PD_Arguments args, + uint64_t ID, + paddle_matrix mat); /** * @brief PDArgsGetIds Get the integer vector of one argument in array, which @@ -220,9 +97,11 @@ PD_API PD_Error PDArgsGetValue(PD_Arguments args, uint64_t ID, PD_Matrix mat); * @param args arguments array * @param ID array index * @param ids integer vector pointer - * @return PD_Error + * @return paddle_error */ -PD_API PD_Error PDArgsGetIds(PD_Arguments args, uint64_t ID, PD_IVector ids); +PD_API paddle_error PDArgsGetIds(PD_Arguments args, + uint64_t ID, + paddle_ivector ids); /** * @brief PDArgsSetIds Set the integer vector of one argument in array, which @@ -230,9 +109,11 @@ PD_API PD_Error PDArgsGetIds(PD_Arguments args, uint64_t ID, PD_IVector ids); * @param [in] args arguments array * @param [in] ID array index * @param [out] ids integer vector pointer - * @return PD_Error + * @return paddle_error */ -PD_API PD_Error PDArgsSetIds(PD_Arguments args, uint64_t ID, PD_IVector ids); +PD_API paddle_error PDArgsSetIds(PD_Arguments args, + uint64_t ID, + paddle_ivector ids); /** * @brief PDArgsSetSequenceStartPos Set sequence start position vector of one @@ -240,22 +121,22 @@ PD_API PD_Error PDArgsSetIds(PD_Arguments args, uint64_t ID, PD_IVector ids); * @param args arguments array * @param ID array index * @param seqPos sequence position array. - * @return PD_Error + * @return paddle_error */ -PD_API PD_Error PDArgsSetSequenceStartPos(PD_Arguments args, - uint64_t ID, - PD_IVector seqPos); +PD_API paddle_error PDArgsSetSequenceStartPos(PD_Arguments args, + uint64_t ID, + paddle_ivector seqPos); /** * @brief PDArgsGetSequenceStartPos Get sequence start position vector of one * argument in array, which index is `ID`. * @param [in] args arguments array * @param [in] ID array index * @param [out] seqPos sequence position array - * @return PD_Error + * @return paddle_error */ -PD_API PD_Error PDArgsGetSequenceStartPos(PD_Arguments args, - uint64_t ID, - PD_IVector seqPos); +PD_API paddle_error PDArgsGetSequenceStartPos(PD_Arguments args, + uint64_t ID, + paddle_ivector seqPos); /** * @brief PDArgsSetSubSequenceStartPos Set sub-sequence start position vector of @@ -263,11 +144,11 @@ PD_API PD_Error PDArgsGetSequenceStartPos(PD_Arguments args, * @param args arguments array * @param ID array index * @param subSeqPos sub-sequence start position array. - * @return PD_Error + * @return paddle_error */ -PD_API PD_Error PDArgsSetSubSequenceStartPos(PD_Arguments args, - uint64_t ID, - PD_IVector subSeqPos); +PD_API paddle_error PDArgsSetSubSequenceStartPos(PD_Arguments args, + uint64_t ID, + paddle_ivector subSeqPos); /** * @brief PDArgsGetSubSequenceStartPos Get sub-sequence start position vector of @@ -275,11 +156,11 @@ PD_API PD_Error PDArgsSetSubSequenceStartPos(PD_Arguments args, * @param args arguments array * @param ID array index * @param subSeqPos sub-sequence start position array - * @return PD_Error + * @return paddle_error */ -PD_API PD_Error PDArgsGetSubSequenceStartPos(PD_Arguments args, - uint64_t ID, - PD_IVector subSeqPos); +PD_API paddle_error PDArgsGetSubSequenceStartPos(PD_Arguments args, + uint64_t ID, + paddle_ivector subSeqPos); /** * @brief GradientMachine means a neural network. */ @@ -291,19 +172,18 @@ typedef void* PD_GradientMachine; * @param [out] machine that used for model inference. * @param [in] modelConfigProtobuf * @param [in] size - * @return PD_Error + * @return paddle_error */ -PD_API PD_Error PDGradientMachineCreateForPredict(PD_GradientMachine* machine, - void* modelConfigProtobuf, - int size); +PD_API paddle_error PDGradientMachineCreateForPredict( + PD_GradientMachine* machine, void* modelConfigProtobuf, int size); /** * @brief PDGradientMachineLoadParameterFromDisk Load parameter from disk. * @param machine Gradient Machine. * @param path local directory path. - * @return PD_Error + * @return paddle_error */ -PD_API PD_Error PDGradientMachineLoadParameterFromDisk( +PD_API paddle_error PDGradientMachineLoadParameterFromDisk( PD_GradientMachine machine, const char* path); /** @@ -312,12 +192,12 @@ PD_API PD_Error PDGradientMachineLoadParameterFromDisk( * @param inArgs input arguments * @param outArgs output arguments * @param isTrain is train or not - * @return PD_Error + * @return paddle_error */ -PD_API PD_Error PDGradientMachineForward(PD_GradientMachine machine, - PD_Arguments inArgs, - PD_Arguments outArgs, - bool isTrain); +PD_API paddle_error PDGradientMachineForward(PD_GradientMachine machine, + PD_Arguments inArgs, + PD_Arguments outArgs, + bool isTrain); /** * @brief PDGradientMachineCreateSharedParam Create a gradient machine, which @@ -326,24 +206,25 @@ PD_API PD_Error PDGradientMachineForward(PD_GradientMachine machine, * @param [in] modelConfigProtobuf model config protobuf * @param [in] size of model config buffer. * @param [out] slave gradient machine, the output value. - * @return PD_Error + * @return paddle_error */ -PD_API PD_Error PDGradientMachineCreateSharedParam(PD_GradientMachine origin, - void* modelConfigProtobuf, - int size, - PD_GradientMachine* slave); +PD_API paddle_error +PDGradientMachineCreateSharedParam(PD_GradientMachine origin, + void* modelConfigProtobuf, + int size, + PD_GradientMachine* slave); /** * @brief PDGradientMachineDestroy Destroy a gradient machine * @param machine that need to destroy - * @return PD_Error + * @return paddle_error */ -PD_API PD_Error PDGradientMachineDestroy(PD_GradientMachine machine); +PD_API paddle_error PDGradientMachineDestroy(PD_GradientMachine machine); /** * Initialize Paddle. */ -PD_API PD_Error PDInit(int argc, char** argv); +PD_API paddle_error PDInit(int argc, char** argv); #ifdef __cplusplus } diff --git a/paddle/capi/Vector.cpp b/paddle/capi/Vector.cpp index 514d65fec8f6aff72613a4dc391d57cef7fb9c52..4ccb167fec21ba046ae6cfd4f1961d45f24640a0 100644 --- a/paddle/capi/Vector.cpp +++ b/paddle/capi/Vector.cpp @@ -19,9 +19,14 @@ using paddle::capi::cast; extern "C" { -PD_IVector PDIVecCreateNone() { return new paddle::capi::CIVector(); } +paddle_ivector paddle_ivector_create_none() { + return new paddle::capi::CIVector(); +} -PD_IVector PDIVectorCreate(int* array, uint64_t size, bool copy, bool useGPU) { +paddle_ivector paddle_ivector_create(int* array, + uint64_t size, + bool copy, + bool useGPU) { auto ptr = new paddle::capi::CIVector(); if (copy) { ptr->vec = paddle::IVector::create(size, useGPU); @@ -32,13 +37,13 @@ PD_IVector PDIVectorCreate(int* array, uint64_t size, bool copy, bool useGPU) { return ptr; } -PD_Error PDIVecDestroy(PD_IVector ivec) { +paddle_error paddle_ivector_destroy(paddle_ivector ivec) { if (ivec == nullptr) return kPD_NULLPTR; delete cast(ivec); return kPD_NO_ERROR; } -PD_Error PDIVectorGet(PD_IVector ivec, int** buffer) { +paddle_error paddle_ivector_get(paddle_ivector ivec, int** buffer) { if (ivec == nullptr || buffer == nullptr) return kPD_NULLPTR; auto v = cast(ivec); if (v->vec == nullptr) return kPD_NULLPTR; @@ -46,7 +51,7 @@ PD_Error PDIVectorGet(PD_IVector ivec, int** buffer) { return kPD_NO_ERROR; } -PD_Error PDIVectorResize(PD_IVector ivec, uint64_t size) { +paddle_error paddle_ivector_resize(paddle_ivector ivec, uint64_t size) { if (ivec == nullptr) return kPD_NULLPTR; auto v = cast(ivec); if (v->vec == nullptr) return kPD_NULLPTR; @@ -54,7 +59,7 @@ PD_Error PDIVectorResize(PD_IVector ivec, uint64_t size) { return kPD_NO_ERROR; } -PD_Error PDIVectorGetSize(PD_IVector ivec, uint64_t* size) { +paddle_error paddle_ivector_get_size(paddle_ivector ivec, uint64_t* size) { if (ivec == nullptr) return kPD_NULLPTR; auto v = cast(ivec); if (v->vec == nullptr) return kPD_NULLPTR; diff --git a/paddle/capi/config.h.in b/paddle/capi/config.h.in index 32d8a364e0eaaa896bc6bd2f19c1c7914870ba85..af4e80dea144f4cf2af4d1c0ccb80487aeaa621b 100644 --- a/paddle/capi/config.h.in +++ b/paddle/capi/config.h.in @@ -3,4 +3,8 @@ typedef @PADDLE_FLOAT_TYPE@ pd_real; +// Since we only support linux and macos in compile, always use clang or +// gcc 4.8+. DLL_IMPORT/DLL_EXPORT is as simple as below. +#define PD_API __attribute__((visibility("default"))) + #endif diff --git a/paddle/capi/error.h b/paddle/capi/error.h new file mode 100644 index 0000000000000000000000000000000000000000..8dbb6d954872169711a2ca14f12ab48096d8a49e --- /dev/null +++ b/paddle/capi/error.h @@ -0,0 +1,15 @@ +#ifndef __PADDLE_CAPI_ERROR_H__ +#define __PADDLE_CAPI_ERROR_H__ + +/** + * Error Type for Paddle API. + */ +typedef enum { + kPD_NO_ERROR = 0, + kPD_NULLPTR = 1, + kPD_OUT_OF_RANGE = 2, + kPD_PROTOBUF_ERROR = 3, + kPD_UNDEFINED_ERROR = -1, +} paddle_error; + +#endif diff --git a/paddle/capi/matrix.h b/paddle/capi/matrix.h new file mode 100644 index 0000000000000000000000000000000000000000..2f6488f38386aa07698b2104cb6afc98d72ae37b --- /dev/null +++ b/paddle/capi/matrix.h @@ -0,0 +1,91 @@ +/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserve. + +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. */ + +#ifndef __PADDLE_CAPI_MATRIX_H__ +#define __PADDLE_CAPI_MATRIX_H__ + +#include +#include "config.h" +#include "error.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * Matrix functions. Return will be a paddle_error type. + */ +typedef void* paddle_matrix; + +/** + * @brief paddle_matrix_create Create a dense matrix + * @param height matrix height. + * @param width matrix width + * @param useGpu use GPU of not + * @return Matrix handler + */ +PD_API paddle_matrix paddle_matrix_create(uint64_t height, + uint64_t width, + bool useGpu); + +/** + * @brief paddle_matrix_destroy Destroy a matrix. + * @param mat + * @return paddle_error + */ +PD_API paddle_error paddle_matrix_destroy(paddle_matrix mat); + +/** + * @brief paddle_matrix_set_row Set a row to matrix. + * @param mat Target Matrix + * @param rowID Index of row + * @param rowArray Row data. + * @return paddle_error + */ +PD_API paddle_error paddle_matrix_set_row(paddle_matrix mat, + uint64_t rowID, + pd_real* rowArray); + +/** + * @brief PDMatGetRow Get raw row buffer from matrix + * @param [in] mat Target matrix + * @param [in] rowID Index of row. + * @param [out] rawRowBuffer Row Buffer + * @return paddle_error + */ +PD_API paddle_error paddle_matrix_get_row(paddle_matrix mat, + uint64_t rowID, + pd_real** rawRowBuffer); + +/** + * @brief PDMatCreateNone Create None Matrix + * @return + */ +PD_API paddle_matrix paddle_matrix_create_none(); + +/** + * @brief PDMatGetShape get the shape of matrix + * @param mat target matrix + * @param height The height of matrix + * @param width The width of matrix + * @return paddle_error + */ +PD_API paddle_error paddle_matrix_get_shape(paddle_matrix mat, + uint64_t* height, + uint64_t* width); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/paddle/capi/tests/test_Arguments.cpp b/paddle/capi/tests/test_Arguments.cpp index e015b94e12cd9f8737efd6f810f306e3199718ea..92dcf6bf9c580ef037a3d00018a6f12d04721974 100644 --- a/paddle/capi/tests/test_Arguments.cpp +++ b/paddle/capi/tests/test_Arguments.cpp @@ -39,14 +39,14 @@ TEST(CAPIArguments, value) { PD_Arguments args = PDArgsCreateNone(); ASSERT_EQ(kPD_NO_ERROR, PDArgsResize(args, 1)); - PD_Matrix mat = PDMatCreate(128, 64, false); + paddle_matrix mat = paddle_matrix_create(128, 64, false); for (size_t i = 0; i < 128; ++i) { std::vector sampleBuf = randomBuffer(64); - PDMatCopyToRow(mat, i, sampleBuf.data()); + paddle_matrix_set_row(mat, i, sampleBuf.data()); } ASSERT_EQ(kPD_NO_ERROR, PDArgsSetValue(args, 0, mat)); - PD_Matrix val = PDMatCreateNone(); + paddle_matrix val = paddle_matrix_create_none(); ASSERT_EQ(kPD_NO_ERROR, PDArgsGetValue(args, 0, val)); @@ -54,15 +54,15 @@ TEST(CAPIArguments, value) { pd_real* row1; pd_real* row2; - ASSERT_EQ(kPD_NO_ERROR, PDMatGetRow(mat, i, &row1)); - ASSERT_EQ(kPD_NO_ERROR, PDMatGetRow(val, i, &row2)); + ASSERT_EQ(kPD_NO_ERROR, paddle_matrix_get_row(mat, i, &row1)); + ASSERT_EQ(kPD_NO_ERROR, paddle_matrix_get_row(val, i, &row2)); ASSERT_EQ(row1, row2); } - PD_IVector ivec = PDIVecCreateNone(); - ASSERT_EQ(kPD_NO_ERROR, PDIVecDestroy(ivec)); - ASSERT_EQ(kPD_NO_ERROR, PDMatDestroy(val)); - ASSERT_EQ(kPD_NO_ERROR, PDMatDestroy(mat)); + paddle_ivector ivec = paddle_ivector_create_none(); + ASSERT_EQ(kPD_NO_ERROR, paddle_ivector_destroy(ivec)); + ASSERT_EQ(kPD_NO_ERROR, paddle_matrix_destroy(val)); + ASSERT_EQ(kPD_NO_ERROR, paddle_matrix_destroy(mat)); ASSERT_EQ(kPD_NO_ERROR, PDArgsDestroy(args)); } @@ -70,15 +70,15 @@ TEST(CAPIArguments, ids) { PD_Arguments args = PDArgsCreateNone(); ASSERT_EQ(kPD_NO_ERROR, PDArgsResize(args, 1)); - PD_IVector ivec; + paddle_ivector ivec; int array[3] = {1, 2, 3}; - ivec = PDIVectorCreate(array, 3, true, false); + ivec = paddle_ivector_create(array, 3, true, false); ASSERT_EQ(kPD_NO_ERROR, PDArgsSetIds(args, 0, ivec)); - PD_IVector val = PDIVecCreateNone(); + paddle_ivector val = paddle_ivector_create_none(); ASSERT_EQ(kPD_NO_ERROR, PDArgsGetIds(args, 0, val)); - ASSERT_EQ(kPD_NO_ERROR, PDIVecDestroy(ivec)); - ASSERT_EQ(kPD_NO_ERROR, PDIVecDestroy(val)); + ASSERT_EQ(kPD_NO_ERROR, paddle_ivector_destroy(ivec)); + ASSERT_EQ(kPD_NO_ERROR, paddle_ivector_destroy(val)); ASSERT_EQ(kPD_NO_ERROR, PDArgsDestroy(args)); } @@ -87,24 +87,24 @@ void testSequenceHelper(T1 setter, T2 getter) { PD_Arguments args = PDArgsCreateNone(); ASSERT_EQ(kPD_NO_ERROR, PDArgsResize(args, 1)); - PD_IVector ivec; + paddle_ivector ivec; int array[3] = {1, 2, 3}; - ivec = PDIVectorCreate(array, 3, true, false); + ivec = paddle_ivector_create(array, 3, true, false); ASSERT_EQ(kPD_NO_ERROR, setter(args, 0, ivec)); - PD_IVector val = PDIVecCreateNone(); + paddle_ivector val = paddle_ivector_create_none(); ASSERT_EQ(kPD_NO_ERROR, getter(args, 0, val)); uint64_t size; - ASSERT_EQ(kPD_NO_ERROR, PDIVectorGetSize(val, &size)); + ASSERT_EQ(kPD_NO_ERROR, paddle_ivector_get_size(val, &size)); int* rawBuf; - ASSERT_EQ(kPD_NO_ERROR, PDIVectorGet(val, &rawBuf)); + ASSERT_EQ(kPD_NO_ERROR, paddle_ivector_get(val, &rawBuf)); for (size_t i = 0; i < size; ++i) { ASSERT_EQ(array[i], rawBuf[i]); } - ASSERT_EQ(kPD_NO_ERROR, PDIVecDestroy(ivec)); - ASSERT_EQ(kPD_NO_ERROR, PDIVecDestroy(val)); + ASSERT_EQ(kPD_NO_ERROR, paddle_ivector_destroy(ivec)); + ASSERT_EQ(kPD_NO_ERROR, paddle_ivector_destroy(val)); ASSERT_EQ(kPD_NO_ERROR, PDArgsDestroy(args)); } diff --git a/paddle/capi/tests/test_GradientMachine.cpp b/paddle/capi/tests/test_GradientMachine.cpp index acee99bcc4b23e564d0f4ae6b89a6b5e9aed8a8b..05a06445c2727e102046ea38c8a7087db8ad4e99 100644 --- a/paddle/capi/tests/test_GradientMachine.cpp +++ b/paddle/capi/tests/test_GradientMachine.cpp @@ -59,12 +59,12 @@ TEST(GradientMachine, testPredict) { PD_Arguments inArgs = PDArgsCreateNone(); ASSERT_EQ(kPD_NO_ERROR, PDArgsResize(inArgs, 1)); - PD_Matrix mat = PDMatCreate(1, 100, false); + paddle_matrix mat = paddle_matrix_create(1, 100, false); static_assert(std::is_same::value, ""); auto data = randomBuffer(100); pd_real* rowPtr; - ASSERT_EQ(kPD_NO_ERROR, PDMatGetRow(mat, 0, &rowPtr)); + ASSERT_EQ(kPD_NO_ERROR, paddle_matrix_get_row(mat, 0, &rowPtr)); memcpy(rowPtr, data.data(), data.size() * sizeof(pd_real)); ASSERT_EQ(kPD_NO_ERROR, PDArgsSetValue(inArgs, 0, mat)); @@ -87,16 +87,16 @@ TEST(GradientMachine, testPredict) { auto matPaddle = paddleOutArgs[0].value; uint64_t height, width; - ASSERT_EQ(kPD_NO_ERROR, PDMatGetShape(mat, &height, &width)); + ASSERT_EQ(kPD_NO_ERROR, paddle_matrix_get_shape(mat, &height, &width)); ASSERT_EQ(matPaddle->getHeight(), height); ASSERT_EQ(matPaddle->getWidth(), width); - ASSERT_EQ(kPD_NO_ERROR, PDMatGetRow(mat, 0, &rowPtr)); + ASSERT_EQ(kPD_NO_ERROR, paddle_matrix_get_row(mat, 0, &rowPtr)); for (size_t i = 0; i < width; ++i) { ASSERT_NEAR(matPaddle->getData()[i], rowPtr[i], 1e-5); } - ASSERT_EQ(kPD_NO_ERROR, PDMatDestroy(mat)); + ASSERT_EQ(kPD_NO_ERROR, paddle_matrix_destroy(mat)); ASSERT_EQ(kPD_NO_ERROR, PDArgsDestroy(inArgs)); ASSERT_EQ(kPD_NO_ERROR, PDArgsDestroy(outArgs)); std::swap(machineSlave, machine); diff --git a/paddle/capi/tests/test_Matrix.cpp b/paddle/capi/tests/test_Matrix.cpp index 1d38162add21a0d0ee1f3a6f5770faddb8da1e66..1b3b881caee55d742590bbc9bee8b0422443b733 100644 --- a/paddle/capi/tests/test_Matrix.cpp +++ b/paddle/capi/tests/test_Matrix.cpp @@ -16,30 +16,31 @@ limitations under the License. */ #include "gtest/gtest.h" TEST(CAPIMatrix, create) { - PD_Matrix mat = PDMatCreate(128, 32, false); + paddle_matrix mat = paddle_matrix_create(128, 32, false); std::vector sampleRow; sampleRow.resize(32); for (size_t i = 0; i < sampleRow.size(); ++i) { sampleRow[i] = 1.0 / (i + 1.0); } - ASSERT_EQ(kPD_NO_ERROR, PDMatCopyToRow(mat, 0, sampleRow.data())); - ASSERT_EQ(kPD_OUT_OF_RANGE, PDMatCopyToRow(mat, 128, sampleRow.data())); + ASSERT_EQ(kPD_NO_ERROR, paddle_matrix_set_row(mat, 0, sampleRow.data())); + ASSERT_EQ(kPD_OUT_OF_RANGE, + paddle_matrix_set_row(mat, 128, sampleRow.data())); pd_real* arrayPtr; - ASSERT_EQ(kPD_NO_ERROR, PDMatGetRow(mat, 0, &arrayPtr)); + ASSERT_EQ(kPD_NO_ERROR, paddle_matrix_get_row(mat, 0, &arrayPtr)); for (size_t i = 0; i < sampleRow.size(); ++i) { ASSERT_NEAR(sampleRow[i], arrayPtr[i], 1e-5); } uint64_t height, width; - ASSERT_EQ(kPD_NO_ERROR, PDMatGetShape(mat, &height, &width)); + ASSERT_EQ(kPD_NO_ERROR, paddle_matrix_get_shape(mat, &height, &width)); ASSERT_EQ(128UL, height); ASSERT_EQ(32UL, width); - ASSERT_EQ(kPD_NO_ERROR, PDMatDestroy(mat)); + ASSERT_EQ(kPD_NO_ERROR, paddle_matrix_destroy(mat)); } TEST(CAPIMatrix, createNone) { - PD_Matrix mat = PDMatCreateNone(); - ASSERT_EQ(kPD_NO_ERROR, PDMatDestroy(mat)); + paddle_matrix mat = paddle_matrix_create_none(); + ASSERT_EQ(kPD_NO_ERROR, paddle_matrix_destroy(mat)); } diff --git a/paddle/capi/tests/test_Vector.cpp b/paddle/capi/tests/test_Vector.cpp index b3558fe0fdd171702f06ae3336db21ea3887cc11..64c19265e3d05eb9cac0bd8eb3dd5b26fb9ad509 100644 --- a/paddle/capi/tests/test_Vector.cpp +++ b/paddle/capi/tests/test_Vector.cpp @@ -16,16 +16,16 @@ limitations under the License. */ #include "gtest/gtest.h" TEST(CAPIVector, create) { - PD_IVector vec; + paddle_ivector vec; int array[3] = {1, 2, 3}; - vec = PDIVectorCreate(array, 3, true, false); - ASSERT_EQ(kPD_NO_ERROR, PDIVectorResize(vec, 1000)); + vec = paddle_ivector_create(array, 3, true, false); + ASSERT_EQ(kPD_NO_ERROR, paddle_ivector_resize(vec, 1000)); uint64_t size; - ASSERT_EQ(kPD_NO_ERROR, PDIVectorGetSize(vec, &size)); - ASSERT_EQ(kPD_NO_ERROR, PDIVecDestroy(vec)); + ASSERT_EQ(kPD_NO_ERROR, paddle_ivector_get_size(vec, &size)); + ASSERT_EQ(kPD_NO_ERROR, paddle_ivector_destroy(vec)); } TEST(CAPIVector, createNone) { - PD_IVector vec = PDIVecCreateNone(); - ASSERT_EQ(kPD_NO_ERROR, PDIVecDestroy(vec)); + paddle_ivector vec = paddle_ivector_create_none(); + ASSERT_EQ(kPD_NO_ERROR, paddle_ivector_destroy(vec)); } diff --git a/paddle/capi/vector.h b/paddle/capi/vector.h new file mode 100644 index 0000000000000000000000000000000000000000..a92aeff16425779bf63a7ffd7217709b6bf3cd05 --- /dev/null +++ b/paddle/capi/vector.h @@ -0,0 +1,89 @@ +/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserve. + +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. */ + +#ifndef __PADDLE_CAPI_VECTOR_H__ +#define __PADDLE_CAPI_VECTOR_H__ + +#include +#include +#include "config.h" +#include "error.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * Int Vector Functions. Return will be a paddle_error type. + */ +typedef void* paddle_ivector; + +/** + * @brief Create an none int vector. It just a handler and store nothing. Used + * to get output from other api. + * @return None int vector. + */ +PD_API paddle_ivector paddle_ivector_create_none(); + +/** + * @brief paddle_ivector_create create a paddle int vector + * @param array: input array. + * @param size: input array size. + * @param copy: memory copy or just use same memory. True if copy. + * @param useGPU: True if use GPU + * @return paddle_error + */ +PD_API paddle_ivector paddle_ivector_create(int* array, + uint64_t size, + bool copy, + bool useGPU); + +/** + * @brief paddle_ivector_destroy destory an int vector. + * @param ivec vector to be destoried. + * @return paddle_error + */ +PD_API paddle_error paddle_ivector_destroy(paddle_ivector ivec); + +/** + * @brief paddle_ivector_get get raw buffer stored inside this int vector. It + * could be GPU memory if this int vector is stored in GPU. + * @param [in] ivec int vector + * @param [out] buffer the return buffer pointer. + * @return paddle_error + */ +PD_API paddle_error paddle_ivector_get(paddle_ivector ivec, int** buffer); + +/** + * @brief paddle_ivector_resize resize the int vector. + * @param [in] ivec: int vector + * @param [in] size: size to change + * @return paddle_error + */ +PD_API paddle_error paddle_ivector_resize(paddle_ivector ivec, uint64_t size); + +/** + * @brief paddle_ivector_get_size get the size of int vector. + * @param [in] ivec: int vector + * @param [out] size: return size of this int vector. + * @return paddle_error + */ +PD_API paddle_error paddle_ivector_get_size(paddle_ivector ivec, + uint64_t* size); + +#ifdef __cplusplus +} +#endif + +#endif