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

Changes imported from Abseil "staging" branch:

Browse source 
- 43853019b439efb32c79d5d50e24508588e1bbe0 Undo the not applying qualifications to absl types in enc... by Derek Mauro <dmauro@google.com>
  - 06d62a10621c9864279ee57097069cfe3cb7b42a fix capitalization by Abseil Team <absl-team@google.com>
  - 22adbfee340bb452ba38b68975ade6f072859c4a Fix indices in str_split.h comments. by Derek Mauro <dmauro@google.com>
  - ae5143a559ad8633a78cd76620e30a781006d088 Fix the inconsistent licenses directives in the BUILD fil... by Derek Mauro <dmauro@google.com>
  - 0a76a3653b2ecfdad433d3e2f5b651c4ecdcf74b Remove strip.cc, fastmem.h, and fastmem_test.cc from the ... by Derek Mauro <dmauro@google.com>
  - 77908cfce5927aabca1f8d62481106f22cfc1936 Internal change. by Derek Mauro <dmauro@google.com>
  - d3277b4171f37e22ab346becb5e295c36c7a0219 Be consistent in (not) applying qualifications for enclos... by Abseil Team <absl-team@google.com>
  - 9ec7f8164e7d6a5f64288a7360a346628393cc50 Add std:: qualification to isnan and isinf in duration_te... by Derek Mauro <dmauro@google.com>
  - 9f7c87d7764ddba05286fabca1f4f15285f3250a Fix typos in string_view comments. by Abseil Team <absl-team@google.com>
  - 281860804f8053143d969b99876e3dbc6deb1236 Fix typo in container.h docs. by Abseil Team <absl-team@google.com>
  - 0b0a9388c7a9d7f72349d44b5b46132f45bde56c Add bazel-* symlinks to gitignore. by Michael Pratt <mpratt@google.com>

GitOrigin-RevId: 43853019b439efb32c79d5d50e24508588e1bbe0
Change-Id: I9e74a5430816a34ecf1acb86486ed3b0bd12a1d6
This commit is contained in:
Abseil Team 2017-09-27 10:50:48 -07:00 committed by Derek Mauro
parent 7a64d73e1e
commit cdf20caa49
15 changed files with 66 additions and 998 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
.gitignore vendored Normal file
View file

@ -0,0 +1,2 @@
# Ignore all bazel-* symlinks.
/bazel-*

2
absl/algorithm/container.h
View file

