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

Export of internal Abseil changes.

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

Fix miscellaneous CMake change interleaving issues for the daily release:
  * add back the absl::container target
  * Add copts to absl_cc_library targets in absl/container/CMakeLists.txt
  * Add trailing newline to the end of AbseilConfigureCopts.cmake

PiperOrigin-RevId: 223057096

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

Internal Cleanup.

PiperOrigin-RevId: 223051579

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

Internal Change.

PiperOrigin-RevId: 223046855

--
5467ad987ea82aef77d2f1cc85aa9105e7d9c320 by Samuel Benzaquen <sbenza@google.com>:

Workaround for gcc bug https://gcc.gnu.org/PR88115

PiperOrigin-RevId: 223041901

--
36fa5cfd41df2b71d26487c45363901bbf6a2463 by Tom Manshreck <shreck@google.com>:

Clarify visit() constraints

PiperOrigin-RevId: 223032194

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

Fix comment typos.

PiperOrigin-RevId: 223024090

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

Make absl::spinlock_test_common TESTONLY

This should fix https://github.com/abseil/abseil-cpp/issues/221

PiperOrigin-RevId: 222885323

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

Internal change.

PiperOrigin-RevId: 222877017

--
96ff25bf78c4f4bca0d6e61faa4feeab91a2e73c by Jon Cohen <cohenjon@google.com>:

Align CMake and Bazel compile options.  This is the first step towards a single source of truth for Abseil compile options.  Also makes absl_test and absl_cc_test make binaries and targets with compatible names to each other to make testing easier.

PiperOrigin-RevId: 222858408

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

Revert "absl: cap SpinLock backoff to 4ms"

PiperOrigin-RevId: 222656230

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

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

PiperOrigin-RevId: 222535766

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

Disable header parsing for broken targets

PiperOrigin-RevId: 222257218

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

absl: cap SpinLock backoff to 4ms

The current backoff logic has 3 problems:
1. It can produce too high values (up to 256ms), which can negatively
affect tail latency. The value was chosen long time ago and now it's
a good idea to reconsider it.
2. It does not have low bound, so on any iteration it can produce
a very small value that will lead to unnecessary cpu consumption.
3. It does not increase low bound with the number of iterations.
So if the SpinLock is actually somehow locked for a very prolonged time,
a waiter can still wake periodically.

Rework the logic to solve these problems.
Add lower bound of 128us, no code should rely on absence of episodic
delays in this range as they can occur everywhere.
Lower upper bound to 4ms. A thread sleeping for 4ms does not consume
significant cpu time (see below).
Grow lower bound with the number of iterations.

This is cpu consumption of a process doing usleep(x) in a loop
(sampled with ps):

    64us -> 4.0%
   128us -> 2.7%
   256us -> 3.5%
   512us -> 2.8%
  1024us -> 1.6%
  2048us -> 0.6%
  4096us -> 0.3%
  8192us -> 0.0%

Few millisecond sleeps do not consume significant time.

PiperOrigin-RevId: 222196086

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

Add benchmarks for hashing civil_times.

PiperOrigin-RevId: 222152108
GitOrigin-RevId: 15d7bcf28220750db46930f4d8c090b54e3ae5fe
Change-Id: I73b929feaf6ce72b70fdafd6108f53bbbeaf9738
This commit is contained in:
Abseil Team 2018-11-27 14:21:25 -08:00 committed by vslashg
parent 3088e76c59
commit 13327debeb
18 changed files with 989 additions and 186 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

145
CMake/AbseilConfigureCopts.cmake Normal file
View file

