mdebray/tvl-depot
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Export of internal Abseil changes.

Browse source 
--
ba4dd47492748bd630462eb68b7959037fc6a11a by Abseil Team <absl-team@google.com>:

Work around nvcc 9.0 compiler bug for open-source Tensorflow build.

With the current implementation, when I (unintentionally and transitively)
include absl/types/optional.h in a CUDA compilation unit, I get the following
nvcc error message:
  INFO: From Compiling tensorflow/core/kernels/crop_and_resize_op_gpu.cu.cc:
  external/com_google_absl/absl/types/optional.h: In member function 'void absl::optional_internal::optional_data_dtor_base<T, <anonymous> >::destruct()':
  external/com_google_absl/absl/types/optional.h:185:50: error: '__T0' was not declared in this scope
         data_.~T();

I've also seen similar compilation failures online, for flat_hash_map:
https://devtalk.nvidia.com/default/topic/1042599/nvcc-preprocessor-bug-causes-compilation-failure/

The bug is always around unnamed template parameters. Therefore, the workaround is to make them named.

PiperOrigin-RevId: 219208288

--
dad2f40cb2e8d5017660985ef6fb57f3c3cdcc80 by CJ Johnson <johnsoncj@google.com>:

Adds internal macros for catching and throwing unknown exception types

PiperOrigin-RevId: 219207362

--
0a9840328d2d86e8420b853435fdbf1f7a19d931 by Abseil Team <absl-team@google.com>:

Fix typo in mutex.h comments.

PiperOrigin-RevId: 219199397

--
0d576dc7597564210bfdf91518075064756f0bf4 by Matt Calabrese <calabrese@google.com>:

Internal change.

PiperOrigin-RevId: 219185475

--
66be156095571959fb19a76da8ad0b53ec37658e by Abseil Team <absl-team@google.com>:

Fix alignment conformance for VS 2017 >= 15.8 (fix #193)

PiperOrigin-RevId: 219129894

--
a6e1825a12587945f8194677ccfdcaba6f7aad1d by Abseil Team <absl-team@google.com>:

Reapply PR #173

PiperOrigin-RevId: 219129361

--
cf72ade4881b25acc6ccaea468f69793a0fdce32 by Abseil Team <absl-team@google.com>:

Update .gitignore

PiperOrigin-RevId: 219127495

--
0537490c6348a2cb489abe15638928ac5aa6982a by Jon Cohen <cohenjon@google.com>:

Small refactor and reformat of error messages from the exception safety test framework.

PiperOrigin-RevId: 218927773

--
4c556ca45fa25698ad12002a00c713aeceefab73 by CJ Johnson <johnsoncj@google.com>:

Updates the inlined vector swap tests to check for number of moves that took place if available

PiperOrigin-RevId: 218900777

--
dcbfda0021a1e6dfa9586986b1269c06ec394053 by Mark Barolak <mbar@google.com>:

Add parens around calls to std::numeric_limits<>::min and
std::numeric_limits<>::max to prevent compilation errors on Windows platforms
where min and max are defined as macros.

PiperOrigin-RevId: 218888700
GitOrigin-RevId: ba4dd47492748bd630462eb68b7959037fc6a11a
Change-Id: I0e393958eb8cb501b85f6114979f6d4d86ed996c
This commit is contained in:
Abseil Team 2018-10-29 15:53:34 -07:00 • committed by Matt Calabrese
parent 0117457865
commit a4c3ffff11
20 changed files with 147 additions and 110 deletions
Download patch file Download diff file Expand all files Collapse all files

33
absl/time/time.h
View file

@ -402,10 +402,10 @@ Duration Milliseconds(T n) {
template <typename T, time_internal::EnableIfFloat<T> = 0>
Duration Seconds(T n) {
if (n >= 0) {
if (n >= std::numeric_limits<int64_t>::max()) return InfiniteDuration();
if (n >= (std::numeric_limits<int64_t>::max)()) return InfiniteDuration();
return time_internal::MakePosDoubleDuration(n);
} else {
if (n <= std::numeric_limits<int64_t>::min()) return -InfiniteDuration();
if (n <= (std::numeric_limits<int64_t>::min)()) return -InfiniteDuration();
return -time_internal::MakePosDoubleDuration(-n);
}
}
@ -686,7 +686,7 @@ constexpr Time UniversalEpoch() {
// Returns an `absl::Time` that is infinitely far in the future.
constexpr Time InfiniteFuture() {
return Time(
time_internal::MakeDuration(std::numeric_limits<int64_t>::max(), ~0U));
time_internal::MakeDuration((std::numeric_limits<int64_t>::max)(), ~0U));
}
// InfinitePast()
@ -694,7 +694,7 @@ constexpr Time InfiniteFuture() {
// Returns an `absl::Time` that is infinitely far in the past.
constexpr Time InfinitePast() {
return Time(
time_internal::MakeDuration(std::numeric_limits<int64_t>::min(), ~0U));
time_internal::MakeDuration((std::numeric_limits<int64_t>::min)(), ~0U));
}
// FromUnixNanos()
@ -1329,8 +1329,8 @@ constexpr bool IsInfiniteDuration(Duration d) { return GetRepLo(d) == ~0U; }
// REQUIRES: IsInfiniteDuration(d)
constexpr Duration OppositeInfinity(Duration d) {
return GetRepHi(d) < 0
? MakeDuration(std::numeric_limits<int64_t>::max(), ~0U)
: MakeDuration(std::numeric_limits<int64_t>::min(), ~0U);
? MakeDuration((std::numeric_limits<int64_t>::max)(), ~0U)
: MakeDuration((std::numeric_limits<int64_t>::min)(), ~0U);
}
// Returns (-n)-1 (equivalently -(n+1)) without avoidable overflow.
@ -1355,14 +1355,14 @@ constexpr Duration FromInt64(int64_t v, std::ratio<1, N>) {
v / N, v % N * kTicksPerNanosecond * 1000 * 1000 * 1000 / N);
}
constexpr Duration FromInt64(int64_t v, std::ratio<60>) {
return (v <= std::numeric_limits<int64_t>::max() / 60 &&
v >= std::numeric_limits<int64_t>::min() / 60)
return (v <= (std::numeric_limits<int64_t>::max)() / 60 &&
v >= (std::numeric_limits<int64_t>::min)() / 60)
? MakeDuration(v * 60)
: v > 0 ? InfiniteDuration() : -InfiniteDuration();
}
constexpr Duration FromInt64(int64_t v, std::ratio<3600>) {
return (v <= std::numeric_limits<int64_t>::max() / 3600 &&
v >= std::numeric_limits<int64_t>::min() / 3600)
return (v <= (std::numeric_limits<int64_t>::max)() / 3600 &&
v >= (std::numeric_limits<int64_t>::min)() / 3600)
? MakeDuration(v * 3600)
: v > 0 ? InfiniteDuration() : -InfiniteDuration();
}
@ -1421,8 +1421,8 @@ T ToChronoDuration(Duration d) {
if (time_internal::IsInfiniteDuration(d))
return d < ZeroDuration() ? T::min() : T::max();
const auto v = ToInt64(d, Period{});
if (v > std::numeric_limits<Rep>::max()) return T::max();
if (v < std::numeric_limits<Rep>::min()) return T::min();
if (v > (std::numeric_limits<Rep>::max)()) return T::max();
if (v < (std::numeric_limits<Rep>::min)()) return T::min();
return T{v};
}
@ -1449,7 +1449,8 @@ constexpr Duration Hours(int64_t n) {
constexpr bool operator<(Duration lhs, Duration rhs) {
return time_internal::GetRepHi(lhs) != time_internal::GetRepHi(rhs)
? time_internal::GetRepHi(lhs) < time_internal::GetRepHi(rhs)
: time_internal::GetRepHi(lhs) == std::numeric_limits<int64_t>::min()
: time_internal::GetRepHi(lhs) ==
(std::numeric_limits<int64_t>::min)()
? time_internal::GetRepLo(lhs) + 1 <
time_internal::GetRepLo(rhs) + 1
: time_internal::GetRepLo(lhs) <
@ -1474,7 +1475,8 @@ constexpr Duration operator-(Duration d) {
// a second's worth of ticks and avoid overflow (as negating int64_t-min + 1
// is safe).
return time_internal::GetRepLo(d) == 0
? time_internal::GetRepHi(d) == std::numeric_limits<int64_t>::min()
? time_internal::GetRepHi(d) ==
(std::numeric_limits<int64_t>::min)()
? InfiniteDuration()
: time_internal::MakeDuration(-time_internal::GetRepHi(d))
: time_internal::IsInfiniteDuration(d)
@ -1487,7 +1489,8 @@ constexpr Duration operator-(Duration d) {
}
constexpr Duration InfiniteDuration() {
return time_internal::MakeDuration(std::numeric_limits<int64_t>::max(), ~0U);
return time_internal::MakeDuration((std::numeric_limits<int64_t>::max)(),
~0U);
}
constexpr Duration FromChrono(const std::chrono::nanoseconds& d) {