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

Export of internal Abseil changes.

Browse source 
--
da04b8cd21f6225d71397471474d34a77df0efd6 by Jon Cohen <cohenjon@google.com>:

Don't use std::any, std::optional, std::variant, and friends on MacOS versions older than 10.14.

Although Xcode 10 includes those headers and makes the types available to use, according to https://developer.apple.com/documentation/xcode_release_notes/xcode_10_release_notes, on MacOS 10.13 and earlier use of any functions (std::get, for example) results in an error message to upgrade to MacOS 10.14.

This fixes https://github.com/abseil/abseil-cpp/issues/207.  See that issue for more information on the error generated.

PiperOrigin-RevId: 221844618

--
1d99f77b4c60c5b0d7984f46e8ed63a3f969c635 by Jon Cohen <cohenjon@google.com>:

raw_hash_set_test is still flaky under gcc 4.8.  Since we now have the probe_test, we don't need the PerfectRatio tests.  Just remove them.

PiperOrigin-RevId: 221843042

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

Update absl/algorithm/CMakeLists.txt to use new functions
i.e. absl_cc_(library|test)

PiperOrigin-RevId: 221828348

--
1a5abde4f17f998ae89d87155d59f982a70202d8 by Jon Cohen <cohenjon@google.com>:

Internal change

PiperOrigin-RevId: 221708245

--
e03e031d4de39275989f695c768b0940cce1ff16 by Matt Armstrong <marmstrong@google.com>:

Log to FATAL in throw_delegate.h

ABSL_RAW_LOG(FATAL, ...) is guaranteed to abort.
Previously, the code was logging to ERROR and
calling abort() explicitly, which defeated any
integration with absl::raw_logging_internal::AbortHook().

These changes are limited to Abseil internal APIs.

PiperOrigin-RevId: 221696513

--
d13691523a3f9a5367fd1194cf9604bf4a969029 by Shahriar Rouf <nafi@google.com>:

Import of CCTZ from GitHub.

PiperOrigin-RevId: 221694877

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

Update absl/base/CMakeLists.txt to use new functions
i.e. absl_cc_(library|test)

PiperOrigin-RevId: 221676669
GitOrigin-RevId: da04b8cd21f6225d71397471474d34a77df0efd6
Change-Id: If6621e10d096a39b6a056a072c2727a0df0b0620
This commit is contained in:
Abseil Team 2018-11-16 13:36:37 -08:00 committed by Jon Cohen
parent a06c4a1d90
commit f6ae816808
9 changed files with 432 additions and 529 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

20
CMake/AbseilHelpers.cmake
View file

@ -73,11 +73,12 @@ endfunction()
# DEFINES: List of public defines
# LINKOPTS: List of link options
# PUBLIC: Add this so that this library will be exported under absl:: (see Note).
# Also in IDE, target will appear in Abseil folder while non PUBLIC will be in Abseil/internal.
# TESTONLY: When added, this target will only be built if user passes -DABSL_RUN_TESTS=ON to CMake.
#
# Note:
# By default, absl_cc_library will always create a library named absl_internal_${NAME},
# which means other targets can only depend this library as absl_internal_${NAME}, not ${NAME}.
# and alias target absl::${NAME}.
# This is to reduce namespace pollution.
#
# absl_cc_library(
@ -98,7 +99,7 @@ endfunction()
# )
#
# If PUBLIC is set, absl_cc_library will instead create a target named
# absl_${NAME} and an alias absl::${NAME}.
# absl_${NAME} and still an alias absl::${NAME}.
#
# absl_cc_library(
# NAME
@ -146,7 +147,13 @@ function(absl_cc_library)
target_compile_definitions(${_NAME} PUBLIC ${ABSL_CC_LIB_DEFINES})
# Add all Abseil targets to a a folder in the IDE for organization.
set_property(TARGET ${_NAME} PROPERTY FOLDER ${ABSL_IDE_FOLDER})
if(ABSL_CC_LIB_PUBLIC)
set_property(TARGET ${_NAME} PROPERTY FOLDER ${ABSL_IDE_FOLDER})
elseif(ABSL_CC_LIB_TESTONLY)
set_property(TARGET ${_NAME} PROPERTY FOLDER ${ABSL_IDE_FOLDER}/test)
else()
set_property(TARGET ${_NAME} PROPERTY FOLDER ${ABSL_IDE_FOLDER}/internal)
endif()
else()
# Generating header-only library
add_library(${_NAME} INTERFACE)
@ -157,10 +164,7 @@ function(absl_cc_library)
)
target_compile_definitions(${_NAME} INTERFACE ${ABSL_CC_LIB_DEFINES})
endif()
if(ABSL_CC_LIB_PUBLIC)
add_library(absl::${ABSL_CC_LIB_NAME} ALIAS ${_NAME})
endif()
add_library(absl::${ABSL_CC_LIB_NAME} ALIAS ${_NAME})
endif()
endfunction()
@ -231,7 +235,7 @@ function(absl_cc_test)
PRIVATE ${ABSL_CC_TEST_LINKOPTS}
)
# Add all Abseil targets to a a folder in the IDE for organization.
set_property(TARGET ${_NAME} PROPERTY FOLDER ${ABSL_IDE_FOLDER})
set_property(TARGET ${_NAME} PROPERTY FOLDER ${ABSL_IDE_FOLDER}/test)
add_test(NAME ${_NAME} COMMAND ${_NAME})
endfunction()

