maurice/snix
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Export of internal Abseil changes

Browse source 
--
a9ac6567c0933d786d68c10011e3f3ff9deedf89 by Greg Falcon <gfalcon@google.com>:

Add absl::FunctionRef, a type analogous to the proposed C++23 std::function_ref.

Like std::function, FunctionRef can be used to type-erase any callable (invokable) object.  However, FunctionRef works by reference: it does not store a copy of the type-erased object.  If the wrapped object is destroyed before the FunctionRef, the reference becomes dangling.

FunctionRef relates to std::function in much the same way that string_view relates to std::string.

Because of these limitations, FunctionRef is best used only as a function argument type, and only where the function will be invoked immediately (rather than saved for later use).  When `const std::function<...>&` is used in this way, `absl::FunctionRef<...>` is a better-performing replacement.

PiperOrigin-RevId: 275484044

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

Add FastHexToBufferZeroPad16() function for blazingly fast hex encoding of uint64_t.

PiperOrigin-RevId: 275420901

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

Avoid applying the workaround for MSVC's static initialization problems when using clang-cl.

PiperOrigin-RevId: 275366326

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

Added comments to SimpleAtof()/SimpleAtod() that clarify that they
always use the "C" locale, unlike the standard functions strtod()
and strtof() referenced now in the comments.

PiperOrigin-RevId: 275355815

--
086779dacb3f6f2b3ab59947e94e79046bdb1fe1 by Jorg Brown <jorg@google.com>:

Move the hex conversion table used by escaping.cc into numbers.h so
that other parts of Abseil can more efficiently access it.

PiperOrigin-RevId: 275331251

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

Avoid applying the workaround for MSVC's static initialization problems when using clang-cl.

PiperOrigin-RevId: 275323858

--
56ceb58ab688c3761978308609b09a1ac2739c9a by Derek Mauro <dmauro@google.com>:

Add script for testing on Alpine Linux (for musl test coverage)

PiperOrigin-RevId: 275321244
GitOrigin-RevId: a9ac6567c0933d786d68c10011e3f3ff9deedf89
Change-Id: I39799fa03768ddb44f3166200c860e1da4461807
This commit is contained in:
Abseil Team 2019-10-18 09:06:29 -07:00 • committed by Andy Soffer
parent a15364ce4d
commit e4c8d0eb8e
15 changed files with 887 additions and 40 deletions
Download patch file Download diff file Expand all files Collapse all files

45
absl/strings/numbers.h
View file

@ -24,6 +24,10 @@
#ifndef ABSL_STRINGS_NUMBERS_H_
#define ABSL_STRINGS_NUMBERS_H_
#ifdef __SSE4_2__
#include <x86intrin.h>
#endif
#include <cstddef>
#include <cstdlib>
#include <cstring>
@ -32,6 +36,8 @@
#include <string>
#include <type_traits>
#include "absl/base/internal/bits.h"
#include "absl/base/internal/endian.h"
#include "absl/base/macros.h"
#include "absl/base/port.h"
#include "absl/numeric/int128.h"
@ -54,7 +60,8 @@ ABSL_MUST_USE_RESULT bool SimpleAtoi(absl::string_view str, int_type* out);
// Converts the given string (optionally followed or preceded by ASCII
// whitespace) into a float, which may be rounded on overflow or underflow.
// See https://en.cppreference.com/w/c/string/byte/strtof for details about the
// allowed formats for `str`. If any errors are encountered, this function
// allowed formats for `str`, except SimpleAtof() is locale-indepdent and will
// always use the "C" locale. If any errors are encountered, this function
// returns `false`, leaving `out` in an unspecified state.
ABSL_MUST_USE_RESULT bool SimpleAtof(absl::string_view str, float* out);
@ -63,7 +70,8 @@ ABSL_MUST_USE_RESULT bool SimpleAtof(absl::string_view str, float* out);
// Converts the given string (optionally followed or preceded by ASCII
// whitespace) into a double, which may be rounded on overflow or underflow.
// See https://en.cppreference.com/w/c/string/byte/strtof for details about the
// allowed formats for `str`. If any errors are encountered, this function
// allowed formats for `str`, except SimpleAtod is locale-independent and will
// always use the "C" locale. If any errors are encountered, this function
// returns `false`, leaving `out` in an unspecified state.
ABSL_MUST_USE_RESULT bool SimpleAtod(absl::string_view str, double* out);
@ -84,6 +92,10 @@ ABSL_MUST_USE_RESULT bool SimpleAtob(absl::string_view str, bool* out);
namespace absl {
namespace numbers_internal {
// Digit conversion.
extern const char kHexChar[17]; // 0123456789abcdef
extern const char kHexTable[513]; // 000102030405060708090a0b0c0d0e0f1011...
// safe_strto?() functions for implementing SimpleAtoi()
bool safe_strto32_base(absl::string_view text, int32_t* value, int base);
bool safe_strto64_base(absl::string_view text, int64_t* value, int base);
@ -170,6 +182,35 @@ ABSL_MUST_USE_RESULT bool safe_strtoi_base(absl::string_view s, int_type* out,
return parsed;
}
// FastHexToBufferZeroPad16()
//
// Outputs `val` into `out` as if by `snprintf(out, 17, "%016x", val)` but
// without the terminating null character. Thus `out` must be of length >= 16.
// Returns the number of non-pad digits of the output (it can never be zero
// since 0 has one digit).
inline size_t FastHexToBufferZeroPad16(uint64_t val, char* out) {
uint64_t be = absl::big_endian::FromHost64(val);
#ifdef __SSE4_2__
const auto kNibbleMask = _mm_set1_epi8(0xf);
const auto kHexDigits = _mm_setr_epi8('0', '1', '2', '3', '4', '5', '6', '7',
'8', '9', 'a', 'b', 'c', 'd', 'e', 'f');
auto v = _mm_loadu_si64(reinterpret_cast<__m128i*>(&be)); // load lo dword
auto v4 = _mm_srli_epi64(v, 4); // shift 4 right
auto il = _mm_unpacklo_epi8(v4, v); // interleave bytes
auto m = _mm_and_si128(il, kNibbleMask); // mask out nibbles
auto hexchars = _mm_shuffle_epi8(kHexDigits, m); // hex chars
_mm_storeu_si128(reinterpret_cast<__m128i*>(out), hexchars);
#else
for (int i = 0; i < 8; ++i) {
auto byte = (be >> (8 * i)) & 0xFF;
auto* hex = &absl::numbers_internal::kHexTable[byte * 2];
std::memcpy(out + 2 * i, hex, 2);
}
#endif
// | 0x1 so that even 0 has 1 digit.
return 16 - absl::base_internal::CountLeadingZeros64(val | 0x1) / 4;
}
} // namespace numbers_internal
// SimpleAtoi()