@ -869,7 +869,7 @@ void c_stable_sort(C& c, Compare&& comp) {
// c_is_sorted()
//
// Container-based version of the <algorithm> `std::is_sorted()` function
// to evaluate whethr the given containter is sorted in ascending order.
// to evaluate whether the given containter is sorted in ascending order.
template <typename C>
bool c_is_sorted(const C& c) {
return std::is_sorted(container_algorithm_internal::c_begin(c),

2
absl/meta/BUILD.bazel
View file

@ -6,7 +6,7 @@ load(
package(default_visibility = ["//visibility:public"])
licenses(["unencumbered"]) # Owned by Google
licenses(["notice"]) # Apache 2.0
cc_library(
name = "type_traits",

2
absl/numeric/BUILD.bazel
View file

@ -6,7 +6,7 @@ load(
package(default_visibility = ["//visibility:public"])
licenses(["unencumbered"]) # Owned by Google
licenses(["notice"]) # Apache 2.0
cc_library(
name = "int128",

1
absl/strings/BUILD.bazel
View file

@ -86,7 +86,6 @@ cc_library(
],
hdrs = [
"internal/char_map.h",
"internal/fastmem.h",
"internal/ostringstream.h",
"internal/resize_uninitialized.h",
"internal/utf8.h",

215
absl/strings/internal/fastmem.h
View file

@ -1,215 +0,0 @@
// Copyright 2017 The Abseil Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Fast memory copying and comparison routines.
// strings::fastmemcmp_inlined() replaces memcmp()
// strings::memcpy_inlined() replaces memcpy()
// strings::memeq(a, b, n) replaces memcmp(a, b, n) == 0
//
// strings::*_inlined() routines are inline versions of the
// routines exported by this module. Sometimes using the inlined
// versions is faster. Measure before using the inlined versions.
//
#ifndef ABSL_STRINGS_INTERNAL_FASTMEM_H_
#define ABSL_STRINGS_INTERNAL_FASTMEM_H_
#ifdef __SSE4_1__
#include <immintrin.h>
#endif
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include "absl/base/internal/unaligned_access.h"
#include "absl/base/macros.h"
#include "absl/base/port.h"
namespace absl {
namespace strings_internal {
// Return true if the n bytes at a equal the n bytes at b.
// The regions are allowed to overlap.
//
// The performance is similar to the performance of memcmp(), but faster for
// moderately-sized inputs, or inputs that share a common prefix and differ
// somewhere in their last 8 bytes. Further optimizations can be added later
// if it makes sense to do so. Alternatively, if the compiler & runtime improve
// to eliminate the need for this, we can remove it.
inline bool memeq(const char* a, const char* b, size_t n) {
size_t n_rounded_down = n & ~static_cast<size_t>(7);
if (ABSL_PREDICT_FALSE(n_rounded_down == 0)) { // n <= 7
return memcmp(a, b, n) == 0;
}
// n >= 8
{
uint64_t u =
ABSL_INTERNAL_UNALIGNED_LOAD64(a) ^ ABSL_INTERNAL_UNALIGNED_LOAD64(b);
uint64_t v = ABSL_INTERNAL_UNALIGNED_LOAD64(a + n - 8) ^
ABSL_INTERNAL_UNALIGNED_LOAD64(b + n - 8);
if ((u | v) != 0) { // The first or last 8 bytes differ.
return false;
}
}
// The next line forces n to be a multiple of 8.
n = n_rounded_down;
if (n >= 80) {
// In 2013 or later, this should be fast on long strings.
return memcmp(a, b, n) == 0;
}
// Now force n to be a multiple of 16. Arguably, a "switch" would be smart
// here, but there's a difficult-to-evaluate code size vs. speed issue. The
// current approach often re-compares some bytes (worst case is if n initially
// was 16, 32, 48, or 64), but is fairly short.
size_t e = n & 8;
a += e;
b += e;
n -= e;
// n is now in {0, 16, 32, ...}. Process 0 or more 16-byte chunks.
while (n > 0) {
#ifdef __SSE4_1__
__m128i u =
_mm_xor_si128(_mm_loadu_si128(reinterpret_cast<const __m128i*>(a)),
_mm_loadu_si128(reinterpret_cast<const __m128i*>(b)));
if (!_mm_test_all_zeros(u, u)) {
return false;
}
#else
uint64_t x =
ABSL_INTERNAL_UNALIGNED_LOAD64(a) ^ ABSL_INTERNAL_UNALIGNED_LOAD64(b);
uint64_t y = ABSL_INTERNAL_UNALIGNED_LOAD64(a + 8) ^
ABSL_INTERNAL_UNALIGNED_LOAD64(b + 8);
if ((x | y) != 0) {
return false;
}
#endif
a += 16;
b += 16;
n -= 16;
}
return true;
}
inline int fastmemcmp_inlined(const void* va, const void* vb, size_t n) {
const unsigned char* pa = static_cast<const unsigned char*>(va);
const unsigned char* pb = static_cast<const unsigned char*>(vb);
switch (n) {
default:
return memcmp(va, vb, n);
case 7:
if (*pa != *pb) return *pa < *pb ? -1 : +1;
++pa;
++pb;
ABSL_FALLTHROUGH_INTENDED;
case 6:
if (*pa != *pb) return *pa < *pb ? -1 : +1;
++pa;
++pb;
ABSL_FALLTHROUGH_INTENDED;
case 5:
if (*pa != *pb) return *pa < *pb ? -1 : +1;
++pa;
++pb;
ABSL_FALLTHROUGH_INTENDED;
case 4:
if (*pa != *pb) return *pa < *pb ? -1 : +1;
++pa;
++pb;
ABSL_FALLTHROUGH_INTENDED;
case 3:
if (*pa != *pb) return *pa < *pb ? -1 : +1;
++pa;
++pb;
ABSL_FALLTHROUGH_INTENDED;
case 2:
if (*pa != *pb) return *pa < *pb ? -1 : +1;
++pa;
++pb;
ABSL_FALLTHROUGH_INTENDED;
case 1:
if (*pa != *pb) return *pa < *pb ? -1 : +1;
ABSL_FALLTHROUGH_INTENDED;
case 0:
break;
}
return 0;
}
// The standard memcpy operation is slow for variable small sizes.
// This implementation inlines the optimal realization for sizes 1 to 16.
// To avoid code bloat don't use it in case of not performance-critical spots,
// nor when you don't expect very frequent values of size <= 16.
inline void memcpy_inlined(char* dst, const char* src, size_t size) {
// Compiler inlines code with minimal amount of data movement when third
// parameter of memcpy is a constant.
switch (size) {
case 1:
memcpy(dst, src, 1);
break;
case 2:
memcpy(dst, src, 2);
break;
case 3:
memcpy(dst, src, 3);
break;
case 4:
memcpy(dst, src, 4);
break;
case 5:
memcpy(dst, src, 5);
break;
case 6:
memcpy(dst, src, 6);
break;
case 7:
memcpy(dst, src, 7);
break;
case 8:
memcpy(dst, src, 8);
break;
case 9:
memcpy(dst, src, 9);
break;
case 10:
memcpy(dst, src, 10);
break;
case 11:
memcpy(dst, src, 11);
break;
case 12:
memcpy(dst, src, 12);
break;
case 13:
memcpy(dst, src, 13);
break;
case 14:
memcpy(dst, src, 14);
break;
case 15:
memcpy(dst, src, 15);
break;
case 16:
memcpy(dst, src, 16);
break;
default:
memcpy(dst, src, size);
break;
}
}
} // namespace strings_internal
} // namespace absl
#endif // ABSL_STRINGS_INTERNAL_FASTMEM_H_

453
absl/strings/internal/fastmem_test.cc
View file

@ -1,453 +0,0 @@
// Copyright 2017 The Abseil Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "absl/strings/internal/fastmem.h"
#include <memory>
#include <random>
#include <string>
#include "base/init_google.h"
#include "base/logging.h"
#include "testing/base/public/benchmark.h"
#include "gtest/gtest.h"
namespace {
using RandomEngine = std::minstd_rand0;
void VerifyResults(const int r1, const int r2, const std::string& a,
const std::string& b) {
CHECK_EQ(a.size(), b.size());
if (r1 == 0) {
EXPECT_EQ(r2, 0) << a << " " << b;
} else if (r1 > 0) {
EXPECT_GT(r2, 0) << a << " " << b;
} else {
EXPECT_LT(r2, 0) << a << " " << b;
}
if ((r1 == 0) == (r2 == 0)) {
EXPECT_EQ(r1 == 0,
absl::strings_internal::memeq(a.data(), b.data(), a.size()))
<< r1 << " " << a << " " << b;
}
}
// Check correctness against glibc's memcmp implementation
void CheckSingle(const std::string& a, const std::string& b) {
CHECK_EQ(a.size(), b.size());
const int r1 = memcmp(a.data(), b.data(), a.size());
const int r2 =
absl::strings_internal::fastmemcmp_inlined(a.data(), b.data(), a.size());
VerifyResults(r1, r2, a, b);
}
void GenerateString(size_t len, std::string* s) {
s->clear();
for (int i = 0; i < len; i++) {
*s += ('a' + (i % 26));
}
}
void CheckCompare(const std::string& a, const std::string& b) {
CheckSingle(a, b);
for (int common = 0; common <= 32; common++) {
std::string extra;
GenerateString(common, &extra);
CheckSingle(extra + a, extra + b);
CheckSingle(a + extra, b + extra);
for (char c1 = 'a'; c1 <= 'c'; c1++) {
for (char c2 = 'a'; c2 <= 'c'; c2++) {
CheckSingle(extra + c1 + a, extra + c2 + b);
}
}
}
}
TEST(FastCompare, Misc) {
CheckCompare("", "");
CheckCompare("a", "a");
CheckCompare("ab", "ab");
CheckCompare("abc", "abc");
CheckCompare("abcd", "abcd");
CheckCompare("abcde", "abcde");
CheckCompare("a", "x");
CheckCompare("ab", "xb");
CheckCompare("abc", "xbc");
CheckCompare("abcd", "xbcd");
CheckCompare("abcde", "xbcde");
CheckCompare("x", "a");
CheckCompare("xb", "ab");
CheckCompare("xbc", "abc");
CheckCompare("xbcd", "abcd");
CheckCompare("xbcde", "abcde");
CheckCompare("a", "x");
CheckCompare("ab", "ax");
CheckCompare("abc", "abx");
CheckCompare("abcd", "abcx");
CheckCompare("abcde", "abcdx");
CheckCompare("x", "a");
CheckCompare("ax", "ab");
CheckCompare("abx", "abc");
CheckCompare("abcx", "abcd");
CheckCompare("abcdx", "abcde");
for (int len = 0; len < 1000; len++) {
std::string p(len, 'z');
CheckCompare(p + "x", p + "a");
CheckCompare(p + "ax", p + "ab");
CheckCompare(p + "abx", p + "abc");
CheckCompare(p + "abcx", p + "abcd");
CheckCompare(p + "abcdx", p + "abcde");
}
}
TEST(FastCompare, TrailingByte) {
for (int i = 0; i < 256; i++) {
for (int j = 0; j < 256; j++) {
std::string a(1, i);
std::string b(1, j);
CheckSingle(a, b);
}
}
}
// Check correctness of memcpy_inlined.
void CheckSingleMemcpyInlined(const std::string& a) {
std::unique_ptr<char[]> destination(new char[a.size() + 2]);
destination[0] = 'x';
destination[a.size() + 1] = 'x';
absl::strings_internal::memcpy_inlined(destination.get() + 1, a.data(),
a.size());
CHECK_EQ('x', destination[0]);
CHECK_EQ('x', destination[a.size() + 1]);
CHECK_EQ(0, memcmp(a.data(), destination.get() + 1, a.size()));
}
TEST(MemCpyInlined, Misc) {
CheckSingleMemcpyInlined("");
CheckSingleMemcpyInlined("0");
CheckSingleMemcpyInlined("012");
CheckSingleMemcpyInlined("0123");
CheckSingleMemcpyInlined("01234");
CheckSingleMemcpyInlined("012345");
CheckSingleMemcpyInlined("0123456");
CheckSingleMemcpyInlined("01234567");
CheckSingleMemcpyInlined("012345678");
CheckSingleMemcpyInlined("0123456789");
CheckSingleMemcpyInlined("0123456789a");
CheckSingleMemcpyInlined("0123456789ab");
CheckSingleMemcpyInlined("0123456789abc");
CheckSingleMemcpyInlined("0123456789abcd");
CheckSingleMemcpyInlined("0123456789abcde");
CheckSingleMemcpyInlined("0123456789abcdef");
CheckSingleMemcpyInlined("0123456789abcdefg");
}
template <typename Function>
inline void CopyLoop(benchmark::State& state, int size, Function func) {
char* src = new char[size];
char* dst = new char[size];
memset(src, 'x', size);
memset(dst, 'y', size);
for (auto _ : state) {
func(dst, src, size);
}
state.SetBytesProcessed(static_cast<int64_t>(state.iterations()) * size);
CHECK_EQ(dst[0], 'x');
delete[] src;
delete[] dst;
}
void BM_memcpy(benchmark::State& state) {
CopyLoop(state, state.range(0), memcpy);
}
BENCHMARK(BM_memcpy)->DenseRange(1, 18)->Range(32, 8 << 20);
void BM_memcpy_inlined(benchmark::State& state) {
CopyLoop(state, state.range(0), absl::strings_internal::memcpy_inlined);
}
BENCHMARK(BM_memcpy_inlined)->DenseRange(1, 18)->Range(32, 8 << 20);
// unaligned memcpy
void BM_unaligned_memcpy(benchmark::State& state) {
const int n = state.range(0);
const int kMaxOffset = 32;
char* src = new char[n + kMaxOffset];
char* dst = new char[n + kMaxOffset];
memset(src, 'x', n + kMaxOffset);
int r = 0, i = 0;
for (auto _ : state) {
memcpy(dst + (i % kMaxOffset), src + ((i + 5) % kMaxOffset), n);
r += dst[0];
++i;
}
state.SetBytesProcessed(static_cast<int64_t>(state.iterations()) * n);
delete[] src;
delete[] dst;
benchmark::DoNotOptimize(r);
}
BENCHMARK(BM_unaligned_memcpy)->DenseRange(1, 18)->Range(32, 8 << 20);
// memmove worst case: heavy overlap, but not always by the same amount.
// Also, the source and destination will often be unaligned.
void BM_memmove_worst_case(benchmark::State& state) {
const int n = state.range(0);
const int32_t kDeterministicSeed = 301;
const int kMaxOffset = 32;
char* src = new char[n + kMaxOffset];
memset(src, 'x', n + kMaxOffset);
size_t offsets[64];
RandomEngine rng(kDeterministicSeed);
std::uniform_int_distribution<size_t> random_to_max_offset(0, kMaxOffset);
for (size_t& offset : offsets) {
offset = random_to_max_offset(rng);
}
int r = 0, i = 0;
for (auto _ : state) {
memmove(src + offsets[i], src + offsets[i + 1], n);
r += src[0];
i = (i + 2) % arraysize(offsets);
}
state.SetBytesProcessed(static_cast<int64_t>(state.iterations()) * n);
delete[] src;
benchmark::DoNotOptimize(r);
}
BENCHMARK(BM_memmove_worst_case)->DenseRange(1, 18)->Range(32, 8 << 20);
// memmove cache-friendly: aligned and overlapping with 4k
// between the source and destination addresses.
void BM_memmove_cache_friendly(benchmark::State& state) {
const int n = state.range(0);
char* src = new char[n + 4096];
memset(src, 'x', n);
int r = 0;
while (state.KeepRunningBatch(2)) { // count each memmove as an iteration
memmove(src + 4096, src, n);
memmove(src, src + 4096, n);
r += src[0];
}
state.SetBytesProcessed(static_cast<int64_t>(state.iterations()) * n);
delete[] src;
benchmark::DoNotOptimize(r);
}
BENCHMARK(BM_memmove_cache_friendly)
->Arg(5 * 1024)
->Arg(10 * 1024)
->Range(16 << 10, 8 << 20);
// memmove best(?) case: aligned and non-overlapping.
void BM_memmove_aligned_non_overlapping(benchmark::State& state) {
CopyLoop(state, state.range(0), memmove);
}
BENCHMARK(BM_memmove_aligned_non_overlapping)
->DenseRange(1, 18)
->Range(32, 8 << 20);
// memset speed
void BM_memset(benchmark::State& state) {
const int n = state.range(0);
char* dst = new char[n];
int r = 0;
for (auto _ : state) {
memset(dst, 'x', n);
r += dst[0];
}
state.SetBytesProcessed(static_cast<int64_t>(state.iterations()) * n);
delete[] dst;
benchmark::DoNotOptimize(r);
}
BENCHMARK(BM_memset)->Range(8, 4096 << 10);
// Bandwidth (vectorization?) test: the ideal generated code will be limited
// by memory bandwidth. Even so-so generated code will max out memory bandwidth
// on some machines.
void BM_membandwidth(benchmark::State& state) {
const int n = state.range(0);
CHECK_EQ(n % 32, 0); // We will read 32 bytes per iter.
char* dst = new char[n];
int r = 0;
for (auto _ : state) {
const uint32_t* p = reinterpret_cast<uint32_t*>(dst);
const uint32_t* limit = reinterpret_cast<uint32_t*>(dst + n);
uint32_t x = 0;
while (p < limit) {
x += p[0];
x += p[1];
x += p[2];
x += p[3];
x += p[4];
x += p[5];
x += p[6];
x += p[7];
p += 8;
}
r += x;
}
state.SetBytesProcessed(static_cast<int64_t>(state.iterations()) * n);
delete[] dst;
benchmark::DoNotOptimize(r);
}
BENCHMARK(BM_membandwidth)->Range(32, 16384 << 10);
// Helper for benchmarks. Repeatedly compares two strings that are
// either equal or different only in one character. If test_equal_strings
// is false then position_to_modify determines where the difference will be.
template <typename Function>
ABSL_ATTRIBUTE_ALWAYS_INLINE inline void StringCompareLoop(
benchmark::State& state, bool test_equal_strings,
std::string::size_type position_to_modify, int size, Function func) {
const int kIterMult = 4; // Iteration multiplier for better timing resolution
CHECK_GT(size, 0);
const bool position_to_modify_is_valid =
position_to_modify != std::string::npos && position_to_modify < size;
CHECK_NE(position_to_modify_is_valid, test_equal_strings);
if (!position_to_modify_is_valid) {
position_to_modify = 0;
}
std::string sa(size, 'a');
std::string sb = sa;
char last = sa[size - 1];
int num = 0;
for (auto _ : state) {
for (int i = 0; i < kIterMult; ++i) {
sb[position_to_modify] = test_equal_strings ? last : last ^ 1;
num += func(sa, sb);
}
}
state.SetBytesProcessed(static_cast<int64_t>(state.iterations()) * size);
benchmark::DoNotOptimize(num);
}
// Helper for benchmarks. Repeatedly compares two memory regions that are
// either equal or different only in their final character.
template <typename Function>
ABSL_ATTRIBUTE_ALWAYS_INLINE inline void CompareLoop(benchmark::State& state,
bool test_equal_strings,
int size, Function func) {
const int kIterMult = 4; // Iteration multiplier for better timing resolution
CHECK_GT(size, 0);
char* data = static_cast<char*>(malloc(size * 2));
memset(data, 'a', size * 2);
char* a = data;
char* b = data + size;
char last = a[size - 1];
int num = 0;
for (auto _ : state) {
for (int i = 0; i < kIterMult; ++i) {
b[size - 1] = test_equal_strings ? last : last ^ 1;
num += func(a, b, size);
}
}
state.SetBytesProcessed(static_cast<int64_t>(state.iterations()) * size);
benchmark::DoNotOptimize(num);
free(data);
}
void BM_memcmp(benchmark::State& state) {
CompareLoop(state, false, state.range(0), memcmp);
}
BENCHMARK(BM_memcmp)->DenseRange(1, 9)->Range(32, 8 << 20);
void BM_fastmemcmp_inlined(benchmark::State& state) {
CompareLoop(state, false, state.range(0),
absl::strings_internal::fastmemcmp_inlined);
}
BENCHMARK(BM_fastmemcmp_inlined)->DenseRange(1, 9)->Range(32, 8 << 20);
void BM_memeq(benchmark::State& state) {
CompareLoop(state, false, state.range(0), absl::strings_internal::memeq);
}
BENCHMARK(BM_memeq)->DenseRange(1, 9)->Range(32, 8 << 20);
void BM_memeq_equal(benchmark::State& state) {
CompareLoop(state, true, state.range(0), absl::strings_internal::memeq);
}
BENCHMARK(BM_memeq_equal)->DenseRange(1, 9)->Range(32, 8 << 20);
bool StringLess(const std::string& x, const std::string& y) { return x < y; }
bool StringEqual(const std::string& x, const std::string& y) { return x == y; }
bool StdEqual(const std::string& x, const std::string& y) {
return x.size() == y.size() &&
std::equal(x.data(), x.data() + x.size(), y.data());
}
// Benchmark for x < y, where x and y are strings that differ in only their
// final char. That should be more-or-less the worst case for <.
void BM_string_less(benchmark::State& state) {
StringCompareLoop(state, false, state.range(0) - 1, state.range(0),
StringLess);
}
BENCHMARK(BM_string_less)->DenseRange(1, 9)->Range(32, 1 << 20);
// Benchmark for x < y, where x and y are strings that differ in only their
// first char. That should be more-or-less the best case for <.
void BM_string_less_easy(benchmark::State& state) {
StringCompareLoop(state, false, 0, state.range(0), StringLess);
}
BENCHMARK(BM_string_less_easy)->DenseRange(1, 9)->Range(32, 1 << 20);
void BM_string_equal(benchmark::State& state) {
StringCompareLoop(state, false, state.range(0) - 1, state.range(0),
StringEqual);
}
BENCHMARK(BM_string_equal)->DenseRange(1, 9)->Range(32, 1 << 20);
void BM_string_equal_equal(benchmark::State& state) {
StringCompareLoop(state, true, std::string::npos, state.range(0), StringEqual);
}
BENCHMARK(BM_string_equal_equal)->DenseRange(1, 9)->Range(32, 1 << 20);
void BM_std_equal(benchmark::State& state) {
StringCompareLoop(state, false, state.range(0) - 1, state.range(0), StdEqual);
}
BENCHMARK(BM_std_equal)->DenseRange(1, 9)->Range(32, 1 << 20);
void BM_std_equal_equal(benchmark::State& state) {
StringCompareLoop(state, true, std::string::npos, state.range(0), StdEqual);
}
BENCHMARK(BM_std_equal_equal)->DenseRange(1, 9)->Range(32, 1 << 20);
void BM_string_equal_unequal_lengths(benchmark::State& state) {
const int size = state.range(0);
std::string a(size, 'a');
std::string b(size + 1, 'a');
int count = 0;
for (auto _ : state) {
b[size - 1] = 'a';
count += (a == b);
}
benchmark::DoNotOptimize(count);
}
BENCHMARK(BM_string_equal_unequal_lengths)->Arg(1)->Arg(1 << 20);
void BM_stdstring_equal_unequal_lengths(benchmark::State& state) {
const int size = state.range(0);
std::string a(size, 'a');
std::string b(size + 1, 'a');
int count = 0;
for (auto _ : state) {
b[size - 1] = 'a';
count += (a == b);
}
benchmark::DoNotOptimize(count);
}
BENCHMARK(BM_stdstring_equal_unequal_lengths)->Arg(1)->Arg(1 << 20);
} // namespace

8
absl/strings/str_split.h
View file

@ -118,7 +118,7 @@ namespace absl {
// using absl::ByString;
// std::vector<std::string> v2 = absl::StrSplit("a, b, c",
// ByString(", "));
// // v[0] == "a", v[1] == "b", v[3] == "c"
// // v[0] == "a", v[1] == "b", v[2] == "c"
class ByString {
public:
explicit ByString(absl::string_view sp);
@ -141,7 +141,7 @@ class ByString {
// std::vector<std::string> v1 = absl::StrSplit("a,b,c", ',');
// using absl::ByChar;
// std::vector<std::string> v2 = absl::StrSplit("a,b,c", ByChar(','));
// // v[0] == "a", v[1] == "b", v[3] == "c"
// // v[0] == "a", v[1] == "b", v[2] == "c"
//
// `ByChar` is also the default delimiter if a single character is given
// as the delimiter to `StrSplit()`. For example, the following calls are
@ -173,7 +173,7 @@ class ByChar {
//
// using absl::ByAnyChar;
// std::vector<std::string> v = absl::StrSplit("a,b=c", ByAnyChar(",="));
// // v[0] == "a", v[1] == "b", v[3] == "c"
// // v[0] == "a", v[1] == "b", v[2] == "c"
//
// If `ByAnyChar` is given the empty std::string, it behaves exactly like
// `ByString` and matches each individual character in the input std::string.
@ -390,7 +390,7 @@ struct SkipWhitespace {
//
// using absl::ByAnyChar;
// std::vector<std::string> v = absl::StrSplit("a,b=c", ByAnyChar(",="));
// // v[0] == "a", v[1] == "b", v[3] == "c"
// // v[0] == "a", v[1] == "b", v[2] == "c"
//
// See above for more information on delimiters.
//

4
absl/strings/string_view.h
View file

@ -339,8 +339,8 @@ class string_view {
// string_view::substr()
//
// Returns a "substring" of the `string_view` (at offset `post` and length
// `n`) as another std::string views. This function throws `std::out_of_bounds` if
// Returns a "substring" of the `string_view` (at offset `pos` and length
// `n`) as another string_view. This function throws `std::out_of_bounds` if
// `pos > size'.
string_view substr(size_type pos, size_type n = npos) const {
if (ABSL_PREDICT_FALSE(pos > length_))

268
absl/strings/strip.cc
View file

@ -1,268 +0,0 @@
// Copyright 2017 The Abseil Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// This file contains functions that remove a defined part from the std::string,
// i.e., strip the std::string.
#include "absl/strings/strip.h"
#include <algorithm>
#include <cstring>
#include <string>
#include "absl/strings/ascii.h"
#include "absl/strings/string_view.h"
// ----------------------------------------------------------------------
// ReplaceCharacters
// Replaces any occurrence of the character 'remove' (or the characters
// in 'remove') with the character 'replace_with'.
// ----------------------------------------------------------------------
void ReplaceCharacters(char* str, size_t len, absl::string_view remove,
char replace_with) {
for (char* end = str + len; str != end; ++str) {
if (remove.find(*str) != absl::string_view::npos) {
*str = replace_with;
}
}
}
void ReplaceCharacters(std::string* s, absl::string_view remove, char replace_with) {
for (char& ch : *s) {
if (remove.find(ch) != absl::string_view::npos) {
ch = replace_with;
}
}
}
bool StripTrailingNewline(std::string* s) {
if (!s->empty() && (*s)[s->size() - 1] == '\n') {
if (s->size() > 1 && (*s)[s->size() - 2] == '\r')
s->resize(s->size() - 2);
else
s->resize(s->size() - 1);
return true;
}
return false;
}
// ----------------------------------------------------------------------
// Misc. stripping routines
// ----------------------------------------------------------------------
void StripCurlyBraces(std::string* s) {
return StripBrackets('{', '}', s);
}
void StripBrackets(char left, char right, std::string* s) {
std::string::iterator opencurly = std::find(s->begin(), s->end(), left);
while (opencurly != s->end()) {
std::string::iterator closecurly = std::find(opencurly, s->end(), right);
if (closecurly == s->end()) return;
opencurly = s->erase(opencurly, closecurly + 1);
opencurly = std::find(opencurly, s->end(), left);
}
}
void StripMarkupTags(std::string* s) {
std::string::iterator output = std::find(s->begin(), s->end(), '<');
std::string::iterator input = output;
while (input != s->end()) {
if (*input == '<') {
input = std::find(input, s->end(), '>');
if (input == s->end()) break;
++input;
} else {
*output++ = *input++;
}
}
s->resize(output - s->begin());
}
std::string OutputWithMarkupTagsStripped(const std::string& s) {
std::string result(s);
StripMarkupTags(&result);
return result;
}
ptrdiff_t TrimStringLeft(std::string* s, absl::string_view remove) {
size_t i = 0;
while (i < s->size() && memchr(remove.data(), (*s)[i], remove.size())) {
++i;
}
if (i > 0) s->erase(0, i);
return i;
}
ptrdiff_t TrimStringRight(std::string* s, absl::string_view remove) {
size_t i = s->size(), trimmed = 0;
while (i > 0 && memchr(remove.data(), (*s)[i - 1], remove.size())) {
--i;
}
if (i < s->size()) {
trimmed = s->size() - i;
s->erase(i);
}
return trimmed;
}
// Unfortunately, absl::string_view does not have erase, so we've to replicate
// the implementation with remove_prefix()/remove_suffix()
ptrdiff_t TrimStringLeft(absl::string_view* s, absl::string_view remove) {
size_t i = 0;
while (i < s->size() && memchr(remove.data(), (*s)[i], remove.size())) {
++i;
}
if (i > 0) s->remove_prefix(i);
return i;
}
ptrdiff_t TrimStringRight(absl::string_view* s, absl::string_view remove) {
size_t i = s->size(), trimmed = 0;
while (i > 0 && memchr(remove.data(), (*s)[i - 1], remove.size())) {
--i;
}
if (i < s->size()) {
trimmed = s->size() - i;
s->remove_suffix(trimmed);
}
return trimmed;
}
// ----------------------------------------------------------------------
// Various removal routines
// ----------------------------------------------------------------------
ptrdiff_t strrm(char* str, char c) {
char* src;
char* dest;
for (src = dest = str; *src != '\0'; ++src)
if (*src != c) *(dest++) = *src;
*dest = '\0';
return dest - str;
}
ptrdiff_t memrm(char* str, ptrdiff_t strlen, char c) {
char* src;
char* dest;
for (src = dest = str; strlen-- > 0; ++src)
if (*src != c) *(dest++) = *src;
return dest - str;
}
ptrdiff_t strrmm(char* str, const char* chars) {
char* src;
char* dest;
for (src = dest = str; *src != '\0'; ++src) {
bool skip = false;
for (const char* c = chars; *c != '\0'; c++) {
if (*src == *c) {
skip = true;
break;
}
}
if (!skip) *(dest++) = *src;
}
*dest = '\0';
return dest - str;
}
ptrdiff_t strrmm(std::string* str, const std::string& chars) {
size_t str_len = str->length();
size_t in_index = str->find_first_of(chars);
if (in_index == std::string::npos) return str_len;
size_t out_index = in_index++;
while (in_index < str_len) {
char c = (*str)[in_index++];
if (chars.find(c) == std::string::npos) (*str)[out_index++] = c;
}
str->resize(out_index);
return out_index;
}
// ----------------------------------------------------------------------
// StripDupCharacters
// Replaces any repeated occurrence of the character 'dup_char'
// with single occurrence. e.g.,
// StripDupCharacters("a//b/c//d", '/', 0) => "a/b/c/d"
// Return the number of characters removed
// ----------------------------------------------------------------------
ptrdiff_t StripDupCharacters(std::string* s, char dup_char, ptrdiff_t start_pos) {
if (start_pos < 0) start_pos = 0;
// remove dups by compaction in-place
ptrdiff_t input_pos = start_pos; // current reader position
ptrdiff_t output_pos = start_pos; // current writer position
const ptrdiff_t input_end = s->size();
while (input_pos < input_end) {
// keep current character
const char curr_char = (*s)[input_pos];
if (output_pos != input_pos) // must copy
(*s)[output_pos] = curr_char;
++input_pos;
++output_pos;
if (curr_char == dup_char) { // skip subsequent dups
while ((input_pos < input_end) && ((*s)[input_pos] == dup_char))
++input_pos;
}
}
const ptrdiff_t num_deleted = input_pos - output_pos;
s->resize(s->size() - num_deleted);
return num_deleted;
}
// ----------------------------------------------------------------------
// TrimRunsInString
// Removes leading and trailing runs, and collapses middle
// runs of a set of characters into a single character (the
// first one specified in 'remove'). Useful for collapsing
// runs of repeated delimiters, whitespace, etc. E.g.,
// TrimRunsInString(&s, " :,()") removes leading and trailing
// delimiter chars and collapses and converts internal runs
// of delimiters to single ' ' characters, so, for example,
// " a:(b):c " -> "a b c"
// "first,last::(area)phone, ::zip" -> "first last area phone zip"
// ----------------------------------------------------------------------
void TrimRunsInString(std::string* s, absl::string_view remove) {
std::string::iterator dest = s->begin();
std::string::iterator src_end = s->end();
for (std::string::iterator src = s->begin(); src != src_end;) {
if (remove.find(*src) == absl::string_view::npos) {
*(dest++) = *(src++);
} else {
// Skip to the end of this run of chars that are in 'remove'.
for (++src; src != src_end; ++src) {
if (remove.find(*src) == absl::string_view::npos) {
if (dest != s->begin()) {
// This is an internal run; collapse it.
*(dest++) = remove[0];
}
*(dest++) = *(src++);
break;
}
}
}
}
s->erase(dest, src_end);
}
// ----------------------------------------------------------------------
// RemoveNullsInString
// Removes any internal \0 characters from the std::string.
// ----------------------------------------------------------------------
void RemoveNullsInString(std::string* s) {
s->erase(std::remove(s->begin(), s->end(), '\0'), s->end());
}

24
absl/time/duration_test.cc
View file

@ -460,10 +460,10 @@ TEST(Duration, InfinityAddition) {
// For reference: IEEE 754 behavior
const double dbl_inf = std::numeric_limits<double>::infinity();
EXPECT_TRUE(isinf(dbl_inf + dbl_inf));
EXPECT_TRUE(isnan(dbl_inf + -dbl_inf)); // We return inf
EXPECT_TRUE(isnan(-dbl_inf + dbl_inf)); // We return inf
EXPECT_TRUE(isinf(-dbl_inf + -dbl_inf));
EXPECT_TRUE(std::isinf(dbl_inf + dbl_inf));
EXPECT_TRUE(std::isnan(dbl_inf + -dbl_inf)); // We return inf
EXPECT_TRUE(std::isnan(-dbl_inf + dbl_inf)); // We return inf
EXPECT_TRUE(std::isinf(-dbl_inf + -dbl_inf));
}
TEST(Duration, InfinitySubtraction) {
@ -497,10 +497,10 @@ TEST(Duration, InfinitySubtraction) {
// For reference: IEEE 754 behavior
const double dbl_inf = std::numeric_limits<double>::infinity();
EXPECT_TRUE(isnan(dbl_inf - dbl_inf)); // We return inf
EXPECT_TRUE(isinf(dbl_inf - -dbl_inf));
EXPECT_TRUE(isinf(-dbl_inf - dbl_inf));
EXPECT_TRUE(isnan(-dbl_inf - -dbl_inf)); // We return inf
EXPECT_TRUE(std::isnan(dbl_inf - dbl_inf)); // We return inf
EXPECT_TRUE(std::isinf(dbl_inf - -dbl_inf));
EXPECT_TRUE(std::isinf(-dbl_inf - dbl_inf));
EXPECT_TRUE(std::isnan(-dbl_inf - -dbl_inf)); // We return inf
}
TEST(Duration, InfinityMultiplication) {
@ -708,13 +708,13 @@ TEST(Duration, InfinityIDiv) {
// IEEE 754 says inf / inf should be nan, but int64_t doesn't have
// nan so we'll return kint64max/kint64min instead.
EXPECT_TRUE(isnan(dbl_inf / dbl_inf));
EXPECT_TRUE(std::isnan(dbl_inf / dbl_inf));
EXPECT_EQ(kint64max, inf / inf);
EXPECT_EQ(kint64max, -inf / -inf);
EXPECT_EQ(kint64min, -inf / inf);
EXPECT_EQ(kint64min, inf / -inf);
EXPECT_TRUE(isinf(dbl_inf / 2.0));
EXPECT_TRUE(std::isinf(dbl_inf / 2.0));
EXPECT_EQ(kint64max, inf / any_dur);
EXPECT_EQ(kint64max, -inf / -any_dur);
EXPECT_EQ(kint64min, -inf / any_dur);
@ -763,8 +763,8 @@ TEST(Duration, DivisionByZero) {
// IEEE 754 behavior
double z = 0.0, two = 2.0;
EXPECT_TRUE(isinf(two / z));
EXPECT_TRUE(isnan(z / z)); // We'll return inf
EXPECT_TRUE(std::isinf(two / z));
EXPECT_TRUE(std::isnan(z / z)); // We'll return inf
// Operator/(Duration, double)
EXPECT_EQ(inf, zero / 0.0);

6
absl/time/time.cc
View file

@ -15,7 +15,7 @@
// The implementation of the absl::Time class, which is declared in
// //absl/time.h.
//
// The representation for a absl::Time is a absl::Duration offset from the
// The representation for an absl::Time is an absl::Duration offset from the
// epoch. We use the traditional Unix epoch (1970-01-01 00:00:00 +0000)
// for convenience, but this is not exposed in the API and could be changed.
//
@ -23,12 +23,12 @@
// conventions are used throughout this file.
//
// cz: A cctz::time_zone
// tz: A absl::TimeZone
// tz: An absl::TimeZone
// cl: A cctz::time_zone::civil_lookup
// al: A cctz::time_zone::absolute_lookup
// cd: A cctz::civil_day
// cs: A cctz::civil_second
// bd: A absl::Time::Breakdown
// bd: An absl::Time::Breakdown
#include "absl/time/time.h"

33
absl/time/time.h
View file

@ -558,12 +558,18 @@ class Time {
constexpr Time() {}
// Assignment operators.
Time& operator+=(Duration d) { rep_ += d; return *this; }
Time& operator-=(Duration d) { rep_ -= d; return *this; }
Time& operator+=(Duration d) {
rep_ += d;
return *this;
}
Time& operator-=(Duration d) {
rep_ -= d;
return *this;
}
// Time::Breakdown
//
// The calendar and wall-clock (aka "civil time") components of a
// The calendar and wall-clock (aka "civil time") components of an
// `absl::Time` in a certain `absl::TimeZone`. This struct is not
// intended to represent an instant in time. So, rather than passing
// a `Time::Breakdown` to a function, pass an `absl::Time` and an
@ -624,9 +630,7 @@ inline Duration operator-(Time lhs, Time rhs) { return lhs.rep_ - rhs.rep_; }
// UnixEpoch()
//
// Returns the `absl::Time` representing "1970-01-01 00:00:00.0 +0000".
constexpr Time UnixEpoch() {
return Time();
}
constexpr Time UnixEpoch() { return Time(); }
// UniversalEpoch()
//
@ -937,7 +941,7 @@ inline std::ostream& operator<<(std::ostream& os, Time t) {
//
// "1970-01-01 00:00:00.0 +0000"
//
// For example, parsing a std::string of "15:45" (%H:%M) will return a absl::Time
// For example, parsing a std::string of "15:45" (%H:%M) will return an absl::Time
// that represents "1970-01-01 15:45:00.0 +0000". Note: Since ParseTime()
// returns time instants, it makes the most sense to parse fully-specified
// date/time strings that include a UTC offset (%z/%Ez), such as those
@ -968,8 +972,8 @@ inline std::ostream& operator<<(std::ostream& os, Time t) {
// If the input std::string is "infinite-past", the returned `absl::Time` will be
// `absl::InfinitePast()` and `true` will be returned.
//
bool ParseTime(const std::string& format, const std::string& input,
Time* time, std::string* err);
bool ParseTime(const std::string& format, const std::string& input, Time* time,
std::string* err);
// Like ParseTime() above, but if the format std::string does not contain a UTC
// offset specification (%z/%Ez) then the input is interpreted in the given
@ -994,8 +998,8 @@ bool ParseTime(const std::string& format, const std::string& input, TimeZone tz,
// Note: A UTC offset (or 'Z' indicating a zero-offset from UTC) is required.
//
// Additionally, if you'd like to specify a time as a count of
// seconds/milliseconds/etc from the Unix epoch, use a absl::Duration flag and
// add that duration to absl::UnixEpoch() to get a absl::Time.
// seconds/milliseconds/etc from the Unix epoch, use an absl::Duration flag
// and add that duration to absl::UnixEpoch() to get an absl::Time.
bool ParseFlag(const std::string& text, Time* t, std::string* error);
std::string UnparseFlag(Time t);
@ -1098,7 +1102,7 @@ constexpr Duration MakeDuration(int64_t hi, uint32_t lo = 0) {
}
constexpr Duration MakeDuration(int64_t hi, int64_t lo) {
return time_internal::MakeDuration(hi, static_cast<uint32_t>(lo));
return MakeDuration(hi, static_cast<uint32_t>(lo));
}
// Creates a normalized Duration from an almost-normalized (sec,ticks)
@ -1106,9 +1110,8 @@ constexpr Duration MakeDuration(int64_t hi, int64_t lo) {
// -kTicksPerSecond < *ticks < kTicksPerSecond. If ticks is negative it
// will be normalized to a positive value in the resulting Duration.
constexpr Duration MakeNormalizedDuration(int64_t sec, int64_t ticks) {
return (ticks < 0)
? time_internal::MakeDuration(sec - 1, ticks + kTicksPerSecond)
: time_internal::MakeDuration(sec, ticks);
return (ticks < 0) ? MakeDuration(sec - 1, ticks + kTicksPerSecond)
: MakeDuration(sec, ticks);
}
// Provide access to the Duration representation.
constexpr int64_t GetRepHi(Duration d) { return d.rep_hi_; }

2
absl/types/span.h
View file

@ -35,7 +35,7 @@
// * `absl::Span` has no `operator()`
// * `absl::Span` has no constructors for `std::unique_ptr` or
// `std::shared_ptr`
// * `absl::span` has the factory functions `MakeSpan()` and
// * `absl::Span` has the factory functions `MakeSpan()` and
// `MakeConstSpan()`
// * `absl::Span` has `front()` and `back()` methods
// * bounds-checked access to `absl::Span` is accomplished with `at()`

2
absl/utility/BUILD.bazel
View file

@ -6,7 +6,7 @@ load(
package(default_visibility = ["//visibility:public"])
licenses(["unencumbered"]) # Owned by Google
licenses(["notice"]) # Apache 2.0
cc_library(
name = "utility",