devtools/eigen
1
0
Fork 0
mirror of https://gitlab.com/libeigen/eigen.git synced 2026-04-10 11:34:33 +08:00
Code Issues Packages Projects Releases Wiki Activity

Revert "Avoid integer overflow in EigenMetaKernel indexing"

Browse Source 
This reverts commit 100d7caf92
This commit is contained in:
Antonio Sánchez
2021-10-27 14:55:25 +00:00
parent 68e0d023c0
commit 185ad0e610
3 changed files with 7 additions and 86 deletions
Download Patch File Download Diff File Expand all files Collapse all files

42
unsupported/Eigen/CXX11/src/Tensor/TensorExecutor.h
View File

@@ -553,39 +553,11 @@ class TensorExecutor<Expression, GpuDevice, Vectorizable, Tiling> {
};
#if defined(EIGEN_GPUCC)
// Returns lhs + rhs, saturating to the highest/lowest representable value on
// overflow/underflow respectively.
template <typename Index>
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Index saturate_add(Index lhs, Index rhs) {
const Index highest = NumTraits<Index>::highest();
const Index lowest = NumTraits<Index>::lowest();
if (lhs > 0 && rhs > 0) {
return (lhs > highest - rhs) ? highest : lhs + rhs;
} else if (lhs < 0 && rhs < 0) {
return (lhs < lowest - rhs) ? lowest : lhs + rhs;
} else {
return lhs + rhs;
}
}
#if !defined(EIGEN_USE_HIP)
// Specialization for int32 using PTX intrinsic.
template <>
__device__ EIGEN_ALWAYS_INLINE int32_t saturate_add<int32_t>(int32_t lhs,
int32_t rhs) {
// add.sat is only supported for s32.
int32_t result;
asm("add.sat.s32 %0, %1, %2;" : "=r"(result) : "r"(lhs), "r"(rhs));
return result;
}
#endif
template <typename Evaluator, typename StorageIndex, bool Vectorizable>
struct EigenMetaKernelEval {
static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
void run(Evaluator& eval, StorageIndex firstIdx, StorageIndex lastIdx, StorageIndex step_size) {
for (StorageIndex i = firstIdx; i < lastIdx;
i = saturate_add(i, step_size)) {
for (StorageIndex i = firstIdx; i < lastIdx; i += step_size) {
eval.evalScalar(i);
}
}
@@ -601,11 +573,10 @@ struct EigenMetaKernelEval<Evaluator, StorageIndex, true> {
// Use the vector path
for (StorageIndex i = firstIdx * PacketSize; i < vectorized_size;
i = saturate_add(i, vectorized_step_size)) {
i += vectorized_step_size) {
eval.evalPacket(i);
}
for (StorageIndex i = saturate_add(vectorized_size, firstIdx); i < lastIdx;
i = saturate_add(i, step_size)) {
for (StorageIndex i = vectorized_size + firstIdx; i < lastIdx; i += step_size) {
eval.evalScalar(i);
}
}
@@ -632,11 +603,8 @@ EIGEN_STRONG_INLINE void TensorExecutor<Expression, GpuDevice, Vectorizable, Til
if (needs_assign) {
const int block_size = device.maxGpuThreadsPerBlock();
const int max_blocks =
numext::mini<int64_t>(device.getNumGpuMultiProcessors() *
device.maxGpuThreadsPerMultiProcessor(),
NumTraits<StorageIndex>::highest()) /
block_size;
const int max_blocks = device.getNumGpuMultiProcessors() *
device.maxGpuThreadsPerMultiProcessor() / block_size;
const StorageIndex size = array_prod(evaluator.dimensions());
// Create a least one block to ensure we won't crash when tensorflow calls with tensors of size 0.
const int num_blocks = numext::maxi<int>(numext::mini<int>(max_blocks, divup<int>(size, block_size)), 1);

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

@@ -30,15 +30,13 @@ const T2& choose(Cond<false>, const T1&, const T2& second) {
template <typename T, typename X, typename Y>
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
T divup(const X x, const Y y) {
// Note: This form is used because it cannot overflow.
return static_cast<T>(x == 0 ? 0 : (x - 1) / y + 1);
return static_cast<T>((x + y - 1) / y);
}
template <typename T>
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
T divup(const T x, const T y) {
// Note: This form is used because it cannot overflow.
return static_cast<T>(x == 0 ? 0 : (x - 1) / y + 1);
return static_cast<T>((x + y - 1) / y);
}
template <size_t n> struct max_n_1 {