Skip to content

A
abseil-cpp
Switch branch/tag
  1. 12 Mar, 2024 1 commit
  3. 11 Mar, 2024 3 commits
  5. 07 Mar, 2024 2 commits
  7. 06 Mar, 2024 4 commits
  9. 04 Mar, 2024 3 commits
  11. 03 Mar, 2024 1 commit
  13. 29 Feb, 2024 2 commits
  15. 28 Feb, 2024 4 commits
  17. 27 Feb, 2024 4 commits
    • Make DLOG(FATAL) not understood as [[noreturn]] · c0bec1a7 
      Having DLOG(FATAL) be [[noreturn]] in debug builds makes dead-code
warnings impossible to satisfy between the release and debug build.

PiperOrigin-RevId: 610851706
Change-Id: I07104d6687e2b1a8472ee3ea876d5fd74a70574e
      Abseil Team committed
    • Optimize `absl::Duration` division and modulo: Avoid repeated redundant… · 9bbbbd3b 
      Optimize `absl::Duration` division and modulo: Avoid repeated redundant comparisons in `IDivFastPath`.

PiperOrigin-RevId: 610758911
Change-Id: I3d0fa2f52a3bd75bdd2b5c365d79878b4160bd29
      Abseil Team committed
    • Optimize `absl::Duration` division and modulo: Allow the compiler to inline… · bde089f9 
      Optimize `absl::Duration` division and modulo: Allow the compiler to inline `time_internal::IDivDuration`, by splitting the slow path to a separate function.

With that change, the compiler can inline the fast path. This is specially important in the context of `Duration::operator%=`, because it allows proving that the return value is unused, therefore avoiding expensive multiplies and divides (e.g. `*q = num_hi / den_hi;`).

```
name                         old cpu/op   new cpu/op   delta
BM_Duration_Modulo           23.1ns ± 0%  22.5ns ± 0%   -2.42%  (p=0.000 n=20+16)
BM_Duration_Modulo_FastPath  7.05ns ± 0%  4.85ns ± 0%  -31.17%  (p=0.000 n=20+20)

name                         old time/op          new time/op          delta
BM_Duration_Modulo           23.1ns ± 0%          22.6ns ± 0%   -2.43%  (p=0.000 n=20+16)
BM_Duration_Modulo_FastPath  7.06ns ± 0%          4.86ns ± 0%  -31.18%  (p=0.000 n=20+20)

name                         old INSTRUCTIONS/op  new INSTRUCTIONS/op  delta
BM_Duration_Modulo              188 ± 0%             178 ± 0%   -5.32%  (p=0.000 n=20+20)
BM_Duration_Modulo_FastPath    84.0 ± 0%            62.0 ± 0%  -26.19%  (p=0.000 n=20+20)

name                         old CYCLES/op        new CYCLES/op        delta
BM_Duration_Modulo             73.8 ± 0%            72.1 ± 0%   -2.27%  (p=0.000 n=19+20)
BM_Duration_Modulo_FastPath    22.5 ± 0%            15.5 ± 0%  -31.13%  (p=0.000 n=19+20)
```

Note: We don't need to expose `absl::time_internal::IDivDuration` at all given that we have a public `absl::IDivDuration`.
PiperOrigin-RevId: 610710635
Change-Id: Ief7c3d5b1c000b397d931e9249edcaef96e7151e
      Abseil Team committed
    • Fix typo in example code snippet. · 90ebb6fc 
      PiperOrigin-RevId: 610672905
Change-Id: I8e4ae98bb6e6421540a3073e3e6cb7de60fd32a9
      Abseil Team committed
  19. 26 Feb, 2024 1 commit
  21. 23 Feb, 2024 2 commits
  23. 22 Feb, 2024 2 commits
  25. 21 Feb, 2024 4 commits
  27. 20 Feb, 2024 5 commits
  29. 17 Feb, 2024 1 commit
    • PR #1625: absl::is_trivially_relocatable now respects assignment operators · 14b8a4ea 
      Imported from GitHub PR https://github.com/abseil/abseil-cpp/pull/1625

Trivial relocatability also requires that the type not do anything weird with its assignment operator; update the type-trait to reflect this. (This is the definition used by BSL, Folly, HPX, Thrust, Parlay, Amadeus, and P1144.)

This is important if we want to use `absl::is_trivially_relocatable` as a gate for memcpy optimizations in `inlined_vector::erase` and/or `inlined_vector::swap`, because in those cases relocation is used to replace part of a sequence involving assignment; the optimization requires an assignment operator that behaves value-semantically.

Clang's builtin currently fails to check the assignment operator, so we stop using it entirely for now. We already refused to use it on Win32, Win64, and Apple, for various unrelated reasons. I'm working on giving Clang's builtin the behavior that would let us re-enable it here.

Assume that any compiler providing both `__cpp_impl_trivially_relocatable` and a builtin `__is_trivially_relocatable(T)` will use the appropriate (P1144) definition for its builtin. Right now there's only one such compiler (the P1144 reference implementation, which forks Clang), so this is largely a moot point, but I'm being optimistic.
Merge d943abdbabc1b7080aa5f0a2fff3e724135164dc into 34604d5b

Merging this change closes #1625

COPYBARA_INTEGRATE_REVIEW=https://github.com/abseil/abseil-cpp/pull/1625 from Quuxplusone:trivially-relocatable d943abdbabc1b7080aa5f0a2fff3e724135164dc
PiperOrigin-RevId: 607977323
Change-Id: I6436a60326c6d1064bdd71ec2e15b86b7a29efd4
      Arthur O'Dwyer committed
  31. 16 Feb, 2024 1 commit
    • Introduce `Group::MaskNonFull` without usage. · 8a3caf7d 
      It can be used instead of `MaskEmptyOrDeleted` in case of inserting to empty table.
`MaskNonFull` requires less operations, in particular it eliminates `_mm_set1_epi8` and `_mm_cmpgt_epi8` operations.

PiperOrigin-RevId: 607587394
Change-Id: Ia48f922d1ca6de38cc91e7ab0d608c45f8f2c446
      Abseil Team committed