@ -0,0 +1,145 @@
# Abseil-specific compiler flags. See absl/copts.bzl for description.
# DO NOT CHANGE THIS FILE WITHOUT THE CORRESPONDING CHANGE TO absl/copts.bzl
list(APPEND GCC_FLAGS
-Wall
-Wextra
-Wcast-qual
-Wconversion-null
-Wmissing-declarations
-Woverlength-strings
-Wpointer-arith
-Wunused-local-typedefs
-Wunused-result
-Wvarargs
-Wwrite-strings
-Wno-sign-compare
)
list(APPEND GCC_TEST_FLAGS
-Wno-conversion-null
-Wno-missing-declarations
-Wno-sign-compare
-Wno-unused-function
-Wno-unused-parameter
-Wno-unused-private-field
)
list(APPEND LLVM_FLAGS
-Wall
-Wextra
-Weverything
-Wno-c++98-compat-pedantic
-Wno-conversion
-Wno-covered-switch-default
-Wno-deprecated
-Wno-disabled-macro-expansion
-Wno-double-promotion
-Wno-comma
-Wno-extra-semi
-Wno-packed
-Wno-padded
-Wno-sign-compare
-Wno-float-conversion
-Wno-float-equal
-Wno-format-nonliteral
-Wno-gcc-compat
-Wno-global-constructors
-Wno-exit-time-destructors
-Wno-nested-anon-types
-Wno-non-modular-include-in-module
-Wno-old-style-cast
-Wno-range-loop-analysis
-Wno-reserved-id-macro
-Wno-shorten-64-to-32
-Wno-switch-enum
-Wno-thread-safety-negative
-Wno-undef
-Wno-unknown-warning-option
-Wno-unreachable-code
-Wno-unused-macros
-Wno-weak-vtables
-Wbitfield-enum-conversion
-Wbool-conversion
-Wconstant-conversion
-Wenum-conversion
-Wint-conversion
-Wliteral-conversion
-Wnon-literal-null-conversion
-Wnull-conversion
-Wobjc-literal-conversion
-Wno-sign-conversion
-Wstring-conversion
)
list(APPEND LLVM_TEST_FLAGS
-Wno-c99-extensions
-Wno-missing-noreturn
-Wno-missing-prototypes
-Wno-missing-variable-declarations
-Wno-null-conversion
-Wno-shadow
-Wno-shift-sign-overflow
-Wno-sign-compare
-Wno-unused-function
-Wno-unused-member-function
-Wno-unused-parameter
-Wno-unused-private-field
-Wno-unused-template
-Wno-used-but-marked-unused
-Wno-zero-as-null-pointer-constant
-Wno-gnu-zero-variadic-macro-arguments
)
list(APPEND MSVC_FLAGS
/W3
/wd4005
/wd4018
/wd4068
/wd4180
/wd4244
/wd4267
/wd4800
/DNOMINMAX
/DWIN32_LEAN_AND_MEAN
/D_CRT_SECURE_NO_WARNINGS
/D_SCL_SECURE_NO_WARNINGS
/D_ENABLE_EXTENDED_ALIGNED_STORAGE
)
list(APPEND MSVC_TEST_FLAGS
/wd4101
/wd4503
)
if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
set(ABSL_DEFAULT_COPTS "${GCC_FLAGS}")
set(ABSL_TEST_COPTS "${GCC_FLAGS};${GCC_TEST_FLAGS}")
set(ABSL_EXCEPTIONS_FLAG "-fexceptions")
elseif("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
# MATCHES so we get both Clang and AppleClang
set(ABSL_DEFAULT_COPTS "${LLVM_FLAGS}")
set(ABSL_TEST_COPTS "${LLVM_FLAGS};${LLVM_TEST_FLAGS}")
set(ABSL_EXCEPTIONS_FLAG "-fexceptions")
elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
set(ABSL_DEFAULT_COPTS "${MSVC_FLAGS}")
set(ABSL_TEST_COPTS "${MSVC_FLAGS};${MSVC_TEST_FLAGS}")
set(ABSL_EXCEPTIONS_FLAG "/U_HAS_EXCEPTIONS;/D_HAS_EXCEPTIONS=1;/EHsc")
else()
message(WARNING "Unknown compiler: ${CMAKE_CXX_COMPILER}. Building with no default flags")
set(ABSL_DEFAULT_COPTS "")
set(ABSL_TEST_COPTS "")
set(ABSL_EXCEPTIONS_FLAG "")
endif()
# This flag is used internally for Bazel builds and is kept here for consistency
set(ABSL_EXCEPTIONS_FLAG_LINKOPTS "")
if("${CMAKE_CXX_STANDARD}" EQUAL 98)
message(FATAL_ERROR "Abseil requires at least C++11")
elseif(NOT "${CMAKE_CXX_STANDARD}")
message(STATUS "No CMAKE_CXX_STANDARD set, assuming 11")
set(ABSL_CXX_STANDARD 11)
else()
set(ABSL_CXX_STANDARD "${CMAKE_CXX_STANDARD}")
endif()

42
CMake/AbseilHelpers.cmake
View file

@ -15,6 +15,7 @@
# #
include(CMakeParseArguments) include(CMakeParseArguments)
include(AbseilConfigureCopts)
# The IDE folder for Abseil that will be used if Abseil is included in a CMake # The IDE folder for Abseil that will be used if Abseil is included in a CMake
# project that sets # project that sets
@ -48,7 +49,11 @@ function(absl_library)
add_library(${_NAME} STATIC ${ABSL_LIB_SOURCES}) add_library(${_NAME} STATIC ${ABSL_LIB_SOURCES})
target_compile_options(${_NAME} PRIVATE ${ABSL_LIB_PRIVATE_COMPILE_FLAGS}) target_compile_options(${_NAME}
PRIVATE
${ABSL_LIB_PRIVATE_COMPILE_FLAGS}
${ABSL_DEFAULT_COPTS}
)
target_link_libraries(${_NAME} PUBLIC ${ABSL_LIB_PUBLIC_LIBRARIES}) target_link_libraries(${_NAME} PUBLIC ${ABSL_LIB_PUBLIC_LIBRARIES})
target_include_directories(${_NAME} target_include_directories(${_NAME}
PUBLIC ${ABSL_COMMON_INCLUDE_DIRS} ${ABSL_LIB_PUBLIC_INCLUDE_DIRS} PUBLIC ${ABSL_COMMON_INCLUDE_DIRS} ${ABSL_LIB_PUBLIC_INCLUDE_DIRS}
@ -57,6 +62,9 @@ function(absl_library)
# Add all Abseil targets to a a folder in the IDE for organization. # 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})
set_property(TARGET ${_NAME} PROPERTY CXX_STANDARD ${ABSL_CXX_STANDARD})
set_property(TARGET ${_NAME} PROPERTY CXX_STANDARD_REQUIRED ON)
if(ABSL_LIB_EXPORT_NAME) if(ABSL_LIB_EXPORT_NAME)
add_library(absl::${ABSL_LIB_EXPORT_NAME} ALIAS ${_NAME}) add_library(absl::${ABSL_LIB_EXPORT_NAME} ALIAS ${_NAME})
endif() endif()
@ -154,6 +162,10 @@ function(absl_cc_library)
else() else()
set_property(TARGET ${_NAME} PROPERTY FOLDER ${ABSL_IDE_FOLDER}/internal) set_property(TARGET ${_NAME} PROPERTY FOLDER ${ABSL_IDE_FOLDER}/internal)
endif() endif()
# INTERFACE libraries can't have the CXX_STANDARD property set
set_property(TARGET ${_NAME} PROPERTY CXX_STANDARD ${ABSL_CXX_STANDARD})
set_property(TARGET ${_NAME} PROPERTY CXX_STANDARD_REQUIRED ON)
else() else()
# Generating header-only library # Generating header-only library
add_library(${_NAME} INTERFACE) add_library(${_NAME} INTERFACE)
@ -164,6 +176,7 @@ function(absl_cc_library)
) )
target_compile_definitions(${_NAME} INTERFACE ${ABSL_CC_LIB_DEFINES}) target_compile_definitions(${_NAME} INTERFACE ${ABSL_CC_LIB_DEFINES})
endif() endif()
add_library(absl::${ABSL_CC_LIB_NAME} ALIAS ${_NAME}) add_library(absl::${ABSL_CC_LIB_NAME} ALIAS ${_NAME})
endif() endif()
endfunction() endfunction()
@ -237,6 +250,9 @@ function(absl_cc_test)
# Add all Abseil targets to a a folder in the IDE for organization. # Add all Abseil targets to a a folder in the IDE for organization.
set_property(TARGET ${_NAME} PROPERTY FOLDER ${ABSL_IDE_FOLDER}/test) set_property(TARGET ${_NAME} PROPERTY FOLDER ${ABSL_IDE_FOLDER}/test)
set_property(TARGET ${_NAME} PROPERTY CXX_STANDARD ${ABSL_CXX_STANDARD})
set_property(TARGET ${_NAME} PROPERTY CXX_STANDARD_REQUIRED ON)
add_test(NAME ${_NAME} COMMAND ${_NAME}) add_test(NAME ${_NAME} COMMAND ${_NAME})
endfunction() endfunction()
@ -279,6 +295,9 @@ function(absl_header_library)
# Add all Abseil targets to a a folder in the IDE for organization. # 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})
set_property(TARGET ${_NAME} PROPERTY CXX_STANDARD ${ABSL_CXX_STANDARD})
set_property(TARGET ${_NAME} PROPERTY CXX_STANDARD_REQUIRED ON)
if(ABSL_HO_LIB_EXPORT_NAME) if(ABSL_HO_LIB_EXPORT_NAME)
add_library(absl::${ABSL_HO_LIB_EXPORT_NAME} ALIAS ${_NAME}) add_library(absl::${ABSL_HO_LIB_EXPORT_NAME} ALIAS ${_NAME})
endif() endif()
@ -312,22 +331,29 @@ function(absl_test)
if(ABSL_RUN_TESTS) if(ABSL_RUN_TESTS)
set(_NAME ${ABSL_TEST_TARGET}) set(_NAME "absl_${ABSL_TEST_TARGET}")
string(TOUPPER ${_NAME} _UPPER_NAME) string(TOUPPER ${_NAME} _UPPER_NAME)
add_executable(${_NAME}_bin ${ABSL_TEST_SOURCES}) add_executable(${_NAME} ${ABSL_TEST_SOURCES})
target_compile_options(${_NAME}_bin PRIVATE ${ABSL_TEST_PRIVATE_COMPILE_FLAGS}) target_compile_options(${_NAME}
target_link_libraries(${_NAME}_bin PUBLIC ${ABSL_TEST_PUBLIC_LIBRARIES} ${ABSL_TEST_COMMON_LIBRARIES}) PRIVATE
target_include_directories(${_NAME}_bin ${ABSL_TEST_PRIVATE_COMPILE_FLAGS}
${ABSL_TEST_COPTS}
)
target_link_libraries(${_NAME} PUBLIC ${ABSL_TEST_PUBLIC_LIBRARIES} ${ABSL_TEST_COMMON_LIBRARIES})
target_include_directories(${_NAME}
PUBLIC ${ABSL_COMMON_INCLUDE_DIRS} ${ABSL_TEST_PUBLIC_INCLUDE_DIRS} PUBLIC ${ABSL_COMMON_INCLUDE_DIRS} ${ABSL_TEST_PUBLIC_INCLUDE_DIRS}
PRIVATE ${GMOCK_INCLUDE_DIRS} ${GTEST_INCLUDE_DIRS} PRIVATE ${GMOCK_INCLUDE_DIRS} ${GTEST_INCLUDE_DIRS}
) )
# Add all Abseil targets to a a folder in the IDE for organization. # Add all Abseil targets to a a folder in the IDE for organization.
set_property(TARGET ${_NAME}_bin PROPERTY FOLDER ${ABSL_IDE_FOLDER}) set_property(TARGET ${_NAME} PROPERTY FOLDER ${ABSL_IDE_FOLDER})
add_test(${_NAME} ${_NAME}_bin) set_property(TARGET ${_NAME} PROPERTY CXX_STANDARD ${ABSL_CXX_STANDARD})
set_property(TARGET ${_NAME} PROPERTY CXX_STANDARD_REQUIRED ON)
add_test(NAME ${_NAME} COMMAND ${_NAME})
endif(ABSL_RUN_TESTS) endif(ABSL_RUN_TESTS)
endfunction() endfunction()

2
CMakeLists.txt
View file

@ -19,7 +19,7 @@
cmake_minimum_required(VERSION 3.1) cmake_minimum_required(VERSION 3.1)
project(absl) project(absl)
list(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/CMake) list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR}/CMake)
include(GNUInstallDirs) include(GNUInstallDirs)
include(AbseilHelpers) include(AbseilHelpers)

