/* * Copyright (c) Meta Platforms, Inc. and affiliates. * * 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. */ #pragma once #include <cstring> #include <folly/ConstexprMath.h> #include <folly/Likely.h> #include <folly/Portability.h> #include <folly/Utility.h> #include <folly/lang/Align.h> #include <folly/lang/CArray.h> #include <folly/portability/Builtins.h> namespace folly { // to_ascii_alphabet // // Used implicity by to_ascii_lower and to_ascii_upper below. // // This alphabet translates digits to 0-9,a-z or 0-9,A-Z. The largest supported // base is 36; operator() presumes an argument less than that. // // Alternative alphabets may be used with to_ascii_with provided they match // the constructibility/destructibility and the interface of this one. template <bool Upper> struct to_ascii_alphabet { … }; to_ascii_alphabet_lower; to_ascii_alphabet_upper; namespace detail { template <uint64_t Base, typename Alphabet> struct to_ascii_array { … }; template <uint64_t Base, typename Alphabet> alignas(kIsMobile ? sizeof(size_t) : hardware_constructive_interference_size) typename to_ascii_array<Base, Alphabet>::data_type_ const to_ascii_array<Base, Alphabet>::data = …; extern template to_ascii_array<8, to_ascii_alphabet_lower>::data_type_ const to_ascii_array<8, to_ascii_alphabet_lower>::data; extern template to_ascii_array<10, to_ascii_alphabet_lower>::data_type_ const to_ascii_array<10, to_ascii_alphabet_lower>::data; extern template to_ascii_array<16, to_ascii_alphabet_lower>::data_type_ const to_ascii_array<16, to_ascii_alphabet_lower>::data; extern template to_ascii_array<8, to_ascii_alphabet_upper>::data_type_ const to_ascii_array<8, to_ascii_alphabet_upper>::data; extern template to_ascii_array<10, to_ascii_alphabet_upper>::data_type_ const to_ascii_array<10, to_ascii_alphabet_upper>::data; extern template to_ascii_array<16, to_ascii_alphabet_upper>::data_type_ const to_ascii_array<16, to_ascii_alphabet_upper>::data; template <uint64_t Base, typename Alphabet> struct to_ascii_table { … }; template <uint64_t Base, typename Alphabet> alignas(hardware_constructive_interference_size) typename to_ascii_table<Base, Alphabet>::data_type_ const to_ascii_table<Base, Alphabet>::data = …; extern template to_ascii_table<8, to_ascii_alphabet_lower>::data_type_ const to_ascii_table<8, to_ascii_alphabet_lower>::data; extern template to_ascii_table<10, to_ascii_alphabet_lower>::data_type_ const to_ascii_table<10, to_ascii_alphabet_lower>::data; extern template to_ascii_table<16, to_ascii_alphabet_lower>::data_type_ const to_ascii_table<16, to_ascii_alphabet_lower>::data; extern template to_ascii_table<8, to_ascii_alphabet_upper>::data_type_ const to_ascii_table<8, to_ascii_alphabet_upper>::data; extern template to_ascii_table<10, to_ascii_alphabet_upper>::data_type_ const to_ascii_table<10, to_ascii_alphabet_upper>::data; extern template to_ascii_table<16, to_ascii_alphabet_upper>::data_type_ const to_ascii_table<16, to_ascii_alphabet_upper>::data; template <uint64_t Base, typename Int> struct to_ascii_powers { … }; template <uint64_t Base, typename Int> alignas(hardware_constructive_interference_size) typename to_ascii_powers<Base, Int>::data_type_ const to_ascii_powers<Base, Int>::data = …; extern template to_ascii_powers<8, uint64_t>::data_type_ const to_ascii_powers<8, uint64_t>::data; extern template to_ascii_powers<10, uint64_t>::data_type_ const to_ascii_powers<10, uint64_t>::data; extern template to_ascii_powers<16, uint64_t>::data_type_ const to_ascii_powers<16, uint64_t>::data; template <uint64_t Base> FOLLY_ALWAYS_INLINE size_t to_ascii_size_imuls(uint64_t v) { … } template <uint64_t Base> FOLLY_ALWAYS_INLINE size_t to_ascii_size_idivs(uint64_t v) { … } template <uint64_t Base> FOLLY_ALWAYS_INLINE size_t to_ascii_size_array(uint64_t v) { … } // For some architectures, we can get a little help from clzll, the "count // leading zeros" builtin, which is backed by a single performant instruction. // // Note that the compiler implements __builtin_clzll on all architectures, but // only emits a single clzll instruction when the architecture has one. // // This implementation may be faster than the basic ones in the general case // because the time taken to compute this one is constant for non-zero v, // whereas the basic ones take time proportional to log<2>(v). Whether this one // is actually faster depends on the emitted code for this implementation and // on whether the loops in the basic implementations are unrolled. template <uint64_t Base> FOLLY_ALWAYS_INLINE size_t to_ascii_size_clzll(uint64_t v) { … } template <uint64_t Base> FOLLY_ALWAYS_INLINE size_t to_ascii_size_route(uint64_t v) { … } // The straightforward implementation, assuming the size known in advance. // // The straightforward implementation without the size known in advance would // entail emitting the bytes backward and then reversing them at the end, once // the size is known. template <uint64_t Base, typename Alphabet> FOLLY_ALWAYS_INLINE void to_ascii_with_basic( char* out, size_t size, uint64_t v) { … } // A variant of the straightforward implementation, but using a lookup table. template <uint64_t Base, typename Alphabet> FOLLY_ALWAYS_INLINE void to_ascii_with_array( char* out, size_t size, uint64_t v) { … } // A trickier implementation which performs half as many divides as the other, // more straightforward, implementation. On modern hardware, the divides are // the bottleneck (even when the compiler emits a complicated sequence of add, // sub, and mul instructions with special constants to simulate a divide by a // fixed denominator). // // The downside of this implementation is that the emitted code is larger, // especially when the divide is simulated, which affects inlining decisions. template <uint64_t Base, typename Alphabet> FOLLY_ALWAYS_INLINE void to_ascii_with_table( char* out, size_t size, uint64_t v) { … } template <uint64_t Base, typename Alphabet> FOLLY_ALWAYS_INLINE size_t to_ascii_with_table(char* out, uint64_t v) { … } // Assumes that size >= number of digits in v. If >, the result is left-padded // with 0s. template <uint64_t Base, typename Alphabet> FOLLY_ALWAYS_INLINE void to_ascii_with_route( char* outb, size_t size, uint64_t v) { … } template <uint64_t Base, typename Alphabet> FOLLY_ALWAYS_INLINE size_t to_ascii_with_route(char* outb, char const* oute, uint64_t v) { … } template <uint64_t Base, typename Alphabet, size_t N> FOLLY_ALWAYS_INLINE size_t to_ascii_with_route(char (&out)[N], uint64_t v) { … } } // namespace detail // to_ascii_size_max // // The maximum size buffer that might be required to hold the ascii-encoded // representation of any value of unsigned type I in base Base. // // In base 10, u64 requires at most 20 bytes, u32 at most 10, u16 at most 5, // and u8 at most 3. to_ascii_size_max; // to_ascii_size_max_decimal // // An alias to to_ascii_size_max<10>. to_ascii_size_max_decimal; // to_ascii_size // // Returns the number of digits in the base Base representation of a uint64_t. // Useful for preallocating buffers, etc. // // async-signal-safe template <uint64_t Base> size_t to_ascii_size(uint64_t v) { … } // to_ascii_size_decimal // // An alias to to_ascii_size<10>. // // async-signal-safe inline size_t to_ascii_size_decimal(uint64_t v) { … } // to_ascii_with // // Copies the digits of v, in base Base, translated with Alphabet, into buffer // and returns the number of bytes written. // // Does *not* append a null terminator. It is the caller's responsibility to // append a null terminator if one is required. // // Assumes buffer points to at least to_ascii_size<Base>(v) bytes of writable // memory. It is the caller's responsibility to provide a writable buffer with // the required min size. // // async-signal-safe template <uint64_t Base, typename Alphabet> size_t to_ascii_with(char* outb, char const* oute, uint64_t v) { … } template <uint64_t Base, typename Alphabet, size_t N> size_t to_ascii_with(char (&out)[N], uint64_t v) { … } // to_ascii_lower // // Composes to_ascii_with with to_ascii_alphabet_lower. // // async-signal-safe template <uint64_t Base> size_t to_ascii_lower(char* outb, char const* oute, uint64_t v) { … } template <uint64_t Base, size_t N> size_t to_ascii_lower(char (&out)[N], uint64_t v) { … } // to_ascii_upper // // Composes to_ascii_with with to_ascii_alphabet_upper. // // async-signal-safe template <uint64_t Base> size_t to_ascii_upper(char* outb, char const* oute, uint64_t v) { … } template <uint64_t Base, size_t N> size_t to_ascii_upper(char (&out)[N], uint64_t v) { … } // to_ascii_decimal // // An alias to to_ascii<10, false>. // // async-signal-safe inline size_t to_ascii_decimal(char* outb, char const* oute, uint64_t v) { … } template <size_t N> inline size_t to_ascii_decimal(char (&out)[N], uint64_t v) { … } } // namespace folly
Codebase Browser
folly