Chiebot-Mirror
/
abseil-cpp
mirror of https://hub.fastgit.xyz/abseil/abseil-cpp.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

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
pull/226/head
Abseil Team 6 years ago committed by Jon Cohen
parent a06c4a1d90
commit f6ae816808
9 changed files with 384 additions and 481 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 20
      CMake/AbseilHelpers.cmake
  2. 2
      CMake/DownloadGTest.cmake
  3. 70
      absl/algorithm/CMakeLists.txt
  4. 574
      absl/base/CMakeLists.txt
  5. 21
      absl/base/config.h
  6. 4
      absl/base/internal/throw_delegate.cc
  7. 138
      absl/container/internal/raw_hash_set_test.cc
  8. 2
      absl/debugging/CMakeLists.txt
  9. 34
      absl/time/internal/cctz/include/cctz/civil_time_detail.h

20
CMake/AbseilHelpers.cmake
Unescape 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
Unescape 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
Unescape 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
)

574
absl/base/CMakeLists.txt
Unescape View File

@ -14,90 +14,147 @@
# 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"
absl_cc_library(
NAME
spinlock_wait
HDRS
"internal/scheduling_mode.h"
"internal/spinlock_wait.h"
SRCS
"internal/spinlock_akaros.inc"
"internal/spinlock_linux.inc"
"internal/spinlock_posix.inc"
"internal/spinlock_wait.cc"
"internal/spinlock_win32.inc"
DEPS
absl::core_headers
)
absl_cc_library(
NAME
config
HDRS
"config.h"
"policy_checks.h"
PUBLIC
)
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_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
HDRS
"attributes.h"
"macros.h"
"optimization.h"
"port.h"
"thread_annotations.h"
DEPS
absl::config
PUBLIC
)
# 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_cc_library(
NAME
malloc_internal
HDRS
"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_library(
TARGET
absl_base
SOURCES
${BASE_SRC}
PUBLIC_LIBRARIES
absl_dynamic_annotations
absl_internal_spinlock_wait
EXPORT_NAME
absl_cc_library(
NAME
base_internal
HDRS
"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::base_internal
absl::config
absl::core_headers
absl::dynamic_annotations
absl::spinlock_wait
PUBLIC
)
absl_cc_library(
NAME
throw_delegate
SRCS
"internal/throw_delegate.cc"
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"
)
# exception-safety testing library
absl_cc_library(
NAME
exception_safety_testing
@ -109,288 +166,227 @@ absl_cc_library(
${ABSL_EXCEPTIONS_FLAG}
DEPS
absl::base
absl::config
absl::pretty_function
absl::memory
absl::meta
absl::strings
absl::optional
absl::utility
gtest
TESTONLY
)
# dynamic_annotations library
set(DYNAMIC_ANNOTATIONS_SRC "dynamic_annotations.cc")
absl_library(
TARGET
absl_dynamic_annotations
SOURCES
${DYNAMIC_ANNOTATIONS_SRC}
)
absl_cc_library(
absl_cc_test(
NAME
config
HDRS
"config.h"
"policy_checks.h"
PUBLIC
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_library(
absl_cc_test(
NAME
core_headers
HDRS
"attributes.h"
"macros.h"
"optimization.h"
"port.h"
"thread_annotations.h"
atomic_hook_test
SRCS
"internal/atomic_hook_test.cc"
DEPS
absl::config
PUBLIC
absl::base
absl::core_headers
gtest_main
)
absl_cc_library(
absl_cc_test(
NAME
spinlock_wait
bit_cast_test
SRCS
"internal/spinlock_wait.cc"
HDRS
"internal/scheduling_mode.h"
"internal/spinlock_wait.h"
"bit_cast_test.cc"
DEPS
absl::base
absl::core_headers
gtest_main
)
absl_cc_library(
absl_cc_test(
NAME
malloc_internal
throw_delegate_test
SRCS
"internal/low_level_alloc.cc"
HDRS
"internal/direct_mmap.h"
"internal/low_level_alloc.h"
"throw_delegate_test.cc"
DEPS
absl_dynamic_annotations
)
#
## 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}
absl::base
absl_internal_throw_delegate
gtest_main
)
# 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}
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
)
# test invoke_test
set(INVOKE_TEST_SRC "invoke_test.cc")
set(INVOKE_TEST_PUBLIC_LIBRARIES absl::strings)
absl_test(
TARGET
absl_cc_test(
NAME
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}
SRCS
"invoke_test.cc"
DEPS
absl::base_internal
absl::memory
absl::strings
gmock
gtest_main
)
# 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
absl_cc_library(
NAME
spinlock_test_common
SOURCES
${SPINLOCK_TEST_COMMON_SRC}
PUBLIC_LIBRARIES
${SPINLOCK_TEST_COMMON_PUBLIC_LIBRARIES}
SRCS
"spinlock_test_common.cc"
COPTS
${ABSL_TEST_COPTS}
DEPS
absl::base
absl::core_headers
absl::spinlock_wait
absl::synchronization
gtest
PUBLIC
)
# test spinlock_test
set(SPINLOCK_TEST_SRC "spinlock_test_common.cc")
set(SPINLOCK_TEST_PUBLIC_LIBRARIES absl::base absl::synchronization)
absl_test(
TARGET
# On bazel BUILD this target use "alwayslink = 1" which is not implemented here
absl_cc_test(
NAME
spinlock_test
SOURCES
${SPINLOCK_TEST_SRC}
PUBLIC_LIBRARIES
${SPINLOCK_TEST_PUBLIC_LIBRARIES}
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
)
# test endian_test
set(ENDIAN_TEST_SRC "internal/endian_test.cc")
absl_test(
TARGET
absl_cc_test(
NAME
endian_test
SOURCES
${ENDIAN_TEST_SRC}
SRCS
"internal/endian_test.cc"
DEPS
absl::base
absl::config
absl::endian
gtest_main
)
# test config_test
set(CONFIG_TEST_SRC "config_test.cc")
set(CONFIG_TEST_PUBLIC_LIBRARIES absl::base absl::synchronization)
absl_test(
TARGET
absl_cc_test(
NAME
config_test
SOURCES
${CONFIG_TEST_SRC}
PUBLIC_LIBRARIES
${CONFIG_TEST_PUBLIC_LIBRARIES}
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
)
# 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
absl_cc_test(
NAME
raw_logging_test
SOURCES
${RAW_LOGGING_TEST_SRC}
PUBLIC_LIBRARIES
${RAW_LOGGING_TEST_PUBLIC_LIBRARIES}
SRCS
"raw_logging_test.cc"
DEPS
absl::base
absl::strings
gtest_main
)
# test sysinfo_test
set(SYSINFO_TEST_SRC "internal/sysinfo_test.cc")
set(SYSINFO_TEST_PUBLIC_LIBRARIES absl::base absl::synchronization)
absl_test(
TARGET
absl_cc_test(
NAME
sysinfo_test
SOURCES
${SYSINFO_TEST_SRC}
PUBLIC_LIBRARIES
${SYSINFO_TEST_PUBLIC_LIBRARIES}
SRCS
"internal/sysinfo_test.cc"
DEPS
absl::base
absl::synchronization
gtest_main
)
# 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
absl_cc_test(
NAME
low_level_alloc_test
SOURCES
${LOW_LEVEL_ALLOC_TEST_SRC}
PUBLIC_LIBRARIES
${LOW_LEVEL_ALLOC_TEST_PUBLIC_LIBRARIES}
SRCS
"internal/low_level_alloc_test.cc"
DEPS
absl::malloc_internal
Threads::Threads
)
# 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
absl_cc_test(
NAME
thread_identity_test
SOURCES
${THREAD_IDENTITY_TEST_SRC}
PUBLIC_LIBRARIES
${THREAD_IDENTITY_TEST_PUBLIC_LIBRARIES}
SRCS
"internal/thread_identity_test.cc"
DEPS
absl::base
absl::core_headers
absl::synchronization
Threads::Threads
gtest_main
)
#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_cc_library(
NAME
bits
HDRS
"internal/bits.h"
DEPS
absl::core_headers
)
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_EXCEPTIONS_FLAG}
absl_cc_test(
NAME
bits_test
SRCS
"internal/bits_test.cc"
DEPS
absl::bits
gtest_main
)

21
absl/base/config.h
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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:

Write Preview
Loading…
Cancel
Save