2
CMake/DownloadGTest.cmake
View file

@ -4,7 +4,7 @@
# Download the latest googletest from Github master
configure_file(
${CMAKE_CURRENT_LIST_DIR}/CMakeLists.txt.in
googletest-download/CMakeLists.txt
${CMAKE_BINARY_DIR}/googletest-download/CMakeLists.txt
)
# Configure and build the downloaded googletest source

70
absl/algorithm/CMakeLists.txt
View file

@ -14,50 +14,46 @@
# limitations under the License.
#
list(APPEND ALGORITHM_PUBLIC_HEADERS
"algorithm.h"
"container.h"
)
#
## TESTS
#
# test algorithm_test
list(APPEND ALGORITHM_TEST_SRC
"algorithm_test.cc"
${ALGORITHM_PUBLIC_HEADERS}
${ALGORITHM_INTERNAL_HEADERS}
)
absl_header_library(
TARGET
absl_algorithm
EXPORT_NAME
absl_cc_library(
NAME
algorithm
HDRS
"algorithm.h"
PUBLIC
)
absl_test(
TARGET
absl_cc_test(
NAME
algorithm_test
SOURCES
${ALGORITHM_TEST_SRC}
PUBLIC_LIBRARIES
SRCS
"algorithm_test.cc"
DEPS
absl::algorithm
gmock_main
)
absl_cc_library(
NAME
algorithm_container
HDRS
"container.h"
DEPS
absl::algorithm
absl::core_headers
absl::meta
PUBLIC
)
# test container_test
set(CONTAINER_TEST_SRC "container_test.cc")
absl_test(
TARGET
absl_cc_test(
NAME
container_test
SOURCES
${CONTAINER_TEST_SRC}
PUBLIC_LIBRARIES
absl::algorithm
SRCS
"container_test.cc"
DEPS
absl::algorithm_container
absl::base
absl::core_headers
absl::memory
absl::span
gmock_main
)

670
absl/base/CMakeLists.txt
View file

@ -14,118 +14,20 @@
# limitations under the License.
#
list(APPEND BASE_PUBLIC_HEADERS
"attributes.h"
"call_once.h"
"casts.h"
"config.h"
"dynamic_annotations.h"
"log_severity.h"
"macros.h"
"optimization.h"
"policy_checks.h"
"port.h"
"thread_annotations.h"
)
list(APPEND BASE_INTERNAL_HEADERS
"internal/atomic_hook.h"
"internal/bits.h"
"internal/cycleclock.h"
"internal/direct_mmap.h"
"internal/endian.h"
"internal/exception_testing.h"
"internal/exception_safety_testing.h"
"internal/hide_ptr.h"
"internal/identity.h"
"internal/invoke.h"
"internal/inline_variable.h"
"internal/low_level_alloc.h"
"internal/low_level_scheduling.h"
"internal/per_thread_tls.h"
"internal/pretty_function.h"
"internal/raw_logging.h"
"internal/scheduling_mode.h"
"internal/spinlock.h"
"internal/spinlock_wait.h"
"internal/sysinfo.h"
"internal/thread_identity.h"
"internal/throw_delegate.h"
"internal/tsan_mutex_interface.h"
"internal/unaligned_access.h"
"internal/unscaledcycleclock.h"
)
# absl_base main library
list(APPEND BASE_SRC
"internal/cycleclock.cc"
"internal/raw_logging.cc"
"internal/spinlock.cc"
"internal/sysinfo.cc"
"internal/thread_identity.cc"
"internal/unscaledcycleclock.cc"
"internal/low_level_alloc.cc"
${BASE_PUBLIC_HEADERS}
${BASE_INTERNAL_HEADERS}
)
absl_library(
TARGET
absl_base
SOURCES
${BASE_SRC}
PUBLIC_LIBRARIES
absl_dynamic_annotations
absl_internal_spinlock_wait
EXPORT_NAME
base
)
absl_cc_library(
NAME
throw_delegate
SRCS
"internal/throw_delegate.cc"
spinlock_wait
HDRS
"internal/throw_delegate.h"
COPTS
${ABSL_EXCEPTIONS_FLAG}
DEPS
absl::base
)
# exception-safety testing library
absl_cc_library(
NAME
exception_safety_testing
HDRS
"internal/exception_safety_testing.h"
"internal/scheduling_mode.h"
"internal/spinlock_wait.h"
SRCS
"internal/exception_safety_testing.cc"
COPTS
${ABSL_EXCEPTIONS_FLAG}
"internal/spinlock_akaros.inc"
"internal/spinlock_linux.inc"
"internal/spinlock_posix.inc"
"internal/spinlock_wait.cc"
"internal/spinlock_win32.inc"
DEPS
absl::base
absl::memory
absl::meta
absl::strings
absl::optional
gtest
TESTONLY
)
# dynamic_annotations library
set(DYNAMIC_ANNOTATIONS_SRC "dynamic_annotations.cc")
absl_library(
TARGET
absl_dynamic_annotations
SOURCES
${DYNAMIC_ANNOTATIONS_SRC}
absl::core_headers
)
absl_cc_library(
@ -137,6 +39,18 @@ absl_cc_library(
PUBLIC
)
absl_cc_library(
NAME
dynamic_annotations
HDRS
"dynamic_annotations.h"
SRCS
"dynamic_annotations.cc"
DEFINES
"__CLANG_SUPPORT_DYN_ANNOTATION__"
PUBLIC
)
absl_cc_library(
NAME
core_headers
@ -153,244 +67,326 @@ absl_cc_library(
absl_cc_library(
NAME
spinlock_wait
SRCS
"internal/spinlock_wait.cc"
malloc_internal
HDRS
"internal/scheduling_mode.h"
"internal/spinlock_wait.h"
"internal/direct_mmap.h"
"internal/low_level_alloc.h"
SRCS
"internal/low_level_alloc.cc"
DEPS
absl::base
absl::config
absl::core_headers
absl::dynamic_annotations
absl::spinlock_wait
)
absl_cc_library(
NAME
malloc_internal
SRCS
"internal/low_level_alloc.cc"
base_internal
HDRS
"internal/direct_mmap.h"
"internal/low_level_alloc.h"
"internal/hide_ptr.h"
"internal/identity.h"
"internal/inline_variable.h"
"internal/invoke.h"
)
absl_cc_library(
NAME
base
HDRS
"call_once.h"
"casts.h"
"internal/atomic_hook.h"
"internal/cycleclock.h"
"internal/low_level_scheduling.h"
"internal/per_thread_tls.h"
"internal/raw_logging.h"
"internal/spinlock.h"
"internal/sysinfo.h"
"internal/thread_identity.h"
"internal/tsan_mutex_interface.h"
"internal/unscaledcycleclock.h"
"log_severity.h"
SRCS
"internal/cycleclock.cc"
"internal/raw_logging.cc"
"internal/spinlock.cc"
"internal/sysinfo.cc"
"internal/thread_identity.cc"
"internal/unscaledcycleclock.cc"
DEPS
absl_dynamic_annotations
absl::base_internal
absl::config
absl::core_headers
absl::dynamic_annotations
absl::spinlock_wait
PUBLIC
)
#
## TESTS
#
# call once test
set(ATOMIC_HOOK_TEST_SRC "internal/atomic_hook_test.cc")
set(ATOMIC_HOOK_TEST_PUBLIC_LIBRARIES absl::base)
absl_test(
TARGET
atomic_hook_test
SOURCES
${ATOMIC_HOOK_TEST_SRC}
PUBLIC_LIBRARIES
${ATOMIC_HOOK_TEST_PUBLIC_LIBRARIES}
)
# call once test
set(CALL_ONCE_TEST_SRC "call_once_test.cc")
set(CALL_ONCE_TEST_PUBLIC_LIBRARIES absl::base absl::synchronization)
absl_test(
TARGET
call_once_test
SOURCES
${CALL_ONCE_TEST_SRC}
PUBLIC_LIBRARIES
${CALL_ONCE_TEST_PUBLIC_LIBRARIES}
)
# test bit_cast_test
set(BIT_CAST_TEST_SRC "bit_cast_test.cc")
absl_test(
TARGET
bit_cast_test
SOURCES
${BIT_CAST_TEST_SRC}
)
# test absl_throw_delegate_test
set(THROW_DELEGATE_TEST_SRC "throw_delegate_test.cc")
set(THROW_DELEGATE_TEST_PUBLIC_LIBRARIES absl::base absl_internal_throw_delegate)
absl_test(
TARGET
throw_delegate_test
SOURCES
${THROW_DELEGATE_TEST_SRC}
PUBLIC_LIBRARIES
${THROW_DELEGATE_TEST_PUBLIC_LIBRARIES}
)
# test invoke_test
set(INVOKE_TEST_SRC "invoke_test.cc")
set(INVOKE_TEST_PUBLIC_LIBRARIES absl::strings)
absl_test(
TARGET
invoke_test
SOURCES
${INVOKE_TEST_SRC}
PUBLIC_LIBRARIES
${INVOKE_TEST_PUBLIC_LIBRARIES}
)
# test inline_variable_test
list(APPEND INLINE_VARIABLE_TEST_SRC
"internal/inline_variable_testing.h"
"inline_variable_test.cc"
"inline_variable_test_a.cc"
"inline_variable_test_b.cc"
)
set(INLINE_VARIABLE_TEST_PUBLIC_LIBRARIES absl::base)
absl_test(
TARGET
inline_variable_test
SOURCES
${INLINE_VARIABLE_TEST_SRC}
PUBLIC_LIBRARIES
${INLINE_VARIABLE_TEST_PUBLIC_LIBRARIES}
)
# test spinlock_test_common
set(SPINLOCK_TEST_COMMON_SRC "spinlock_test_common.cc")
set(SPINLOCK_TEST_COMMON_PUBLIC_LIBRARIES absl::base absl::synchronization)
absl_test(
TARGET
spinlock_test_common
SOURCES
${SPINLOCK_TEST_COMMON_SRC}
PUBLIC_LIBRARIES
${SPINLOCK_TEST_COMMON_PUBLIC_LIBRARIES}
)
# test spinlock_test
set(SPINLOCK_TEST_SRC "spinlock_test_common.cc")
set(SPINLOCK_TEST_PUBLIC_LIBRARIES absl::base absl::synchronization)
absl_test(
TARGET
spinlock_test
SOURCES
${SPINLOCK_TEST_SRC}
PUBLIC_LIBRARIES
${SPINLOCK_TEST_PUBLIC_LIBRARIES}
)
# test endian_test
set(ENDIAN_TEST_SRC "internal/endian_test.cc")
absl_test(
TARGET
endian_test
SOURCES
${ENDIAN_TEST_SRC}
)
# test config_test
set(CONFIG_TEST_SRC "config_test.cc")
set(CONFIG_TEST_PUBLIC_LIBRARIES absl::base absl::synchronization)
absl_test(
TARGET
config_test
SOURCES
${CONFIG_TEST_SRC}
PUBLIC_LIBRARIES
${CONFIG_TEST_PUBLIC_LIBRARIES}
)
# test raw_logging_test
set(RAW_LOGGING_TEST_SRC "raw_logging_test.cc")
set(RAW_LOGGING_TEST_PUBLIC_LIBRARIES absl::base absl::strings)
absl_test(
TARGET
raw_logging_test
SOURCES
${RAW_LOGGING_TEST_SRC}
PUBLIC_LIBRARIES
${RAW_LOGGING_TEST_PUBLIC_LIBRARIES}
)
# test sysinfo_test
set(SYSINFO_TEST_SRC "internal/sysinfo_test.cc")
set(SYSINFO_TEST_PUBLIC_LIBRARIES absl::base absl::synchronization)
absl_test(
TARGET
sysinfo_test
SOURCES
${SYSINFO_TEST_SRC}
PUBLIC_LIBRARIES
${SYSINFO_TEST_PUBLIC_LIBRARIES}
)
# test low_level_alloc_test
set(LOW_LEVEL_ALLOC_TEST_SRC "internal/low_level_alloc_test.cc")
set(LOW_LEVEL_ALLOC_TEST_PUBLIC_LIBRARIES absl::base)
absl_test(
TARGET
low_level_alloc_test
SOURCES
${LOW_LEVEL_ALLOC_TEST_SRC}
PUBLIC_LIBRARIES
${LOW_LEVEL_ALLOC_TEST_PUBLIC_LIBRARIES}
)
# test thread_identity_test
set(THREAD_IDENTITY_TEST_SRC "internal/thread_identity_test.cc")
set(THREAD_IDENTITY_TEST_PUBLIC_LIBRARIES absl::base absl::synchronization)
absl_test(
TARGET
thread_identity_test
SOURCES
${THREAD_IDENTITY_TEST_SRC}
PUBLIC_LIBRARIES
${THREAD_IDENTITY_TEST_PUBLIC_LIBRARIES}
)
#test exceptions_safety_testing_test
set(EXCEPTION_SAFETY_TESTING_TEST_SRC "exception_safety_testing_test.cc")
set(EXCEPTION_SAFETY_TESTING_TEST_PUBLIC_LIBRARIES
absl::base
absl_internal_exception_safety_testing
absl::memory
absl::meta
absl::strings
absl::utility
)
absl_test(
TARGET
absl_exception_safety_testing_test
SOURCES
${EXCEPTION_SAFETY_TESTING_TEST_SRC}
PUBLIC_LIBRARIES
${EXCEPTION_SAFETY_TESTING_TEST_PUBLIC_LIBRARIES}
PRIVATE_COMPILE_FLAGS
absl_cc_library(
NAME
throw_delegate
HDRS
"internal/throw_delegate.h"
SRCS
"internal/throw_delegate.cc"
COPTS
${ABSL_EXCEPTIONS_FLAG}
DEPS
absl::base
)
absl_cc_library(
NAME
exception_testing
HDRS
"internal/exception_testing.h"
DEPS
absl::config
gtest
TESTONLY
)
absl_cc_library(
NAME
pretty_function
HDRS
"internal/pretty_function.h"
)
absl_cc_library(
NAME
exception_safety_testing
HDRS
"internal/exception_safety_testing.h"
SRCS
"internal/exception_safety_testing.cc"
COPTS
${ABSL_EXCEPTIONS_FLAG}
DEPS
absl::base
absl::config
absl::pretty_function
absl::memory
absl::meta
absl::strings
absl::utility
gtest
TESTONLY
)
absl_cc_test(
NAME
absl_exception_safety_testing_test
SRCS
"exception_safety_testing_test.cc"
COPTS
${ABSL_EXCEPTIONS_FLAG}
LINKOPTS
${ABSL_EXCEPTIONS_FLAG_LINKOPTS}
DEPS
absl::exception_safety_testing
absl::memory
gtest_main
)
absl_cc_test(
NAME
atomic_hook_test
SRCS
"internal/atomic_hook_test.cc"
DEPS
absl::base
absl::core_headers
gtest_main
)
absl_cc_test(
NAME
bit_cast_test
SRCS
"bit_cast_test.cc"
DEPS
absl::base
absl::core_headers
gtest_main
)
absl_cc_test(
NAME
throw_delegate_test
SRCS
"throw_delegate_test.cc"
DEPS
absl::base
absl_internal_throw_delegate
gtest_main
)
absl_cc_test(
NAME
inline_variable_test
SRCS
"internal/inline_variable_testing.h"
"inline_variable_test.cc"
"inline_variable_test_a.cc"
"inline_variable_test_b.cc"
DEPS
absl::base_internal
gtest_main
)
absl_cc_test(
NAME
invoke_test
SRCS
"invoke_test.cc"
DEPS
absl::base_internal
absl::memory
absl::strings
gmock
gtest_main
)
absl_cc_library(
NAME
spinlock_test_common
SRCS
"spinlock_test_common.cc"
COPTS
${ABSL_TEST_COPTS}
DEPS
absl::base
absl::core_headers
absl::spinlock_wait
absl::synchronization
gtest
PUBLIC
)
# On bazel BUILD this target use "alwayslink = 1" which is not implemented here
absl_cc_test(
NAME
spinlock_test
SRCS
"spinlock_test_common.cc"
DEPS
absl::base
absl::core_headers
absl::spinlock_wait
absl::synchronization
gtest_main
)
absl_cc_library(
NAME
endian
HDRS
"internal/endian.h"
"internal/unaligned_access.h"
DEPS
absl::config
absl::core_headers
PUBLIC
)
absl_cc_test(
NAME
endian_test
SRCS
"internal/endian_test.cc"
DEPS
absl::base
absl::config
absl::endian
gtest_main
)
absl_cc_test(
NAME
config_test
SRCS
"config_test.cc"
DEPS
absl::config
absl::synchronization
gtest_main
)
absl_cc_test(
NAME
call_once_test
SRCS
"call_once_test.cc"
DEPS
absl::base
absl::core_headers
absl::synchronization
gtest_main
)
absl_cc_test(
NAME
raw_logging_test
SRCS
"raw_logging_test.cc"
DEPS
absl::base
absl::strings
gtest_main
)
absl_cc_test(
NAME
sysinfo_test
SRCS
"internal/sysinfo_test.cc"
DEPS
absl::base
absl::synchronization
gtest_main
)
absl_cc_test(
NAME
low_level_alloc_test
SRCS
"internal/low_level_alloc_test.cc"
DEPS
absl::malloc_internal
Threads::Threads
)
absl_cc_test(
NAME
thread_identity_test
SRCS
"internal/thread_identity_test.cc"
DEPS
absl::base
absl::core_headers
absl::synchronization
Threads::Threads
gtest_main
)
absl_cc_library(
NAME
bits
HDRS
"internal/bits.h"
DEPS
absl::core_headers
)
absl_cc_test(
NAME
bits_test
SRCS
"internal/bits_test.cc"
DEPS
absl::bits
gtest_main
)

21
absl/base/config.h
View file

@ -365,6 +365,18 @@
#error "absl endian detection needs to be set up for your compiler"
#endif
// MacOS 10.13 doesn't let you use <any>, <optional>, or <variant> even though
// the headers exist and are publicly noted to work. See
// https://github.com/abseil/abseil-cpp/issues/207 and
// https://developer.apple.com/documentation/xcode_release_notes/xcode_10_release_notes
#if defined(__APPLE__) && defined(_LIBCPP_VERSION) && \
defined(__MAC_OS_X_VERSION_MIN_REQUIRED__) && \
__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 101400
#define ABSL_INTERNAL_MACOS_HAS_CXX_17_TYPES 1
#else
#define ABSL_INTERNAL_MACOS_HAS_CXX_17_TYPES 0
#endif
// ABSL_HAVE_STD_ANY
//
// Checks whether C++17 std::any is available by checking whether <any> exists.
@ -373,7 +385,8 @@
#endif
#ifdef __has_include
#if __has_include(<any>) && __cplusplus >= 201703L
#if __has_include(<any>) && __cplusplus >= 201703L && \
ABSL_INTERNAL_MACOS_HAS_CXX_17_TYPES
#define ABSL_HAVE_STD_ANY 1
#endif
#endif
@ -386,7 +399,8 @@
#endif
#ifdef __has_include
#if __has_include(<optional>) && __cplusplus >= 201703L
#if __has_include(<optional>) && __cplusplus >= 201703L && \
ABSL_INTERNAL_MACOS_HAS_CXX_17_TYPES
#define ABSL_HAVE_STD_OPTIONAL 1
#endif
#endif
@ -399,7 +413,8 @@
#endif
#ifdef __has_include
#if __has_include(<variant>) && __cplusplus >= 201703L
#if __has_include(<variant>) && __cplusplus >= 201703L && \
ABSL_INTERNAL_MACOS_HAS_CXX_17_TYPES
#define ABSL_HAVE_STD_VARIANT 1
#endif
#endif

4
absl/base/internal/throw_delegate.cc
View file

@ -30,8 +30,8 @@ template <typename T>
#ifdef ABSL_HAVE_EXCEPTIONS
throw error;
#else
ABSL_RAW_LOG(ERROR, "%s", error.what());
abort();
ABSL_RAW_LOG(FATAL, "%s", error.what());
std::abort();
#endif
}
} // namespace

138
absl/container/internal/raw_hash_set_test.cc
View file

@ -14,7 +14,6 @@
#include "absl/container/internal/raw_hash_set.h"
#include <array>
#include <cmath>
#include <cstdint>
#include <deque>
@ -1782,143 +1781,6 @@ TEST(Table, IterationOrderChangesForSmallTables) {
FAIL() << "Iteration order remained the same across many attempts.";
}
// Fill the table to 3 different load factors (min, median, max) and evaluate
// the percentage of perfect hits using the debug API.
template <class Table, class AddFn>
std::vector<double> CollectPerfectRatios(Table, AddFn add) {
std::vector<double> results(3);
constexpr size_t kNumTrials = 10;
std::vector<Table> tables(kNumTrials);
for (Table& t : tables) {
using Key = typename Table::key_type;
// First, fill enough to have a good distribution.
constexpr size_t kMinSize = 10000;
std::vector<Key> keys;
while (t.size() < kMinSize) keys.push_back(add(t));
// Then, insert until we reach min load factor.
double lf = t.load_factor();
while (lf <= t.load_factor()) keys.push_back(add(t));
// We are now at min load factor. Take a snapshot.
size_t perfect = 0;
auto update_perfect = [&](Key k) {
perfect += GetHashtableDebugNumProbes(t, k) == 0;
};
for (const auto& k : keys) update_perfect(k);
std::vector<double> perfect_ratios;
// Keep going until we hit max load factor.
while (t.load_factor() < .6) {
perfect_ratios.push_back(1.0 * perfect / t.size());
update_perfect(add(t));
}
while (t.load_factor() > .5) {
perfect_ratios.push_back(1.0 * perfect / t.size());
update_perfect(add(t));
}
results[0] += perfect_ratios.front();
results[1] += perfect_ratios[perfect_ratios.size() / 2];
results[2] += perfect_ratios.back();
}
results[0] /= kNumTrials;
results[1] /= kNumTrials;
results[2] /= kNumTrials;
return results;
}
std::vector<std::pair<double, double>> StringTablePefectRatios() {
constexpr bool kRandomizesInserts =
#if NDEBUG
false;
#else // NDEBUG
true;
#endif // NDEBUG
// The effective load factor is larger in non-opt mode because we insert
// elements out of order.
switch (container_internal::Group::kWidth) {
case 8:
if (kRandomizesInserts) {
return {{0.986, 0.02}, {0.95, 0.02}, {0.89, 0.02}};
} else {
return {{0.995, 0.01}, {0.97, 0.01}, {0.89, 0.02}};
}
case 16:
if (kRandomizesInserts) {
return {{0.973, 0.01}, {0.965, 0.01}, {0.92, 0.02}};
} else {
return {{0.995, 0.005}, {0.99, 0.005}, {0.94, 0.01}};
}
}
ABSL_RAW_LOG(FATAL, "%s", "Unknown Group width");
return {};
}
// This is almost a change detector, but it allows us to know how we are
// affecting the probe distribution.
TEST(Table, EffectiveLoadFactorStrings) {
std::vector<double> perfect_ratios =
CollectPerfectRatios(StringTable(), [](StringTable& t) {
return t.emplace(std::to_string(t.size()), "").first->first;
});
auto ratios = StringTablePefectRatios();
if (ratios.empty()) return;
EXPECT_THAT(perfect_ratios,
ElementsAre(DoubleNear(ratios[0].first, ratios[0].second),
DoubleNear(ratios[1].first, ratios[1].second),
DoubleNear(ratios[2].first, ratios[2].second)));
}
std::vector<std::pair<double, double>> IntTablePefectRatios() {
constexpr bool kRandomizesInserts =
#ifdef NDEBUG
false;
#else // NDEBUG
true;
#endif // NDEBUG
// The effective load factor is larger in non-opt mode because we insert
// elements out of order.
switch (container_internal::Group::kWidth) {
case 8:
if (kRandomizesInserts) {
return {{0.99, 0.02}, {0.985, 0.02}, {0.95, 0.05}};
} else {
return {{0.99, 0.01}, {0.99, 0.01}, {0.95, 0.02}};
}
case 16:
if (kRandomizesInserts) {
return {{0.98, 0.02}, {0.978, 0.02}, {0.96, 0.02}};
} else {
return {{0.998, 0.003}, {0.995, 0.01}, {0.975, 0.02}};
}
}
ABSL_RAW_LOG(FATAL, "%s", "Unknown Group width");
return {};
}
// This is almost a change detector, but it allows us to know how we are
// affecting the probe distribution.
TEST(Table, EffectiveLoadFactorInts) {
std::vector<double> perfect_ratios = CollectPerfectRatios(
IntTable(), [](IntTable& t) { return *t.emplace(t.size()).first; });
auto ratios = IntTablePefectRatios();
if (ratios.empty()) return;
EXPECT_THAT(perfect_ratios,
ElementsAre(DoubleNear(ratios[0].first, ratios[0].second),
DoubleNear(ratios[1].first, ratios[1].second),
DoubleNear(ratios[2].first, ratios[2].second)));
}
// Confirm that we assert if we try to erase() end().
TEST(TableDeathTest, EraseOfEndAsserts) {
// Use an assert with side-effects to figure out if they are actually enabled.

2
absl/debugging/CMakeLists.txt
View file

@ -85,7 +85,7 @@ absl_library(
${SYMBOLIZE_SRC}
PUBLIC_LIBRARIES
absl::base
absl_internal_malloc_internal
absl::malloc_internal
EXPORT_NAME
symbolize
)

34
absl/time/internal/cctz/include/cctz/civil_time_detail.h
View file

@ -326,6 +326,37 @@ CONSTEXPR_F fields align(year_tag, fields f) noexcept {
////////////////////////////////////////////////////////////////////////
namespace impl {
template <typename H>
H AbslHashValueImpl(second_tag, H h, fields f) {
return H::combine(std::move(h), f.y, f.m, f.d, f.hh, f.mm, f.ss);
}
template <typename H>
H AbslHashValueImpl(minute_tag, H h, fields f) {
return H::combine(std::move(h), f.y, f.m, f.d, f.hh, f.mm);
}
template <typename H>
H AbslHashValueImpl(hour_tag, H h, fields f) {
return H::combine(std::move(h), f.y, f.m, f.d, f.hh);
}
template <typename H>
H AbslHashValueImpl(day_tag, H h, fields f) {
return H::combine(std::move(h), f.y, f.m, f.d);
}
template <typename H>
H AbslHashValueImpl(month_tag, H h, fields f) {
return H::combine(std::move(h), f.y, f.m);
}
template <typename H>
H AbslHashValueImpl(year_tag, H h, fields f) {
return H::combine(std::move(h), f.y);
}
} // namespace impl
////////////////////////////////////////////////////////////////////////
template <typename T>
class civil_time {
public:
@ -418,8 +449,7 @@ class civil_time {
template <typename H>
friend H AbslHashValue(H h, civil_time a) {
return H::combine(std::move(h), a.f_.y, a.f_.m, a.f_.d,
a.f_.hh, a.f_.mm, a.f_.ss);
return impl::AbslHashValueImpl(T{}, std::move(h), a.f_);
}
private: