Merge pull request #1064 from hedaoyuan/buffer
Add BufferArg as the Function argument type and modify the Function prototype to remove the inouts argument.avx_docs
hedaoyuan
8 years ago
committed by
GitHub
commit
7df67bae8d
@ -0,0 +1,31 @@
|
||||
/* 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. */
|
||||
|
||||
#include <glog/logging.h>
|
||||
|
||||
#include "BufferArg.h"
|
||||
|
||||
namespace paddle {
|
||||
|
||||
const SequenceArg& BufferArg::sequence() const {
|
||||
// CHECK_EQ(bufferType_, TENSOR_SEQUENCE_DATA);
|
||||
return dynamic_cast<const SequenceArg&>(*this);
|
||||
}
|
||||
|
||||
const SparseMatrixArg& BufferArg::sparse() const {
|
||||
// CHECK_EQ(bufferType_, TENSOR_SPARSE);
|
||||
return dynamic_cast<const SparseMatrixArg&>(*this);
|
||||
}
|
||||
|
||||
} // namespace paddle
|
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,90 @@
|
||||
/* 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. */
|
||||
|
||||
#include "BufferArg.h"
|
||||
#include <gtest/gtest.h>
|
||||
#include "Function.h"
|
||||
#include "paddle/math/MemoryHandle.h"
|
||||
|
||||
namespace paddle {
|
||||
|
||||
TEST(BufferTest, BufferArg) {
|
||||
TensorShape shape({8, 10});
|
||||
CpuMemoryHandle memory(shape.getElements() *
|
||||
sizeOfValuType(VALUE_TYPE_FLOAT));
|
||||
BufferArg buffer(memory.getBuf(), VALUE_TYPE_FLOAT, shape);
|
||||
EXPECT_EQ(buffer.data(), memory.getBuf());
|
||||
}
|
||||
|
||||
TEST(BufferTest, SequenceIdArg) {
|
||||
TensorShape shape({10});
|
||||
CpuMemoryHandle memory(shape.getElements() *
|
||||
sizeOfValuType(VALUE_TYPE_INT32));
|
||||
SequenceIdArg buffer(memory.getBuf(), shape);
|
||||
EXPECT_EQ(buffer.data(), memory.getBuf());
|
||||
EXPECT_EQ(buffer.numSeqs(), 9);
|
||||
}
|
||||
|
||||
TEST(BufferTest, asArgument) {
|
||||
MatrixPtr matrix = Matrix::create(100, 200);
|
||||
VectorPtr vector = Vector::create(100, false);
|
||||
CpuSparseMatrix sparse(200, 300, 50);
|
||||
|
||||
// prepare arguments
|
||||
BufferArgs argments;
|
||||
argments.addArg(*matrix);
|
||||
argments.addArg(*vector);
|
||||
argments.addArg(sparse);
|
||||
|
||||
// function
|
||||
auto function = [=](const BufferArgs& inputs) {
|
||||
EXPECT_EQ(inputs.size(), 3);
|
||||
|
||||
// check inputs[0]
|
||||
EXPECT_EQ(inputs[0].shape().ndims(), 2);
|
||||
EXPECT_EQ(inputs[0].shape()[0], 100);
|
||||
EXPECT_EQ(inputs[0].shape()[1], 200);
|
||||
EXPECT_EQ(inputs[0].data(), matrix->getData());
|
||||
|
||||
EXPECT_EQ(inputs[0].matrix<DEVICE_TYPE_CPU>().getHeight(),
|
||||
matrix->getHeight());
|
||||
EXPECT_EQ(inputs[0].matrix<DEVICE_TYPE_CPU>().getWidth(),
|
||||
matrix->getWidth());
|
||||
EXPECT_EQ(inputs[0].matrix<DEVICE_TYPE_CPU>().getData(), matrix->getData());
|
||||
|
||||
// check inputs[1]
|
||||
EXPECT_EQ(inputs[1].shape().ndims(), 1);
|
||||
EXPECT_EQ(inputs[1].shape()[0], 100);
|
||||
EXPECT_EQ(inputs[1].data(), vector->getData());
|
||||
CpuVector inVector = inputs[1].vector<real, DEVICE_TYPE_CPU>();
|
||||
EXPECT_EQ(inVector.getSize(), vector->getSize());
|
||||
EXPECT_EQ(inVector.getData(), vector->getData());
|
||||
|
||||
// check inputs[2]
|
||||
EXPECT_EQ(inputs[2].shape().ndims(), 2);
|
||||
EXPECT_EQ(inputs[2].shape()[0], 200);
|
||||
EXPECT_EQ(inputs[2].shape()[1], 300);
|
||||
EXPECT_EQ(inputs[2].data(), sparse.getData());
|
||||
// CHECK_EQ(inputs[2].sparse().nnz(), 50);
|
||||
// CHECK_EQ(inputs[2].sparse().dataFormat(), SPARSE_CSR_FORMAT);
|
||||
// CHECK_EQ(inputs[2].sparse().dataType(), SPARSE_FLOAT_VALUE);
|
||||
EXPECT_EQ(inputs[2].sparse().getRowBuf(), sparse.getRows());
|
||||
EXPECT_EQ(inputs[2].sparse().getColBuf(), sparse.getCols());
|
||||
};
|
||||
|
||||
// call function
|
||||
function(argments);
|
||||
}
|
||||
|
||||
} // namespace paddle
|
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,59 @@
|
||||
/* 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. */
|
||||
|
||||
#include "Function.h"
|
||||
#include <gtest/gtest.h>
|
||||
|
||||
namespace paddle {
|
||||
|
||||
template <DeviceType DType>
|
||||
void FunctionApi(typename Tensor<real, DType>::Matrix& output,
|
||||
const typename Tensor<real, DType>::Matrix& input);
|
||||
|
||||
template <>
|
||||
void FunctionApi<DEVICE_TYPE_CPU>(CpuMatrix& output, const CpuMatrix& input) {
|
||||
EXPECT_EQ(output.getHeight(), 100);
|
||||
EXPECT_EQ(output.getWidth(), 200);
|
||||
}
|
||||
|
||||
template <>
|
||||
void FunctionApi<DEVICE_TYPE_GPU>(GpuMatrix& output, const GpuMatrix& input) {
|
||||
EXPECT_EQ(output.getHeight(), 10);
|
||||
EXPECT_EQ(output.getWidth(), 20);
|
||||
}
|
||||
|
||||
template <DeviceType DType>
|
||||
void Function(const BufferArgs& arguments) {
|
||||
const auto input = arguments[0].matrix<DType>();
|
||||
auto output = arguments[1].matrix<DType>();
|
||||
FunctionApi<DType>(output, input);
|
||||
}
|
||||
|
||||
TEST(Function, BufferArgs) {
|
||||
CpuMatrix cpuInput = CpuMatrix(100, 200);
|
||||
CpuMatrix cpuOutput = CpuMatrix(100, 200);
|
||||
BufferArgs cpuArgments;
|
||||
cpuArgments.addArg(cpuInput);
|
||||
cpuArgments.addArg(cpuOutput);
|
||||
Function<DEVICE_TYPE_CPU>(cpuArgments);
|
||||
|
||||
GpuMatrix gpuInput = GpuMatrix(10, 20);
|
||||
GpuMatrix gpuOutput = GpuMatrix(10, 20);
|
||||
BufferArgs gpuArgments;
|
||||
gpuArgments.addArg(gpuInput);
|
||||
gpuArgments.addArg(gpuOutput);
|
||||
Function<DEVICE_TYPE_GPU>(gpuArgments);
|
||||
}
|
||||
|
||||
} // namespace paddle
|
||||
@ -0,0 +1,97 @@
|
||||
/* 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. */
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <glog/logging.h>
|
||||
|
||||
namespace paddle {
|
||||
|
||||
/**
|
||||
* TensorShape used to represent shape of normal tensor.
|
||||
*/
|
||||
class TensorShape {
|
||||
public:
|
||||
TensorShape() : ndims_(0), nelements_(0) { initDims(0); }
|
||||
|
||||
TensorShape(size_t ndims) : ndims_(ndims), nelements_(1) { initDims(ndims); };
|
||||
|
||||
TensorShape(std::initializer_list<size_t> dims) {
|
||||
ndims_ = dims.size();
|
||||
initDims(ndims_);
|
||||
dims_.assign(dims);
|
||||
numElements();
|
||||
};
|
||||
|
||||
TensorShape(const TensorShape& t)
|
||||
: ndims_(t.ndims_), nelements_(t.nelements_) {
|
||||
initDims(ndims_);
|
||||
dims_.assign(t.dims_.begin(), t.dims_.end());
|
||||
};
|
||||
|
||||
// get the size of specified dimension
|
||||
size_t operator[](size_t dim) const {
|
||||
CHECK_GE(dim, (size_t)0);
|
||||
CHECK_LT(dim, ndims_);
|
||||
return dims_[dim];
|
||||
}
|
||||
|
||||
// set the size of specified dimension
|
||||
void setDim(size_t dim, size_t size) {
|
||||
CHECK_GE(dim, (size_t)0);
|
||||
CHECK_LT(dim, ndims_);
|
||||
dims_[dim] = size;
|
||||
numElements();
|
||||
}
|
||||
|
||||
// number of dimensions of the tensor
|
||||
size_t ndims() const { return ndims_; }
|
||||
|
||||
size_t getElements() const { return nelements_; }
|
||||
|
||||
bool operator==(const TensorShape& t) const {
|
||||
if (ndims() != t.ndims()) return false;
|
||||
for (size_t i = 0; i < ndims(); i++) {
|
||||
if (dims_[i] != t.dims_[i]) return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool operator!=(const TensorShape& t) const { return !(*this == t); }
|
||||
|
||||
private:
|
||||
// compute number of elements
|
||||
void numElements() {
|
||||
nelements_ = 1;
|
||||
for (size_t n = 0; n < ndims_; n++) {
|
||||
nelements_ *= dims_[n];
|
||||
}
|
||||
}
|
||||
|
||||
// init dims_
|
||||
void initDims(size_t ndims) {
|
||||
size_t count = ndims < 4 ? 4 : ndims;
|
||||
dims_.assign(count, 1);
|
||||
}
|
||||
|
||||
// number of dimensions
|
||||
// ndims_ may be not equeal dims_.size()
|
||||
size_t ndims_;
|
||||
// number of elements
|
||||
size_t nelements_;
|
||||
std::vector<size_t> dims_;
|
||||
};
|
||||
|
||||
} // namespace paddle
|
||||
@ -0,0 +1,53 @@
|
||||
/* 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. */
|
||||
|
||||
#include "TensorShape.h"
|
||||
#include <gtest/gtest.h>
|
||||
|
||||
namespace paddle {
|
||||
|
||||
TEST(TensorShape, Constructor) {
|
||||
TensorShape t1;
|
||||
EXPECT_EQ(t1.ndims(), 0);
|
||||
EXPECT_EQ(t1.getElements(), 0);
|
||||
|
||||
TensorShape t2(3);
|
||||
EXPECT_EQ(t2.ndims(), 3);
|
||||
EXPECT_EQ(t2.getElements(), 1);
|
||||
|
||||
TensorShape t3({8, 10});
|
||||
EXPECT_EQ(t3.ndims(), 2);
|
||||
EXPECT_EQ(t3.getElements(), 80);
|
||||
|
||||
TensorShape t4(t3);
|
||||
EXPECT_EQ(t4.ndims(), t3.ndims());
|
||||
EXPECT_EQ(t4.getElements(), t3.getElements());
|
||||
|
||||
TensorShape t5({1, 2, 3, 4, 5});
|
||||
EXPECT_EQ(t5.ndims(), 5);
|
||||
EXPECT_EQ(t5.getElements(), 120);
|
||||
}
|
||||
|
||||
TEST(TensorShape, GetAndSet) {
|
||||
TensorShape t({1, 2, 3});
|
||||
EXPECT_EQ(t.ndims(), 3);
|
||||
EXPECT_EQ(t.getElements(), 6);
|
||||
|
||||
EXPECT_EQ(t[1], 2);
|
||||
t.setDim(1, 100);
|
||||
EXPECT_EQ(t.getElements(), 300);
|
||||
EXPECT_EQ(t[1], 100);
|
||||
}
|
||||
|
||||
} // namespace paddle
|
||||
@ -0,0 +1,121 @@
|
||||
/* 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. */
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "paddle/math/Matrix.h"
|
||||
|
||||
namespace paddle {
|
||||
|
||||
enum ValueType {
|
||||
VALUE_TYPE_INT32 = 0,
|
||||
VALUE_TYPE_FLOAT = 1,
|
||||
VALUE_TYPE_DOUBLE = 2,
|
||||
VALUE_TYPE_BYTE = 3
|
||||
};
|
||||
|
||||
enum DeviceType {
|
||||
DEVICE_TYPE_UNSPECIFIED = 0,
|
||||
DEVICE_TYPE_CPU = 1,
|
||||
DEVICE_TYPE_GPU = 2
|
||||
};
|
||||
|
||||
inline int sizeOfValuType(ValueType valueType) {
|
||||
if (valueType == VALUE_TYPE_INT32) {
|
||||
return 4;
|
||||
} else if (valueType == VALUE_TYPE_FLOAT) {
|
||||
return 4;
|
||||
} else if (valueType == VALUE_TYPE_DOUBLE) {
|
||||
return 8;
|
||||
} else {
|
||||
LOG(FATAL) << "Unknown type: " << valueType;
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
struct DataType;
|
||||
|
||||
template <>
|
||||
struct DataType<float> {
|
||||
static const ValueType value = VALUE_TYPE_FLOAT;
|
||||
};
|
||||
|
||||
template <>
|
||||
struct DataType<double> {
|
||||
static const ValueType value = VALUE_TYPE_DOUBLE;
|
||||
};
|
||||
|
||||
template <>
|
||||
struct DataType<int> {
|
||||
static const ValueType value = VALUE_TYPE_INT32;
|
||||
};
|
||||
|
||||
namespace detail {
|
||||
|
||||
template <typename VType, DeviceType Device>
|
||||
struct MatrixT;
|
||||
|
||||
template <>
|
||||
struct MatrixT<real, DEVICE_TYPE_CPU> {
|
||||
using type = CpuMatrix;
|
||||
};
|
||||
|
||||
template <>
|
||||
struct MatrixT<real, DEVICE_TYPE_GPU> {
|
||||
using type = GpuMatrix;
|
||||
};
|
||||
|
||||
template <>
|
||||
struct MatrixT<int, DEVICE_TYPE_CPU> {
|
||||
using type = void; // Not implemented
|
||||
};
|
||||
|
||||
template <>
|
||||
struct MatrixT<int, DEVICE_TYPE_GPU> {
|
||||
using type = void; // Not implemented
|
||||
};
|
||||
|
||||
template <typename VType, DeviceType Device>
|
||||
struct VectorT;
|
||||
|
||||
template <>
|
||||
struct VectorT<real, DEVICE_TYPE_CPU> {
|
||||
using type = CpuVector;
|
||||
};
|
||||
|
||||
template <>
|
||||
struct VectorT<real, DEVICE_TYPE_GPU> {
|
||||
using type = GpuVector;
|
||||
};
|
||||
|
||||
template <>
|
||||
struct VectorT<int, DEVICE_TYPE_CPU> {
|
||||
using type = CpuIVector;
|
||||
};
|
||||
|
||||
template <>
|
||||
struct VectorT<int, DEVICE_TYPE_GPU> {
|
||||
using type = GpuIVector;
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
template <typename VType, DeviceType DType>
|
||||
struct Tensor {
|
||||
typedef typename detail::MatrixT<VType, DType>::type Matrix;
|
||||
typedef typename detail::VectorT<VType, DType>::type Vector;
|
||||
};
|
||||
|
||||
} // namespace paddle
|
||||
@ -0,0 +1,64 @@
|
||||
/* 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. */
|
||||
|
||||
#include "TensorType.h"
|
||||
#include <gtest/gtest.h>
|
||||
|
||||
namespace paddle {
|
||||
|
||||
TEST(TensorType, Matrix) {
|
||||
Tensor<real, DEVICE_TYPE_CPU>::Matrix matrix(100, 200);
|
||||
EXPECT_EQ(matrix.getHeight(), 100);
|
||||
EXPECT_EQ(matrix.getWidth(), 200);
|
||||
EXPECT_EQ(matrix.getElementCnt(), 100 * 200);
|
||||
EXPECT_EQ(matrix.useGpu(), false);
|
||||
|
||||
Tensor<real, DEVICE_TYPE_GPU>::Matrix testGpu(100, 200);
|
||||
EXPECT_EQ(testGpu.useGpu(), true);
|
||||
}
|
||||
|
||||
TEST(TensorType, Vector) {
|
||||
Tensor<real, DEVICE_TYPE_CPU>::Vector cpuVector(100);
|
||||
Tensor<real, DEVICE_TYPE_GPU>::Vector gpuVector(100);
|
||||
EXPECT_EQ(cpuVector.useGpu(), false);
|
||||
EXPECT_EQ(gpuVector.useGpu(), true);
|
||||
EXPECT_EQ(cpuVector.getSize(), 100);
|
||||
EXPECT_EQ(gpuVector.getSize(), 100);
|
||||
|
||||
Tensor<int, DEVICE_TYPE_CPU>::Vector cpuIVector(100);
|
||||
Tensor<int, DEVICE_TYPE_GPU>::Vector gpuIVector(100);
|
||||
EXPECT_EQ(cpuIVector.useGpu(), false);
|
||||
EXPECT_EQ(gpuIVector.useGpu(), true);
|
||||
EXPECT_EQ(cpuIVector.getSize(), 100);
|
||||
EXPECT_EQ(gpuIVector.getSize(), 100);
|
||||
}
|
||||
|
||||
TEST(TensorType, EmptyMatrix) {
|
||||
CpuMatrix empty(nullptr, 0, 0);
|
||||
CpuMatrix nonEmpty(10, 10);
|
||||
EXPECT_EQ(empty.isEmpty(), true);
|
||||
EXPECT_EQ(nonEmpty.isEmpty(), false);
|
||||
CHECK(nonEmpty);
|
||||
auto function = [](const CpuMatrix& matrix) {
|
||||
if (matrix) {
|
||||
EXPECT_NE(matrix.getData(), nullptr);
|
||||
} else {
|
||||
EXPECT_EQ(matrix.getData(), nullptr);
|
||||
}
|
||||
};
|
||||
function(empty);
|
||||
function(nonEmpty);
|
||||
}
|
||||
|
||||
} // namespace paddle
|
||||
Loading…
Reference in new issue