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