m53297601
/
Paddle
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Refactor API follow comments.

Browse Source
feature/design_of_v2_layer_converter
Yu Yang 8 years ago
parent 5a9987a317
commit 7bb12fdb50
10 changed files with 314 additions and 159 deletions
Show Stats Download Patch File Download Diff File

44
paddle/capi/Arguments.cpp
Unescape View File

@ -21,31 +21,27 @@ using paddle::capi::cast;
#define castIVec(v) cast<paddle::capi::CIVector>(v)
extern "C" {
int PDArgsCreateNone(PD_Arguments* args) {
auto ptr = new paddle::capi::CArguments();
*args = ptr;
return kPD_NO_ERROR;
}
PD_Arguments PDArgsCreateNone() { return new paddle::capi::CArguments(); }
int PDArgsDestroy(PD_Arguments args) {
PD_Error PDArgsDestroy(PD_Arguments args) {
if (args == nullptr) return kPD_NULLPTR;
delete castArg(args);
return kPD_NO_ERROR;
}
int PDArgsGetSize(PD_Arguments args, uint64_t* size) {
PD_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;
}
int PDArgsResize(PD_Arguments args, uint64_t size) {
PD_Error PDArgsResize(PD_Arguments args, uint64_t size) {
if (args == nullptr) return kPD_NULLPTR;
castArg(args)->args.resize(size);
return kPD_NO_ERROR;
}
int PDArgsSetValue(PD_Arguments args, uint64_t ID, PD_Matrix mat) {
PD_Error PDArgsSetValue(PD_Arguments args, uint64_t ID, PD_Matrix mat) {
if (args == nullptr || mat == nullptr) return kPD_NULLPTR;
auto m = paddle::capi::cast<paddle::capi::CMatrix>(mat);
if (m->mat == nullptr) return kPD_NULLPTR;
@ -55,7 +51,7 @@ int PDArgsSetValue(PD_Arguments args, uint64_t ID, PD_Matrix mat) {
return kPD_NO_ERROR;
}
int PDArgsGetValue(PD_Arguments args, uint64_t ID, PD_Matrix mat) {
PD_Error PDArgsGetValue(PD_Arguments args, uint64_t ID, PD_Matrix mat) {
if (args == nullptr || mat == nullptr) return kPD_NULLPTR;
auto m = paddle::capi::cast<paddle::capi::CMatrix>(mat);
auto a = castArg(args);
@ -64,7 +60,7 @@ int PDArgsGetValue(PD_Arguments args, uint64_t ID, PD_Matrix mat) {
return kPD_NO_ERROR;
}
int PDArgsGetIds(PD_Arguments args, uint64_t ID, PD_IVector ids) {
PD_Error PDArgsGetIds(PD_Arguments args, uint64_t ID, PD_IVector ids) {
if (args == nullptr || ids == nullptr) return kPD_NULLPTR;
auto iv = castIVec(ids);
auto a = castArg(args);
@ -73,7 +69,7 @@ int PDArgsGetIds(PD_Arguments args, uint64_t ID, PD_IVector ids) {
return kPD_NO_ERROR;
}
int PDArgsSetIds(PD_Arguments args, uint64_t ID, PD_IVector ids) {
PD_Error PDArgsSetIds(PD_Arguments args, uint64_t ID, PD_IVector ids) {
//! TODO(lizhao): Complete this method.
if (args == nullptr || ids == nullptr) return kPD_NULLPTR;
auto iv = paddle::capi::cast<paddle::capi::CIVector>(ids);
@ -84,9 +80,9 @@ int PDArgsSetIds(PD_Arguments args, uint64_t ID, PD_IVector ids) {
return kPD_NO_ERROR;
}
int PDArgsSetSequenceStartPos(PD_Arguments args,
uint64_t ID,
PD_IVector seqPos) {
PD_Error PDArgsSetSequenceStartPos(PD_Arguments args,
uint64_t ID,
PD_IVector seqPos) {
if (args == nullptr || seqPos == nullptr) return kPD_NULLPTR;
auto iv = paddle::capi::cast<paddle::capi::CIVector>(seqPos);
if (iv->vec == nullptr) return kPD_NULLPTR;
@ -97,9 +93,9 @@ int PDArgsSetSequenceStartPos(PD_Arguments args,
return kPD_NO_ERROR;
}
int PDArgsSetSubSequenceStartPos(PD_Arguments args,
uint64_t ID,
PD_IVector subSeqPos) {
PD_Error PDArgsSetSubSequenceStartPos(PD_Arguments args,
uint64_t ID,
PD_IVector subSeqPos) {
if (args == nullptr || subSeqPos == nullptr) return kPD_NULLPTR;
auto iv = paddle::capi::cast<paddle::capi::CIVector>(subSeqPos);
if (iv->vec == nullptr) return kPD_NULLPTR;
@ -110,9 +106,9 @@ int PDArgsSetSubSequenceStartPos(PD_Arguments args,
return kPD_NO_ERROR;
}
int PDArgsGetSequenceStartPos(PD_Arguments args,
uint64_t ID,
PD_IVector seqPos) {
PD_Error PDArgsGetSequenceStartPos(PD_Arguments args,
uint64_t ID,
PD_IVector seqPos) {
if (args == nullptr || seqPos == nullptr) return kPD_NULLPTR;
auto iv = castIVec(seqPos);
auto a = castArg(args);
@ -122,9 +118,9 @@ int PDArgsGetSequenceStartPos(PD_Arguments args,
return kPD_NO_ERROR;
}
int PDArgsGetSubSequenceStartPos(PD_Arguments args,
uint64_t ID,
PD_IVector subSeqPos) {
PD_Error PDArgsGetSubSequenceStartPos(PD_Arguments args,
uint64_t ID,
PD_IVector subSeqPos) {
if (args == nullptr || subSeqPos == nullptr) return kPD_NULLPTR;
auto iv = castIVec(subSeqPos);
auto a = castArg(args);

28
paddle/capi/GradientMachine.cpp
Unescape View File

@ -38,9 +38,9 @@ NeuralNetwork* newCustomNerualNetwork(const std::string& name,
} // namespace paddle
extern "C" {
int PDGradientMachineCreateForPredict(PD_GradientMachine* machine,
void* modelConfigProtobuf,
int size) {
PD_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 @@ int PDGradientMachineCreateForPredict(PD_GradientMachine* machine,
return kPD_NO_ERROR;
}
int PDGradientMachineDestroy(PD_GradientMachine machine) {
PD_Error PDGradientMachineDestroy(PD_GradientMachine machine) {
delete cast(machine);
return kPD_NO_ERROR;
}
int PDGradientMachineLoadParameterFromDisk(PD_GradientMachine machine,
const char* path) {
PD_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 @@ int PDGradientMachineLoadParameterFromDisk(PD_GradientMachine machine,
return kPD_NO_ERROR;
}
int PDGradientMachineForward(PD_GradientMachine machine,
PD_Arguments inArgs,
PD_Arguments outArgs,
bool isTrain) {
PD_Error PDGradientMachineForward(PD_GradientMachine machine,
PD_Arguments inArgs,
PD_Arguments outArgs,
bool isTrain) {
auto m = cast(machine);
auto in = paddle::capi::cast<paddle::capi::CArguments>(inArgs);
auto out = paddle::capi::cast<paddle::capi::CArguments>(outArgs);
@ -83,10 +83,10 @@ int PDGradientMachineForward(PD_GradientMachine machine,
return kPD_NO_ERROR;
}
int PDGradientMachineCreateSharedParam(PD_GradientMachine origin,
void* modelConfigProtobuf,
int size,
PD_GradientMachine* slave) {
PD_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;

2
paddle/capi/Main.cpp
Unescape View File

@ -29,7 +29,7 @@ static void initPaddle(int argc, char** argv) {
}
extern "C" {
int PDInit(int argc, char** argv) {
PD_Error PDInit(int argc, char** argv) {
std::vector<char*> realArgv;
realArgv.reserve(argc + 1);
realArgv.push_back(strdup(""));

19
paddle/capi/Matrix.cpp
Unescape View File

@ -18,27 +18,22 @@ limitations under the License. */
#define cast(v) paddle::capi::cast<paddle::capi::CMatrix>(v)
extern "C" {
int PDMatCreate(PD_Matrix* mat, uint64_t height, uint64_t width, bool useGpu) {
PD_Matrix PDMatCreate(uint64_t height, uint64_t width, bool useGpu) {
auto ptr = new paddle::capi::CMatrix();
ptr->mat = paddle::Matrix::create(height, width, false, useGpu);
*mat = ptr;
return kPD_NO_ERROR;
return ptr;
}
int PDMatCreateNone(PD_Matrix* mat) {
auto ptr = new paddle::capi::CMatrix();
*mat = ptr;
return kPD_NO_ERROR;
}
PD_Matrix PDMatCreateNone() { return new paddle::capi::CMatrix(); }
int PDMatDestroy(PD_Matrix mat) {
PD_Error PDMatDestroy(PD_Matrix mat) {
if (mat == nullptr) return kPD_NULLPTR;
auto ptr = cast(mat);
delete ptr;
return kPD_NO_ERROR;
}
int PDMatCopyToRow(PD_Matrix mat, uint64_t rowID, pd_real* rowArray) {
PD_Error PDMatCopyToRow(PD_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;
@ -53,7 +48,7 @@ int PDMatCopyToRow(PD_Matrix mat, uint64_t rowID, pd_real* rowArray) {
return kPD_NO_ERROR;
}
int PDMatGetRow(PD_Matrix mat, uint64_t rowID, pd_real** rawRowBuffer) {
PD_Error PDMatGetRow(PD_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;
@ -62,7 +57,7 @@ int PDMatGetRow(PD_Matrix mat, uint64_t rowID, pd_real** rawRowBuffer) {
return kPD_NO_ERROR;
}
int PDMatGetShape(PD_Matrix mat, uint64_t* height, uint64_t* width) {
PD_Error PDMatGetShape(PD_Matrix mat, uint64_t* height, uint64_t* width) {
if (mat == nullptr) return kPD_NULLPTR;
if (height != nullptr) {
*height = cast(mat)->mat->getHeight();

303
paddle/capi/PaddleCAPI.h
View File

File diff suppressed because it is too large Load Diff

25
paddle/capi/Vector.cpp
Unescape View File

@ -19,33 +19,26 @@ using paddle::capi::cast;
extern "C" {
int PDIVecCreateNone(PD_IVector* ivec) {
if (ivec == nullptr) return kPD_NULLPTR;
auto ptr = new paddle::capi::CIVector();
*ivec = ptr;
return kPD_NO_ERROR;
}
PD_IVector PDIVecCreateNone() { return new paddle::capi::CIVector(); }
int PDIVectorCreate(PD_IVector* ivec, int* array, uint64_t size, bool copy) {
if (ivec == nullptr) return kPD_NULLPTR;
PD_IVector PDIVectorCreate(int* array, uint64_t size, bool copy, bool useGPU) {
auto ptr = new paddle::capi::CIVector();
if (copy) {
ptr->vec = paddle::IVector::create(size, false);
ptr->vec = paddle::IVector::create(size, useGPU);
ptr->vec->copyFrom(array, size);
} else {
ptr->vec = paddle::IVector::create(array, size, false);
ptr->vec = paddle::IVector::create(array, size, useGPU);
}
*ivec = ptr;
return kPD_NO_ERROR;
return ptr;
}
int PDIVecDestroy(PD_IVector ivec) {
PD_Error PDIVecDestroy(PD_IVector ivec) {
if (ivec == nullptr) return kPD_NULLPTR;
delete cast<paddle::capi::CIVector>(ivec);
return kPD_NO_ERROR;
}
int PDIVectorGet(PD_IVector ivec, int** buffer) {
PD_Error PDIVectorGet(PD_IVector ivec, int** buffer) {
if (ivec == nullptr || buffer == nullptr) return kPD_NULLPTR;
auto v = cast<paddle::capi::CIVector>(ivec);
if (v->vec == nullptr) return kPD_NULLPTR;
@ -53,7 +46,7 @@ int PDIVectorGet(PD_IVector ivec, int** buffer) {
return kPD_NO_ERROR;
}
int PDIVectorResize(PD_IVector ivec, uint64_t size) {
PD_Error PDIVectorResize(PD_IVector ivec, uint64_t size) {
if (ivec == nullptr) return kPD_NULLPTR;
auto v = cast<paddle::capi::CIVector>(ivec);
if (v->vec == nullptr) return kPD_NULLPTR;
@ -61,7 +54,7 @@ int PDIVectorResize(PD_IVector ivec, uint64_t size) {
return kPD_NO_ERROR;
}
int PDIVectorGetSize(PD_IVector ivec, uint64_t* size) {
PD_Error PDIVectorGetSize(PD_IVector ivec, uint64_t* size) {
if (ivec == nullptr) return kPD_NULLPTR;
auto v = cast<paddle::capi::CIVector>(ivec);
if (v->vec == nullptr) return kPD_NULLPTR;

31
paddle/capi/tests/test_Arguments.cpp
Unescape View File

@ -28,8 +28,7 @@ static std::vector<pd_real> randomBuffer(size_t bufSize) {
}
TEST(CAPIArguments, create) {
PD_Arguments args;
ASSERT_EQ(kPD_NO_ERROR, PDArgsCreateNone(&args));
PD_Arguments args = PDArgsCreateNone();
uint64_t size;
ASSERT_EQ(kPD_NO_ERROR, PDArgsGetSize(args, &size));
ASSERT_EQ(0UL, size);
@ -37,20 +36,17 @@ TEST(CAPIArguments, create) {
}
TEST(CAPIArguments, value) {
PD_Arguments args;
ASSERT_EQ(kPD_NO_ERROR, PDArgsCreateNone(&args));
PD_Arguments args = PDArgsCreateNone();
ASSERT_EQ(kPD_NO_ERROR, PDArgsResize(args, 1));
PD_Matrix mat;
ASSERT_EQ(kPD_NO_ERROR, PDMatCreate(&mat, 128, 64, false));
PD_Matrix mat = PDMatCreate(128, 64, false);
for (size_t i = 0; i < 128; ++i) {
std::vector<pd_real> sampleBuf = randomBuffer(64);
PDMatCopyToRow(mat, i, sampleBuf.data());
}
ASSERT_EQ(kPD_NO_ERROR, PDArgsSetValue(args, 0, mat));
PD_Matrix val;
ASSERT_EQ(kPD_NO_ERROR, PDMatCreateNone(&val));
PD_Matrix val = PDMatCreateNone();
ASSERT_EQ(kPD_NO_ERROR, PDArgsGetValue(args, 0, val));
@ -63,8 +59,7 @@ TEST(CAPIArguments, value) {
ASSERT_EQ(row1, row2);
}
PD_IVector ivec;
ASSERT_EQ(kPD_NO_ERROR, PDIVecCreateNone(&ivec));
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));
@ -72,17 +67,15 @@ TEST(CAPIArguments, value) {
}
TEST(CAPIArguments, ids) {
PD_Arguments args;
ASSERT_EQ(kPD_NO_ERROR, PDArgsCreateNone(&args));
PD_Arguments args = PDArgsCreateNone();
ASSERT_EQ(kPD_NO_ERROR, PDArgsResize(args, 1));
PD_IVector ivec;
int array[3] = {1, 2, 3};
ASSERT_EQ(kPD_NO_ERROR, PDIVectorCreate(&ivec, array, 3, true));
ivec = PDIVectorCreate(array, 3, true, false);
ASSERT_EQ(kPD_NO_ERROR, PDArgsSetIds(args, 0, ivec));
PD_IVector val;
ASSERT_EQ(kPD_NO_ERROR, PDIVecCreateNone(&val));
PD_IVector val = PDIVecCreateNone();
ASSERT_EQ(kPD_NO_ERROR, PDArgsGetIds(args, 0, val));
ASSERT_EQ(kPD_NO_ERROR, PDIVecDestroy(ivec));
ASSERT_EQ(kPD_NO_ERROR, PDIVecDestroy(val));
@ -91,17 +84,15 @@ TEST(CAPIArguments, ids) {
template <typename T1, typename T2>
void testSequenceHelper(T1 setter, T2 getter) {
PD_Arguments args;
ASSERT_EQ(kPD_NO_ERROR, PDArgsCreateNone(&args));
PD_Arguments args = PDArgsCreateNone();
ASSERT_EQ(kPD_NO_ERROR, PDArgsResize(args, 1));
PD_IVector ivec;
int array[3] = {1, 2, 3};
ASSERT_EQ(kPD_NO_ERROR, PDIVectorCreate(&ivec, array, 3, true));
ivec = PDIVectorCreate(array, 3, true, false);
ASSERT_EQ(kPD_NO_ERROR, setter(args, 0, ivec));
PD_IVector val;
ASSERT_EQ(kPD_NO_ERROR, PDIVecCreateNone(&val));
PD_IVector val = PDIVecCreateNone();
ASSERT_EQ(kPD_NO_ERROR, getter(args, 0, val));
uint64_t size;
ASSERT_EQ(kPD_NO_ERROR, PDIVectorGetSize(val, &size));

9
paddle/capi/tests/test_GradientMachine.cpp
Unescape View File

@ -55,14 +55,11 @@ TEST(GradientMachine, testPredict) {
PDGradientMachineCreateSharedParam(
machine, &buffer[0], (int)buffer.size(), &machineSlave));
std::swap(machineSlave, machine);
PD_Arguments outArgs;
ASSERT_EQ(kPD_NO_ERROR, PDArgsCreateNone(&outArgs));
PD_Arguments outArgs = PDArgsCreateNone();
PD_Arguments inArgs;
ASSERT_EQ(kPD_NO_ERROR, PDArgsCreateNone(&inArgs));
PD_Arguments inArgs = PDArgsCreateNone();
ASSERT_EQ(kPD_NO_ERROR, PDArgsResize(inArgs, 1));
PD_Matrix mat;
ASSERT_EQ(kPD_NO_ERROR, PDMatCreate(&mat, 1, 100, false));
PD_Matrix mat = PDMatCreate(1, 100, false);
static_assert(std::is_same<pd_real, paddle::real>::value, "");
auto data = randomBuffer(100);

6
paddle/capi/tests/test_Matrix.cpp
Unescape View File

@ -16,8 +16,7 @@ limitations under the License. */
#include "gtest/gtest.h"
TEST(CAPIMatrix, create) {
PD_Matrix mat;
ASSERT_EQ(kPD_NO_ERROR, PDMatCreate(&mat, 128, 32, false));
PD_Matrix mat = PDMatCreate(128, 32, false);
std::vector<pd_real> sampleRow;
sampleRow.resize(32);
for (size_t i = 0; i < sampleRow.size(); ++i) {
@ -41,7 +40,6 @@ TEST(CAPIMatrix, create) {
}
TEST(CAPIMatrix, createNone) {
PD_Matrix mat;
ASSERT_EQ(kPD_NO_ERROR, PDMatCreateNone(&mat));
PD_Matrix mat = PDMatCreateNone();
ASSERT_EQ(kPD_NO_ERROR, PDMatDestroy(mat));
}

6
paddle/capi/tests/test_Vector.cpp
Unescape View File

@ -18,8 +18,7 @@ limitations under the License. */
TEST(CAPIVector, create) {
PD_IVector vec;
int array[3] = {1, 2, 3};
ASSERT_EQ(kPD_NO_ERROR, PDIVectorCreate(&vec, array, 3, true));
ASSERT_EQ(kPD_NO_ERROR, PDIVectorCreate(&vec, array, 3, false));
vec = PDIVectorCreate(array, 3, true, false);
ASSERT_EQ(kPD_NO_ERROR, PDIVectorResize(vec, 1000));
uint64_t size;
ASSERT_EQ(kPD_NO_ERROR, PDIVectorGetSize(vec, &size));
@ -27,7 +26,6 @@ TEST(CAPIVector, create) {
}
TEST(CAPIVector, createNone) {
PD_IVector vec;
ASSERT_EQ(kPD_NO_ERROR, PDIVecCreateNone(&vec));
PD_IVector vec = PDIVecCreateNone();
ASSERT_EQ(kPD_NO_ERROR, PDIVecDestroy(vec));
}

Write Preview
Loading…
Cancel
Save