GitHub-Proxy/eigen
1
0
Fork 0
mirror of https://gitlab.com/libeigen/eigen.git synced 2025-06-04 18:54:00 +08:00
Code Issues Packages Projects Releases Wiki Activity

Fix compilation of tiled evaluation code with c++03

Browse Source
This commit is contained in:
Eugene Zhulenev 2018-09-11 13:32:32 -07:00
parent c144bb355b
commit 81b38a155a
9 changed files with 30 additions and 35 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
unsupported/Eigen/CXX11/src/Tensor/TensorBlock.h
View File

@ -396,8 +396,8 @@ struct TensorBlockCwiseUnaryOp {
typedef const Eigen::Array<InputScalar, Dynamic, 1> Input;
typedef Eigen::Array<OutputScalar, Dynamic, 1> Output;
typedef Eigen::Map<Input, 0, InnerStride<>> InputMap;
typedef Eigen::Map<Output, 0, InnerStride<>> OutputMap;
typedef Eigen::Map<Input, 0, InnerStride<> > InputMap;
typedef Eigen::Map<Output, 0, InnerStride<> > OutputMap;
const InputScalar* input_base = &input_data[input_index];
OutputScalar* output_base = &output_data[output_index];
@ -502,7 +502,7 @@ struct TensorBlockCwiseUnaryIO {
input_stride, input_data);
// Update index.
for (int j = 0; j < num_squeezed_dims; ++j) {
auto& state = block_iter_state[j];
BlockIteratorState& state = block_iter_state[j];
if (++state.count < state.size) {
output_index += state.output_stride;
input_index += state.input_stride;

11
unsupported/Eigen/CXX11/src/Tensor/TensorBroadcasting.h
View File

@ -596,12 +596,11 @@ struct TensorEvaluator<const TensorBroadcastingOp<Broadcast, ArgType>, Device>
std::vector<internal::TensorOpResourceRequirements>* resources) const {
// TODO(wuke): Targeting L1 size is 30% faster than targeting L{-1} on large
// tensors. But this might need further tuning.
auto block_total_size_max = numext::maxi<Eigen::Index>(
Eigen::Index block_total_size_max = numext::maxi<Eigen::Index>(
1, m_device.firstLevelCacheSize() / sizeof(Scalar));
resources->push_back(internal::TensorOpResourceRequirements(
internal::TensorBlockShapeType::kSkewedInnerDims,
block_total_size_max));
internal::kSkewedInnerDims, block_total_size_max));
m_impl.getResourceRequirements(resources);
}
@ -617,8 +616,8 @@ struct TensorEvaluator<const TensorBroadcastingOp<Broadcast, ArgType>, Device>
// equal to m_dimensions for inner dims, a smaller than m_dimensions[i] size
// for the first outer dim, and 1 for other outer dims. This is guaranteed
// by MergeResourceRequirements() in TensorBlock.h.
const auto& output_block_sizes = output_block->block_sizes();
const auto& output_block_strides = output_block->block_strides();
const Dimensions& output_block_sizes = output_block->block_sizes();
const Dimensions& output_block_strides = output_block->block_strides();
// Find where outer dims start.
int outer_dim_start = 0;
@ -642,7 +641,7 @@ struct TensorEvaluator<const TensorBroadcastingOp<Broadcast, ArgType>, Device>
return;
}
const auto& input_dims = m_impl.dimensions();
const Dimensions& input_dims = m_impl.dimensions();
// Pre-fill input_block_sizes, broadcast_block_sizes,
// broadcast_block_strides, and broadcast_tensor_strides. Later on we will

5
unsupported/Eigen/CXX11/src/Tensor/TensorChipping.h
View File

@ -290,11 +290,10 @@ struct TensorEvaluator<const TensorChippingOp<DimId, ArgType>, Device>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void getResourceRequirements(
std::vector<internal::TensorOpResourceRequirements>* resources) const {
auto block_total_size_max = numext::maxi<Eigen::Index>(
Eigen::Index block_total_size_max = numext::maxi<Eigen::Index>(
1, m_device.lastLevelCacheSize() / sizeof(Scalar));
resources->push_back(internal::TensorOpResourceRequirements(
internal::TensorBlockShapeType::kSkewedInnerDims,
block_total_size_max));
internal::kSkewedInnerDims, block_total_size_max));
m_impl.getResourceRequirements(resources);
}

5
unsupported/Eigen/CXX11/src/Tensor/TensorImagePatch.h
View File

@ -550,11 +550,10 @@ struct TensorEvaluator<const TensorImagePatchOp<Rows, Cols, ArgType>, Device>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void getResourceRequirements(
std::vector<internal::TensorOpResourceRequirements>* resources) const {
auto block_total_size_max = numext::maxi<Eigen::Index>(
Eigen::Index block_total_size_max = numext::maxi<Eigen::Index>(
1, m_device.lastLevelCacheSize() / sizeof(Scalar));
resources->push_back(internal::TensorOpResourceRequirements(
internal::TensorBlockShapeType::kSkewedInnerDims,
block_total_size_max));
internal::kSkewedInnerDims, block_total_size_max));
}
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void block(

5
unsupported/Eigen/CXX11/src/Tensor/TensorMorphing.h
View File

@ -677,11 +677,10 @@ struct TensorEvaluator<const TensorSlicingOp<StartIndices, Sizes, ArgType>, Devi
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void getResourceRequirements(
std::vector<internal::TensorOpResourceRequirements>* resources) const {
auto block_total_size_max = numext::maxi<Eigen::Index>(
Eigen::Index block_total_size_max = numext::maxi<Eigen::Index>(
1, m_device.lastLevelCacheSize() / sizeof(Scalar));
resources->push_back(internal::TensorOpResourceRequirements(
internal::TensorBlockShapeType::kSkewedInnerDims,
block_total_size_max));
internal::kSkewedInnerDims, block_total_size_max));
m_impl.getResourceRequirements(resources);
}

5
unsupported/Eigen/CXX11/src/Tensor/TensorReduction.h
View File

@ -771,11 +771,10 @@ struct TensorEvaluator<const TensorReductionOp<Op, Dims, ArgType, MakePointer_>,
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void getResourceRequirements(
std::vector<internal::TensorOpResourceRequirements>* resources) const {
auto block_total_size_max = numext::maxi<Eigen::Index>(
Eigen::Index block_total_size_max = numext::maxi<Eigen::Index>(
1, m_device.lastLevelCacheSize() / sizeof(Scalar));
resources->push_back(internal::TensorOpResourceRequirements(
internal::TensorBlockShapeType::kSkewedInnerDims,
block_total_size_max));
internal::kSkewedInnerDims, block_total_size_max));
m_impl.getResourceRequirements(resources);
}

4
unsupported/Eigen/CXX11/src/Tensor/TensorShuffling.h
View File

@ -229,10 +229,10 @@ struct TensorEvaluator<const TensorShufflingOp<Shuffle, ArgType>, Device>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void getResourceRequirements(
std::vector<internal::TensorOpResourceRequirements>* resources) const {
auto block_total_size_max = numext::maxi<Eigen::Index>(
Eigen::Index block_total_size_max = numext::maxi<Eigen::Index>(
1, m_device.firstLevelCacheSize() / sizeof(Scalar));
resources->push_back(internal::TensorOpResourceRequirements(
internal::TensorBlockShapeType::kUniformAllDims, block_total_size_max));
internal::kUniformAllDims, block_total_size_max));
m_impl.getResourceRequirements(resources);
}

14
unsupported/test/cxx11_tensor_block_access.cpp
View File

@ -535,7 +535,7 @@ static void test_block_cwise_unary_io_basic() {
DSizes<Index, NumDims> block_sizes = RandomDims<NumDims>();
DSizes<Index, NumDims> strides(ComputeStrides<Layout, NumDims>(block_sizes));
const auto total_size = block_sizes.TotalSize();
const Index total_size = block_sizes.TotalSize();
// Create a random input tensors.
T* input_data = GenerateRandomData<T>(total_size);
@ -562,12 +562,12 @@ static void test_block_cwise_unary_io_squeeze_ones() {
DSizes<Index, 5> block_sizes(1, 2, 1, 3, 1);
DSizes<Index, 5> strides(ComputeStrides<Layout, 5>(block_sizes));
const auto total_size = block_sizes.TotalSize();
const Index total_size = block_sizes.TotalSize();
// Create a random input tensors.
auto* input_data = GenerateRandomData<float>(total_size);
float* input_data = GenerateRandomData<float>(total_size);
auto* output_data = new float[total_size];
float* output_data = new float[total_size];
UnaryFunctor functor;
TensorBlockCwiseUnaryIO::Run(functor, block_sizes, strides, output_data,
strides, input_data);
@ -599,13 +599,13 @@ static void test_block_cwise_unary_io_zero_strides() {
input_strides[4] = 0;
// Generate random data.
auto* input_data = GenerateRandomData<float>(input_sizes.TotalSize());
float* input_data = GenerateRandomData<float>(input_sizes.TotalSize());
DSizes<Index, 5> output_sizes = rnd_dims;
DSizes<Index, 5> output_strides(ComputeStrides<Layout, 5>(output_sizes));
const auto output_total_size = output_sizes.TotalSize();
auto* output_data = new float[output_total_size];
const Index output_total_size = output_sizes.TotalSize();
float* output_data = new float[output_total_size];
UnaryFunctor functor;
TensorBlockCwiseUnaryIO::Run(functor, output_sizes, output_strides,

10
unsupported/test/cxx11_tensor_shuffling.cpp
View File

@ -81,12 +81,12 @@ static void test_expr_shuffling()
Tensor<float, 4, DataLayout> expected;
expected = tensor.shuffle(shuffles);
Tensor<float, 4, DataLayout> result(5,7,3,2);
Tensor<float, 4, DataLayout> result(5, 7, 3, 2);
array<ptrdiff_t, 4> src_slice_dim{{2,3,1,7}};
array<ptrdiff_t, 4> src_slice_start{{0,0,0,0}};
array<ptrdiff_t, 4> dst_slice_dim{{1,7,3,2}};
array<ptrdiff_t, 4> dst_slice_start{{0,0,0,0}};
array<ptrdiff_t, 4> src_slice_dim({2, 3, 1, 7});
array<ptrdiff_t, 4> src_slice_start({0, 0, 0, 0});
array<ptrdiff_t, 4> dst_slice_dim({1, 7, 3, 2});
array<ptrdiff_t, 4> dst_slice_start({0, 0, 0, 0});
for (int i = 0; i < 5; ++i) {
result.slice(dst_slice_start, dst_slice_dim) =