4
absl/algorithm/CMakeLists.txt
View file

@ -19,6 +19,8 @@ absl_cc_library(
algorithm algorithm
HDRS HDRS
"algorithm.h" "algorithm.h"
COPTS
${ABSL_DEFAULT_COPTS}
PUBLIC PUBLIC
) )
@ -37,6 +39,8 @@ absl_cc_library(
algorithm_container algorithm_container
HDRS HDRS
"container.h" "container.h"
COPTS
${ABSL_DEFAULT_COPTS}
DEPS DEPS
absl::algorithm absl::algorithm
absl::core_headers absl::core_headers

24
absl/base/CMakeLists.txt
View file

@ -36,6 +36,8 @@ absl_cc_library(
HDRS HDRS
"config.h" "config.h"
"policy_checks.h" "policy_checks.h"
COPTS
${ABSL_DEFAULT_COPTS}
PUBLIC PUBLIC
) )
@ -46,6 +48,8 @@ absl_cc_library(
"dynamic_annotations.h" "dynamic_annotations.h"
SRCS SRCS
"dynamic_annotations.cc" "dynamic_annotations.cc"
COPTS
${ABSL_DEFAULT_COPTS}
DEFINES DEFINES
"__CLANG_SUPPORT_DYN_ANNOTATION__" "__CLANG_SUPPORT_DYN_ANNOTATION__"
PUBLIC PUBLIC
@ -60,6 +64,8 @@ absl_cc_library(
"optimization.h" "optimization.h"
"port.h" "port.h"
"thread_annotations.h" "thread_annotations.h"
COPTS
${ABSL_DEFAULT_COPTS}
DEPS DEPS
absl::config absl::config
PUBLIC PUBLIC
@ -73,6 +79,8 @@ absl_cc_library(
"internal/low_level_alloc.h" "internal/low_level_alloc.h"
SRCS SRCS
"internal/low_level_alloc.cc" "internal/low_level_alloc.cc"
COPTS
${ABSL_DEFAULT_COPTS}
DEPS DEPS
absl::base absl::base
absl::config absl::config
@ -89,6 +97,8 @@ absl_cc_library(
"internal/identity.h" "internal/identity.h"
"internal/inline_variable.h" "internal/inline_variable.h"
"internal/invoke.h" "internal/invoke.h"
COPTS
${ABSL_DEFAULT_COPTS}
) )
absl_cc_library( absl_cc_library(
@ -115,6 +125,8 @@ absl_cc_library(
"internal/sysinfo.cc" "internal/sysinfo.cc"
"internal/thread_identity.cc" "internal/thread_identity.cc"
"internal/unscaledcycleclock.cc" "internal/unscaledcycleclock.cc"
COPTS
${ABSL_DEFAULT_COPTS}
DEPS DEPS
absl::base_internal absl::base_internal
absl::config absl::config
@ -132,6 +144,7 @@ absl_cc_library(
SRCS SRCS
"internal/throw_delegate.cc" "internal/throw_delegate.cc"
COPTS COPTS
${ABSL_DEFAULT_COPTS}
${ABSL_EXCEPTIONS_FLAG} ${ABSL_EXCEPTIONS_FLAG}
DEPS DEPS
absl::base absl::base
@ -142,6 +155,8 @@ absl_cc_library(
exception_testing exception_testing
HDRS HDRS
"internal/exception_testing.h" "internal/exception_testing.h"
COPTS
${ABSL_DEFAULT_COPTS}
DEPS DEPS
absl::config absl::config
gtest gtest
@ -153,6 +168,8 @@ absl_cc_library(
pretty_function pretty_function
HDRS HDRS
"internal/pretty_function.h" "internal/pretty_function.h"
COPTS
${ABSL_DEFAULT_COPTS}
) )
absl_cc_library( absl_cc_library(
@ -163,6 +180,7 @@ absl_cc_library(
SRCS SRCS
"internal/exception_safety_testing.cc" "internal/exception_safety_testing.cc"
COPTS COPTS
${ABSL_DEFAULT_COPTS}
${ABSL_EXCEPTIONS_FLAG} ${ABSL_EXCEPTIONS_FLAG}
DEPS DEPS
absl::base absl::base
@ -263,7 +281,7 @@ absl_cc_library(
absl::spinlock_wait absl::spinlock_wait
absl::synchronization absl::synchronization
gtest gtest
PUBLIC TESTONLY
) )
# On bazel BUILD this target use "alwayslink = 1" which is not implemented here # On bazel BUILD this target use "alwayslink = 1" which is not implemented here
@ -286,6 +304,8 @@ absl_cc_library(
HDRS HDRS
"internal/endian.h" "internal/endian.h"
"internal/unaligned_access.h" "internal/unaligned_access.h"
COPTS
${ABSL_DEFAULT_COPTS}
DEPS DEPS
absl::config absl::config
absl::core_headers absl::core_headers
@ -377,6 +397,8 @@ absl_cc_library(
bits bits
HDRS HDRS
"internal/bits.h" "internal/bits.h"
COPTS
${ABSL_DEFAULT_COPTS}
DEPS DEPS
absl::core_headers absl::core_headers
) )

786
absl/container/CMakeLists.txt
View file

@ -14,164 +14,674 @@
# limitations under the License. # limitations under the License.
# #
# This is deprecated and will be removed in the future. It also doesn't do
list(APPEND CONTAINER_PUBLIC_HEADERS # anything anyways. Prefer to use the library associated with the API you are
"fixed_array.h" # using.
"flat_hash_map.h" absl_cc_library(
"flat_hash_set.h" NAME
"inlined_vector.h"
"node_hash_map.h"
"node_hash_set.h"
)
list(APPEND CONTAINER_INTERNAL_HEADERS
"internal/compressed_tuple.h"
"internal/container_memory.h"
"internal/hash_function_defaults.h"
"internal/hash_generator_testing.h"
"internal/hash_policy_testing.h"
"internal/hash_policy_traits.h"
"internal/hashtable_debug.h"
"internal/layout.h"
"internal/node_hash_policy.h"
"internal/raw_hash_map.h"
"internal/raw_hash_set.h"
"internal/test_instance_tracker.h"
"internal/tracked.h"
"internal/unordered_map_constructor_test.h"
"internal/unordered_map_lookup_test.h"
"internal/unordered_map_modifiers_test.h"
"internal/unordered_set_constructor_test.h"
"internal/unordered_set_lookup_test.h"
"internal/unordered_set_modifiers_test.h"
)
absl_library(
TARGET
absl_container
SOURCES
"internal/raw_hash_set.cc"
EXPORT_NAME
container container
SRCS
"internal/raw_hash_set.cc"
COPTS
${ABSL_DEFAULT_COPTS}
PUBLIC
) )
# absl_cc_library(
## TESTS NAME
# compressed_tuple
SRCS
list(APPEND TEST_INSTANCE_TRACKER_LIB_SRC "internal/compressed_tuple.h"
"internal/test_instance_tracker.cc" DEPS
${CONTAINER_PUBLIC_HEADERS} absl::utility
${CONTAINER_INTERNAL_HEADERS} PUBLIC
) )
absl_cc_test(
absl_library( NAME
TARGET compressed_tuple_test
test_instance_tracker_lib SRCS
SOURCES "internal/compressed_tuple_test.cc"
${TEST_INSTANCE_TRACKER_LIB_SRC} DEPS
PUBLIC_LIBRARIES absl::compressed_tuple
absl::container gmock_main
) )
absl_cc_library(
NAME
fixed_array
HDRS
"fixed_array.h"
COPTS
${ABSL_DEFAULT_COPTS}
DEPS
absl::compressed_tuple
absl::algorithm
absl::core_headers
absl::dynamic_annotations
absl::throw_delegate
absl::memory
PUBLIC
)
absl_cc_test(
# test fixed_array_test NAME
set(FIXED_ARRAY_TEST_SRC "fixed_array_test.cc")
set(FIXED_ARRAY_TEST_PUBLIC_LIBRARIES absl::base absl_internal_throw_delegate test_instance_tracker_lib)
absl_test(
TARGET
fixed_array_test fixed_array_test
SOURCES SRCS
${FIXED_ARRAY_TEST_SRC} "fixed_array_test.cc"
PUBLIC_LIBRARIES COPTS
${FIXED_ARRAY_TEST_PUBLIC_LIBRARIES}
PRIVATE_COMPILE_FLAGS
${ABSL_EXCEPTIONS_FLAG} ${ABSL_EXCEPTIONS_FLAG}
LINKOPTS
${ABSL_EXCEPTIONS_FLAG_LINKOPTS}
DEPS
absl::fixed_array
absl::exception_testing
absl::hash_testing
absl::memory
gmock_main
) )
absl_cc_test(
NAME
absl_test(
TARGET
fixed_array_test_noexceptions fixed_array_test_noexceptions
SOURCES SRCS
${FIXED_ARRAY_TEST_SRC} "fixed_array_test.cc"
PUBLIC_LIBRARIES DEPS
${FIXED_ARRAY_TEST_PUBLIC_LIBRARIES} absl::fixed_array
absl::exception_testing
absl::hash_testing
absl::memory
gmock_main
) )
absl_cc_test(
# test fixed_array_exception_safety_test NAME
set(FIXED_ARRAY_EXCEPTION_SAFETY_TEST_SRC "fixed_array_exception_safety_test.cc")
set(FIXED_ARRAY_EXCEPTION_SAFETY_TEST_PUBLIC_LIBRARIES
absl::container
absl_internal_exception_safety_testing
)
absl_test(
TARGET
fixed_array_exception_safety_test fixed_array_exception_safety_test
SOURCES SRCS
${FIXED_ARRAY_EXCEPTION_SAFETY_TEST_SRC} "fixed_array_exception_safety_test.cc"
PUBLIC_LIBRARIES COPTS
${FIXED_ARRAY_EXCEPTION_SAFETY_TEST_PUBLIC_LIBRARIES}
PRIVATE_COMPILE_FLAGS
${ABSL_EXCEPTIONS_FLAG} ${ABSL_EXCEPTIONS_FLAG}
LINKOPTS
${ABSL_EXCEPTIONS_FLAG_LINKOPTS}
DEPS
absl::fixed_array
absl::exception_safety_testing
gmock_main
) )
absl_cc_library(
NAME
inlined_vector
HDRS
"inlined_vector.h"
COPTS
${ABSL_DEFAULT_COPTS}
DEPS
absl::algorithm
absl::core_headers
absl::throw_delegate
absl::memory
PUBLIC
)
# test inlined_vector_test absl_cc_test(
set(INLINED_VECTOR_TEST_SRC "inlined_vector_test.cc") NAME
set(INLINED_VECTOR_TEST_PUBLIC_LIBRARIES absl::base absl_internal_throw_delegate test_instance_tracker_lib)
absl_test(
TARGET
inlined_vector_test inlined_vector_test
SOURCES SRCS
${INLINED_VECTOR_TEST_SRC} "inlined_vector_test.cc"
PUBLIC_LIBRARIES COPTS
${INLINED_VECTOR_TEST_PUBLIC_LIBRARIES} ${ABSL_EXCEPTIONS_FLAG}
) LINKOPTS
${ABSL_EXCEPTIONS_FLAG_LINKOPTS}
absl_test( DEPS
TARGET absl::inlined_vector
inlined_vector_test_noexceptions absl::test_instance_tracker
SOURCES
${INLINED_VECTOR_TEST_SRC}
PUBLIC_LIBRARIES
${INLINED_VECTOR_TEST_PUBLIC_LIBRARIES}
PRIVATE_COMPILE_FLAGS
${ABSL_NOEXCEPTION_CXXFLAGS}
)
# test test_instance_tracker_test
set(TEST_INSTANCE_TRACKER_TEST_SRC "internal/test_instance_tracker_test.cc")
set(TEST_INSTANCE_TRACKER_TEST_PUBLIC_LIBRARIES absl::base absl_internal_throw_delegate test_instance_tracker_lib)
absl_test(
TARGET
test_instance_tracker_test
SOURCES
${TEST_INSTANCE_TRACKER_TEST_SRC}
PUBLIC_LIBRARIES
${TEST_INSTANCE_TRACKER_TEST_PUBLIC_LIBRARIES}
)
absl_test(
TARGET
raw_hash_set_test
SOURCES
"internal/raw_hash_set_test.cc"
PUBLIC_LIBRARIES
absl::base absl::base
absl::hash absl::core_headers
absl_internal_throw_delegate absl::exception_testing
test_instance_tracker_lib absl::hash_testing
absl::memory
absl::strings
gmock_main
)
absl_cc_test(
NAME
inlined_vector_test_noexceptions
SRCS
"inlined_vector_test.cc"
DEPS
absl::inlined_vector
absl::test_instance_tracker
absl::base
absl::core_headers
absl::exception_testing
absl::hash_testing
absl::memory
absl::strings
gmock_main
)
absl_cc_library(
NAME
test_instance_tracker
HDRS
"internal/test_instance_tracker.h"
SRCS
"internal/test_instance_tracker.cc"
COPTS
${ABSL_DEFAULT_COPTS}
TESTONLY
)
absl_cc_test(
NAME
test_instance_tracker_test
SRCS
"internal/test_instance_tracker_test.cc"
DEPS
absl::test_instance_tracker
gmock_main
)
absl_cc_library(
NAME
flat_hash_map
HDRS
"flat_hash_map.h"
COPTS
${ABSL_DEFAULT_COPTS}
DEPS
absl::container_memory
absl::hash_function_defaults
absl::raw_hash_map
absl::algorithm_container
absl::memory
PUBLIC
)
absl_cc_test(
NAME
flat_hash_map_test
SRCS
"flat_hash_map_test.cc"
COPTS
"-DUNORDERED_MAP_CXX17"
DEPS
absl::flat_hash_map
absl::hash_generator_testing
absl::unordered_map_constructor_test
absl::unordered_map_lookup_test
absl::unordered_map_modifiers_test
absl::any
gmock_main
)
absl_cc_library(
NAME
flat_hash_set
HDRS
"flat_hash_set.h"
COPTS
${ABSL_DEFAULT_COPTS}
DEPS
absl::container_memory
absl::hash_function_defaults
absl::raw_hash_set
absl::algorithm_container
absl::core_headers
absl::memory
PUBLIC
)
absl_cc_test(
NAME
flat_hash_set_test
SRCS
"flat_hash_set_test.cc"
COPTS
"-DUNORDERED_SET_CXX17"
DEPS
absl::flat_hash_set
absl::hash_generator_testing
absl::unordered_set_constructor_test
absl::unordered_set_lookup_test
absl::unordered_set_modifiers_test
absl::memory
absl::strings
gmock_main
)
absl_cc_library(
NAME
node_hash_map
HDRS
"node_hash_map.h"
COPTS
${ABSL_DEFAULT_COPTS}
DEPS
absl::container_memory
absl::hash_function_defaults
absl::node_hash_policy
absl::raw_hash_map
absl::algorithm_container
absl::memory
PUBLIC
)
absl_cc_test(
NAME
node_hash_map_test
SRCS
"node_hash_map_test.cc"
COPTS
"-DUNORDERED_MAP_CXX17"
DEPS
absl::hash_generator_testing
absl::node_hash_map
absl::tracked
absl::unordered_map_constructor_test
absl::unordered_map_lookup_test
absl::unordered_map_modifiers_test
gmock_main
)
absl_cc_library(
NAME
node_hash_set
HDRS
"node_hash_set.h"
COPTS
${ABSL_DEFAULT_COPTS}
DEPS
absl::hash_function_defaults
absl::node_hash_policy
absl::raw_hash_set
absl::algorithm_container
absl::memory
PUBLIC
)
absl_cc_test(
NAME
node_hash_set_test
SRCS
"node_hash_set_test.cc"
COPTS
"-DUNORDERED_SET_CXX17"
DEPS
absl::hash_generator_testing
absl::node_hash_set
absl::unordered_set_constructor_test
absl::unordered_set_lookup_test
absl::unordered_set_modifiers_test
gmock_main
)
absl_cc_library(
NAME
container_memory
HDRS
"internal/container_memory.h"
COPTS
${ABSL_DEFAULT_COPTS}
DEPS
absl::memory
absl::utility
PUBLIC
)
absl_cc_test(
NAME
container_memory_test
SRCS
"internal/container_memory_test.cc"
DEPS
absl::container_memory
absl::strings
gmock_main
)
absl_cc_library(
NAME
hash_function_defaults
HDRS
"internal/hash_function_defaults.h"
COPTS
${ABSL_DEFAULT_COPTS}
DEPS
absl::config
absl::hash
absl::strings
PUBLIC
)
absl_cc_test(
NAME
hash_function_defaults_test
SRCS
"internal/hash_function_defaults_test.cc"
DEPS
absl::hash_function_defaults
absl::hash
absl::strings
gmock_main
)
absl_cc_library(
NAME
hash_generator_testing
HDRS
"internal/hash_generator_testing.h"
SRCS
"internal/hash_generator_testing.cc"
COPTS
${ABSL_TEST_COPTS}
DEPS
absl::hash_policy_testing
absl::meta
absl::strings
TESTONLY
)
absl_cc_library(
NAME
hash_policy_testing
HDRS
"internal/hash_policy_testing.h"
COPTS
${ABSL_TEST_COPTS}
DEPS
absl::hash
absl::strings
TESTONLY
)
absl_cc_test(
NAME
hash_policy_testing_test
SRCS
"internal/hash_policy_testing_test.cc"
DEPS
absl::hash_policy_testing
gmock_main
)
absl_cc_library(
NAME
hash_policy_traits
HDRS
"internal/hash_policy_traits.h"
COPTS
${ABSL_DEFAULT_COPTS}
DEPS
absl::meta
PUBLIC
)
absl_cc_test(
NAME
hash_policy_traits_test
SRCS
"internal/hash_policy_traits_test.cc"
DEPS
absl::hash_policy_traits
gmock_main
)
absl_cc_library(
NAME
hashtable_debug
HDRS
"internal/hashtable_debug.h"
COPTS
${ABSL_DEFAULT_COPTS}
DEPS
absl::hashtable_debug_hooks
)
absl_cc_library(
NAME
hashtable_debug_hooks
HDRS
"internal/hashtable_debug_hooks.h"
COPTS
${ABSL_DEFAULT_COPTS}
PUBLIC
)
absl_cc_library(
NAME
node_hash_policy
HDRS
"internal/node_hash_policy.h"
COPTS
${ABSL_DEFAULT_COPTS}
PUBLIC
)
absl_cc_test(
NAME
node_hash_policy_test
SRCS
"internal/node_hash_policy_test.cc"
DEPS
absl::hash_policy_traits
absl::node_hash_policy
gmock_main
)
absl_cc_library(
NAME
raw_hash_map
HDRS
"internal/raw_hash_map.h"
COPTS
${ABSL_DEFAULT_COPTS}
DEPS
absl::container_memory
absl::raw_hash_set
PUBLIC
)
absl_cc_library(
NAME
raw_hash_set
HDRS
"internal/raw_hash_set.h"
SRCS
"internal/raw_hash_set.cc"
COPTS
${ABSL_DEFAULT_COPTS}
DEPS
absl::compressed_tuple
absl::container_memory
absl::hash_policy_traits
absl::hashtable_debug_hooks
absl::layout
absl::bits
absl::config
absl::core_headers
absl::endian
absl::memory
absl::meta
absl::optional
absl::utility
PUBLIC
)
absl_cc_test(
NAME
raw_hash_set_test
SRCS
"internal/raw_hash_set_test.cc"
DEPS
absl::container_memory
absl::hash_function_defaults
absl::hash_policy_testing
absl::hashtable_debug
absl::raw_hash_set
absl::base
absl::core_headers
absl::strings
gmock_main
)
absl_cc_test(
NAME
raw_hash_set_allocator_test
SRCS
"internal/raw_hash_set_allocator_test.cc"
DEPS
absl::raw_hash_set
absl::tracked
absl::core_headers
gmock_main
)
absl_cc_library(
NAME
layout
HDRS
"internal/layout.h"
COPTS
${ABSL_DEFAULT_COPTS}
DEPS
absl::core_headers
absl::meta
absl::strings
absl::span
absl::utility
PUBLIC
)
absl_cc_test(
NAME
layout_test
SRCS
"internal/layout_test.cc"
DEPS
absl::layout
absl::base
absl::core_headers
absl::span
gmock_main
)
absl_cc_library(
NAME
tracked
HDRS
"internal/tracked.h"
COPTS
${ABSL_TEST_COPTS}
TESTONLY
)
absl_cc_library(
NAME
unordered_map_constructor_test
HDRS
"internal/unordered_map_constructor_test.h"
COPTS
${ABSL_TEST_COPTS}
DEPS
absl::hash_generator_testing
absl::hash_policy_testing
gmock
TESTONLY
)
absl_cc_library(
NAME
unordered_map_lookup_test
HDRS
"internal/unordered_map_lookup_test.h"
COPTS
${ABSL_TEST_COPTS}
DEPS
absl::hash_generator_testing
absl::hash_policy_testing
gmock
TESTONLY
)
absl_cc_library(
NAME
unordered_map_modifiers_test
HDRS
"internal/unordered_map_modifiers_test.h"
COPTS
${ABSL_TEST_COPTS}
DEPS
absl::hash_generator_testing
absl::hash_policy_testing
gmock
TESTONLY
)
absl_cc_library(
NAME
unordered_set_constructor_test
HDRS
"internal/unordered_set_constructor_test.h"
COPTS
${ABSL_TEST_COPTS}
DEPS
absl::hash_generator_testing
absl::hash_policy_testing
gmock
TESTONLY
)
absl_cc_library(
NAME
unordered_set_lookup_test
HDRS
"internal/unordered_set_lookup_test.h"
COPTS
${ABSL_TEST_COPTS}
DEPS
absl::hash_generator_testing
absl::hash_policy_testing
gmock
TESTONLY
)
absl_cc_library(
NAME
unordered_set_modifiers_test
HDRS
"internal/unordered_set_modifiers_test.h"
COPTS
${ABSL_TEST_COPTS}
DEPS
absl::hash_generator_testing
absl::hash_policy_testing
gmock
TESTONLY
)
absl_cc_test(
NAME
unordered_set_test
SRCS
"internal/unordered_set_test.cc"
DEPS
absl::unordered_set_constructor_test
absl::unordered_set_lookup_test
absl::unordered_set_modifiers_test
gmock_main
)
absl_cc_test(
NAME
unordered_map_test
SRCS
"internal/unordered_map_test.cc"
DEPS
absl::unordered_map_constructor_test
absl::unordered_map_lookup_test
absl::unordered_map_modifiers_test
gmock_main
) )

6
absl/container/internal/hash_policy_testing.h
View file

@ -169,7 +169,11 @@ auto keys(const Set& s)
// take allocator arguments. This test is defined ad-hoc for the platforms // take allocator arguments. This test is defined ad-hoc for the platforms
// we care about (notably Crosstool 17) because libstdcxx's useless // we care about (notably Crosstool 17) because libstdcxx's useless
// versioning scheme precludes a more principled solution. // versioning scheme precludes a more principled solution.
#if defined(__GLIBCXX__) && __GLIBCXX__ <= 20140425 // From GCC-4.9 Changelog: (src: https://gcc.gnu.org/gcc-4.9/changes.html)
// "the unordered associative containers in <unordered_map> and <unordered_set>
// meet the allocator-aware container requirements;"
#if (defined(__GLIBCXX__) && __GLIBCXX__ <= 20140425 ) || \
( __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 9 ))
#define ABSL_UNORDERED_SUPPORTS_ALLOC_CTORS 0 #define ABSL_UNORDERED_SUPPORTS_ALLOC_CTORS 0
#else #else
#define ABSL_UNORDERED_SUPPORTS_ALLOC_CTORS 1 #define ABSL_UNORDERED_SUPPORTS_ALLOC_CTORS 1

18
absl/container/internal/layout.h
View file

@ -232,13 +232,17 @@ struct SizeOf : NotAligned<T>, std::integral_constant<size_t, sizeof(T)> {};
template <class T, size_t N> template <class T, size_t N>
struct SizeOf<Aligned<T, N>> : std::integral_constant<size_t, sizeof(T)> {}; struct SizeOf<Aligned<T, N>> : std::integral_constant<size_t, sizeof(T)> {};
// Note: workaround for https://gcc.gnu.org/PR88115
template <class T> template <class T>
struct AlignOf : NotAligned<T>, std::integral_constant<size_t, alignof(T)> {}; struct AlignOf : NotAligned<T> {
static constexpr size_t value = alignof(T);
};
template <class T, size_t N> template <class T, size_t N>
struct AlignOf<Aligned<T, N>> : std::integral_constant<size_t, N> { struct AlignOf<Aligned<T, N>> {
static_assert(N % alignof(T) == 0, static_assert(N % alignof(T) == 0,
"Custom alignment can't be lower than the type's alignment"); "Custom alignment can't be lower than the type's alignment");
static constexpr size_t value = N;
}; };
// Does `Ts...` contain `T`? // Does `Ts...` contain `T`?
@ -290,7 +294,7 @@ std::string TypeName() {
#ifdef ABSL_INTERNAL_HAS_CXA_DEMANGLE #ifdef ABSL_INTERNAL_HAS_CXA_DEMANGLE
demangled = abi::__cxa_demangle(typeid(T).name(), nullptr, nullptr, &status); demangled = abi::__cxa_demangle(typeid(T).name(), nullptr, nullptr, &status);
#endif #endif
if (status == 0 && demangled != nullptr) { // Demangling succeeeded. if (status == 0 && demangled != nullptr) { // Demangling succeeded.
absl::StrAppend(&out, "<", demangled, ">"); absl::StrAppend(&out, "<", demangled, ">");
free(demangled); free(demangled);
} else { } else {
@ -396,7 +400,7 @@ class LayoutImpl<std::tuple<Elements...>, absl::index_sequence<SizeSeq...>,
static_assert(N < NumOffsets, "Index out of bounds"); static_assert(N < NumOffsets, "Index out of bounds");
return adl_barrier::Align( return adl_barrier::Align(
Offset<N - 1>() + SizeOf<ElementType<N - 1>>() * size_[N - 1], Offset<N - 1>() + SizeOf<ElementType<N - 1>>() * size_[N - 1],
ElementAlignment<N>()); ElementAlignment<N>::value);
} }
// Offset in bytes of the array with the specified element type. There must // Offset in bytes of the array with the specified element type. There must
@ -445,7 +449,7 @@ class LayoutImpl<std::tuple<Elements...>, absl::index_sequence<SizeSeq...>,
return Size<ElementIndex<T>()>(); return Size<ElementIndex<T>()>();
} }
// The number of elements of all arrays for which they are known. // The number of elements of all arrays for which they are known.
constexpr std::array<size_t, NumSizes> Sizes() const { constexpr std::array<size_t, NumSizes> Sizes() const {
return {{Size<SizeSeq>()...}}; return {{Size<SizeSeq>()...}};
} }
@ -610,7 +614,7 @@ class LayoutImpl<std::tuple<Elements...>, absl::index_sequence<SizeSeq...>,
#ifdef ADDRESS_SANITIZER #ifdef ADDRESS_SANITIZER
PoisonPadding<Char, N - 1>(p); PoisonPadding<Char, N - 1>(p);
// The `if` is an optimization. It doesn't affect the observable behaviour. // The `if` is an optimization. It doesn't affect the observable behaviour.
if (ElementAlignment<N - 1>() % ElementAlignment<N>()) { if (ElementAlignment<N - 1>::value % ElementAlignment<N>::value) {
size_t start = size_t start =
Offset<N - 1>() + SizeOf<ElementType<N - 1>>() * size_[N - 1]; Offset<N - 1>() + SizeOf<ElementType<N - 1>>() * size_[N - 1];
ASAN_POISON_MEMORY_REGION(p + start, Offset<N>() - start); ASAN_POISON_MEMORY_REGION(p + start, Offset<N>() - start);
@ -690,7 +694,7 @@ class Layout : public internal_layout::LayoutType<sizeof...(Ts), Ts...> {
// //
// It's allowed to pass fewer array sizes than the number of arrays. E.g., // It's allowed to pass fewer array sizes than the number of arrays. E.g.,
// if all you need is to the offset of the second array, you only need to // if all you need is to the offset of the second array, you only need to
// pass one argument -- the number of elements in the first arrays. // pass one argument -- the number of elements in the first array.
// //
// // int[3] followed by 4 bytes of padding and an unknown number of // // int[3] followed by 4 bytes of padding and an unknown number of
// // doubles. // // doubles.

33
absl/container/internal/layout_test.cc
View file

@ -45,7 +45,17 @@ Expected Type(Actual val) {
return val; return val;
} }
using Int128 = int64_t[2]; // Helper class to test different size and alignments.
struct alignas(8) Int128 {
uint64_t a, b;
friend bool operator==(Int128 lhs, Int128 rhs) {
return std::tie(lhs.a, lhs.b) == std::tie(rhs.a, rhs.b);
}
static std::string Name() {
return internal_layout::adl_barrier::TypeName<Int128>();
}
};
// Properties of types that this test relies on. // Properties of types that this test relies on.
static_assert(sizeof(int8_t) == 1, ""); static_assert(sizeof(int8_t) == 1, "");
@ -1361,12 +1371,6 @@ TEST(Layout, PoisonPadding) {
} }
TEST(Layout, DebugString) { TEST(Layout, DebugString) {
const std::string int64_type =
#ifdef _MSC_VER
"__int64";
#else // _MSC_VER
std::is_same<int64_t, long long>::value ? "long long" : "long"; // NOLINT
#endif // _MSC_VER
{ {
constexpr auto x = Layout<int8_t, int32_t, int8_t, Int128>::Partial(); constexpr auto x = Layout<int8_t, int32_t, int8_t, Int128>::Partial();
EXPECT_EQ("@0<signed char>(1)", x.DebugString()); EXPECT_EQ("@0<signed char>(1)", x.DebugString());
@ -1384,24 +1388,24 @@ TEST(Layout, DebugString) {
constexpr auto x = Layout<int8_t, int32_t, int8_t, Int128>::Partial(1, 2, 3); constexpr auto x = Layout<int8_t, int32_t, int8_t, Int128>::Partial(1, 2, 3);
EXPECT_EQ( EXPECT_EQ(
"@0<signed char>(1)[1]; @4<int>(4)[2]; @12<signed char>(1)[3]; " "@0<signed char>(1)[1]; @4<int>(4)[2]; @12<signed char>(1)[3]; "
"@16<" + "@16" +
int64_type + " [2]>(16)", Int128::Name() + "(16)",
x.DebugString()); x.DebugString());
} }
{ {
constexpr auto x = Layout<int8_t, int32_t, int8_t, Int128>::Partial(1, 2, 3, 4); constexpr auto x = Layout<int8_t, int32_t, int8_t, Int128>::Partial(1, 2, 3, 4);
EXPECT_EQ( EXPECT_EQ(
"@0<signed char>(1)[1]; @4<int>(4)[2]; @12<signed char>(1)[3]; " "@0<signed char>(1)[1]; @4<int>(4)[2]; @12<signed char>(1)[3]; "
"@16<" + "@16" +
int64_type + " [2]>(16)[4]", Int128::Name() + "(16)[4]",
x.DebugString()); x.DebugString());
} }
{ {
constexpr Layout<int8_t, int32_t, int8_t, Int128> x(1, 2, 3, 4); constexpr Layout<int8_t, int32_t, int8_t, Int128> x(1, 2, 3, 4);
EXPECT_EQ( EXPECT_EQ(
"@0<signed char>(1)[1]; @4<int>(4)[2]; @12<signed char>(1)[3]; " "@0<signed char>(1)[1]; @4<int>(4)[2]; @12<signed char>(1)[3]; "
"@16<" + "@16" +
int64_type + " [2]>(16)[4]", Int128::Name() + "(16)[4]",
x.DebugString()); x.DebugString());
} }
} }
@ -1528,8 +1532,7 @@ class CompactString {
const char* c_str() const { const char* c_str() const {
// Equivalent to reinterpret_cast<char*>(p.get() + sizeof(size_t)). // Equivalent to reinterpret_cast<char*>(p.get() + sizeof(size_t)).
// The argument in Partial(1) specifies that we have size_t[1] in front of // The argument in Partial(1) specifies that we have size_t[1] in front of
// the // the characters.
// characters.
return L::Partial(1).Pointer<char>(p_.get()); return L::Partial(1).Pointer<char>(p_.get());
} }

2
absl/copts.bzl
View file

@ -3,6 +3,8 @@
Flags specified here must not impact ABI. Code compiled with and without these Flags specified here must not impact ABI. Code compiled with and without these
opts will be linked together, and in some cases headers compiled with and opts will be linked together, and in some cases headers compiled with and
without these options will be part of the same program. without these options will be part of the same program.
DO NOT CHANGE THIS FILE WITHOUT CHANGING THE SAME FLAG IN absl/CMake/AbseilConfigureCopts.cmake!!
""" """
GCC_FLAGS = [ GCC_FLAGS = [
"-Wall", "-Wall",

30
absl/hash/CMakeLists.txt
View file

@ -31,7 +31,7 @@ list(APPEND HASH_SRC
${HASH_INTERNAL_HEADERS} ${HASH_INTERNAL_HEADERS}
) )
set(HASH_PUBLIC_LIBRARIES absl::hash absl::container absl::strings absl::str_format absl::utility) set(HASH_PUBLIC_LIBRARIES absl::hash absl::fixed_array absl::strings absl::str_format absl::utility)
absl_library( absl_library(
TARGET TARGET
@ -48,9 +48,35 @@ absl_library(
## TESTS ## TESTS
# #
absl_cc_library(
NAME
hash_testing
HDRS
"hash_testing.h"
DEPS
absl::spy_hash_state
absl::meta
absl::strings
absl::variant
gmock
TESTONLY
)
absl_cc_library(
NAME
spy_hash_state
HDRS
"internal/spy_hash_state.h"
DEPS
absl::hash
absl::strings
absl::str_format
TESTONLY
)
# testing support # testing support
set(HASH_TEST_HEADERS hash_testing.h internal/spy_hash_state.h) set(HASH_TEST_HEADERS hash_testing.h internal/spy_hash_state.h)
set(HASH_TEST_PUBLIC_LIBRARIES absl::hash absl::container absl::numeric absl::strings absl::str_format) set(HASH_TEST_PUBLIC_LIBRARIES absl::hash absl::flat_hash_set absl::numeric absl::strings absl::str_format)
# hash_test # hash_test
set(HASH_TEST_SRC "hash_test.cc" ${HASH_TEST_HEADERS}) set(HASH_TEST_SRC "hash_test.cc" ${HASH_TEST_HEADERS})

2
absl/strings/CMakeLists.txt
View file

@ -113,7 +113,7 @@ absl_library(
absl::strings absl::strings
absl::base absl::base
absl::numeric absl::numeric
absl::container absl::inlined_vector
absl::span absl::span
) )

1
absl/time/BUILD.bazel
View file

@ -110,6 +110,7 @@ cc_test(
":test_util", ":test_util",
":time", ":time",
"//absl/base", "//absl/base",
"//absl/hash",
"@com_github_google_benchmark//:benchmark_main", "@com_github_google_benchmark//:benchmark_main",
], ],
) )

64
absl/time/civil_time_benchmark.cc
View file

@ -14,17 +14,29 @@
#include "absl/time/civil_time.h" #include "absl/time/civil_time.h"
#include <numeric>
#include <vector>
#include "absl/hash/hash.h"
#include "benchmark/benchmark.h" #include "benchmark/benchmark.h"
namespace { namespace {
// Benchmark Time(ns) CPU(ns) Iterations // Run on (12 X 3492 MHz CPUs); 2018-11-05T13:44:29.814239103-08:00
// ------------------------------------------------------------------------- // CPU: Intel Haswell with HyperThreading (6 cores) dL1:32KB dL2:256KB dL3:15MB
// BM_Difference_Days 20 20 34542508 // Benchmark Time(ns) CPU(ns) Iterations
// BM_Step_Days 15 15 48098146 // ----------------------------------------------------------------
// BM_Format 688 687 1019803 // BM_Difference_Days 14.5 14.5 48531105
// BM_Parse 921 920 762788 // BM_Step_Days 12.6 12.6 54876006
// BM_RoundTripFormatParse 1766 1764 396092 // BM_Format 587 587 1000000
// BM_Parse 692 692 1000000
// BM_RoundTripFormatParse 1309 1309 532075
// BM_CivilYearAbslHash 0.710 0.710 976400000
// BM_CivilMonthAbslHash 1.13 1.13 619500000
// BM_CivilDayAbslHash 1.70 1.70 426000000
// BM_CivilHourAbslHash 2.45 2.45 287600000
// BM_CivilMinuteAbslHash 3.21 3.21 226200000
// BM_CivilSecondAbslHash 4.10 4.10 171800000
void BM_Difference_Days(benchmark::State& state) { void BM_Difference_Days(benchmark::State& state) {
const absl::CivilDay c(2014, 8, 22); const absl::CivilDay c(2014, 8, 22);
@ -54,4 +66,42 @@ void BM_Format(benchmark::State& state) {
} }
BENCHMARK(BM_Format); BENCHMARK(BM_Format);
template <typename T>
void BM_CivilTimeAbslHash(benchmark::State& state) {
const int kSize = 100000;
std::vector<T> civil_times(kSize);
std::iota(civil_times.begin(), civil_times.end(), T(2018));
absl::Hash<T> absl_hasher;
while (state.KeepRunningBatch(kSize)) {
for (const T civil_time : civil_times) {
benchmark::DoNotOptimize(absl_hasher(civil_time));
}
}
}
void BM_CivilYearAbslHash(benchmark::State& state) {
BM_CivilTimeAbslHash<absl::CivilYear>(state);
}
void BM_CivilMonthAbslHash(benchmark::State& state) {
BM_CivilTimeAbslHash<absl::CivilMonth>(state);
}
void BM_CivilDayAbslHash(benchmark::State& state) {
BM_CivilTimeAbslHash<absl::CivilDay>(state);
}
void BM_CivilHourAbslHash(benchmark::State& state) {
BM_CivilTimeAbslHash<absl::CivilHour>(state);
}
void BM_CivilMinuteAbslHash(benchmark::State& state) {
BM_CivilTimeAbslHash<absl::CivilMinute>(state);
}
void BM_CivilSecondAbslHash(benchmark::State& state) {
BM_CivilTimeAbslHash<absl::CivilSecond>(state);
}
BENCHMARK(BM_CivilYearAbslHash);
BENCHMARK(BM_CivilMonthAbslHash);
BENCHMARK(BM_CivilDayAbslHash);
BENCHMARK(BM_CivilHourAbslHash);
BENCHMARK(BM_CivilMinuteAbslHash);
BENCHMARK(BM_CivilSecondAbslHash);
} // namespace } // namespace

2
absl/time/internal/cctz/BUILD.bazel
View file

@ -12,6 +12,8 @@
# See the License for the specific language governing permissions and # See the License for the specific language governing permissions and
# limitations under the License. # limitations under the License.
package(features = ["-parse_headers"])
licenses(["notice"]) # Apache License licenses(["notice"]) # Apache License
### libraries ### libraries

3
absl/time/time.h
View file

@ -1336,9 +1336,12 @@ constexpr Duration MakeNormalizedDuration(int64_t sec, int64_t ticks) {
return (ticks < 0) ? MakeDuration(sec - 1, ticks + kTicksPerSecond) return (ticks < 0) ? MakeDuration(sec - 1, ticks + kTicksPerSecond)
: MakeDuration(sec, ticks); : MakeDuration(sec, ticks);
} }
// Provide access to the Duration representation. // Provide access to the Duration representation.
constexpr int64_t GetRepHi(Duration d) { return d.rep_hi_; } constexpr int64_t GetRepHi(Duration d) { return d.rep_hi_; }
constexpr uint32_t GetRepLo(Duration d) { return d.rep_lo_; } constexpr uint32_t GetRepLo(Duration d) { return d.rep_lo_; }
// Returns true iff d is positive or negative infinity.
constexpr bool IsInfiniteDuration(Duration d) { return GetRepLo(d) == ~0U; } constexpr bool IsInfiniteDuration(Duration d) { return GetRepLo(d) == ~0U; }
// Returns an infinite Duration with the opposite sign. // Returns an infinite Duration with the opposite sign.

4
absl/types/CMakeLists.txt
View file

@ -123,7 +123,7 @@ absl_library(
# test any_test # test any_test
set(ANY_TEST_SRC "any_test.cc") set(ANY_TEST_SRC "any_test.cc")
set(ANY_TEST_PUBLIC_LIBRARIES absl::base absl_internal_throw_delegate absl::any absl::bad_any_cast test_instance_tracker_lib) set(ANY_TEST_PUBLIC_LIBRARIES absl::base absl_internal_throw_delegate absl::any absl::bad_any_cast absl::test_instance_tracker)
absl_test( absl_test(
TARGET TARGET
@ -169,7 +169,7 @@ absl_test(
# test span_test # test span_test
set(SPAN_TEST_SRC "span_test.cc") set(SPAN_TEST_SRC "span_test.cc")
set(SPAN_TEST_PUBLIC_LIBRARIES absl::base absl::strings absl_internal_throw_delegate absl::span test_instance_tracker_lib) set(SPAN_TEST_PUBLIC_LIBRARIES absl::base absl::strings absl_internal_throw_delegate absl::span absl::test_instance_tracker)
absl_test( absl_test(
TARGET TARGET

7
absl/types/variant.h
View file

@ -399,9 +399,9 @@ constexpr absl::add_pointer_t<const T> get_if(
// Calls a provided functor on a given set of variants. `absl::visit()` is // Calls a provided functor on a given set of variants. `absl::visit()` is
// commonly used to conditionally inspect the state of a given variant (or set // commonly used to conditionally inspect the state of a given variant (or set
// of variants). // of variants).
// Requires: The expression in the Effects: element shall be a valid expression //
// of the same type and value category, for all combinations of alternative // The functor must return the same type when called with any of the variants'
// types of all variants. Otherwise, the program is ill-formed. // alternatives.
// //
// Example: // Example:
// //
@ -414,6 +414,7 @@ constexpr absl::add_pointer_t<const T> get_if(
// }; // };
// //
// // Declare our variant, and call `absl::visit()` on it. // // Declare our variant, and call `absl::visit()` on it.
// // Note that `GetVariant()` returns void in either case.
// absl::variant<int, std::string> foo = std::string("foo"); // absl::variant<int, std::string> foo = std::string("foo");
// GetVariant visitor; // GetVariant visitor;
// absl::visit(visitor, foo); // Prints `The variant's value is: foo' // absl::visit(visitor, foo); // Prints `The variant's value is: foo'