*Optimizing uint64_t Digit Counting: A New Method that Beats Lemire's by Up to 27%*

In the quest to improve the performance of my high-speed JSON library, JSONIFIER, I recently stumbled upon a breakthrough in optimizing the calculation of digit counts for `uint64_t` values. While Lemire’s method of using the `lzcnt` instruction for determining the number of digits in a 32-bit unsigned integer has been widely regarded as efficient, I’ve developed a new method that achieves even faster results for 64-bit unsigned integers (i.e., `uint64_t`), with significant gains across different compilers and platforms.

### The Existing Method: Lemire’s Approach

Lemire’s method, known for its efficiency, calculates the number of digits in a `uint32_t` by leveraging the `lzcnt` instruction, which finds the index of the most significant bit set to 1. This is combined with a static lookup table to map the result to the corresponding number of digits.

Here’s the code for Lemire’s method:

```cpp
JSONIFIER_INLINE int int_log2(uint32_t x) {
return 31 - simd_internal::lzcnt(x | 1);
}

JSONIFIER_INLINE int fast_digit_count(uint32_t x) {
static uint64_t table[] = { ... };
return (x + table[int_log2(x)]) >> 32;
}
```

While this approach works well for 32-bit integers, the need for a faster and more efficient solution for `uint64_t` led me to create an alternative method, which uses a more streamlined approach without the overhead of a lookup table.

### My New Method: RTC-64-Bit Digit Counting

I’ve designed a new approach for 64-bit unsigned integers that leverages a similar logic but optimizes the process by storing precomputed digit counts for specific ranges and applying simple threshold checks. The result is faster execution with reduced computational overhead.

Here's the code for the new method:

```cpp
JSONIFIER_INLINE_VARIABLE uint8_t digitCounts[]{ ... };

JSONIFIER_INLINE_VARIABLE uint64_t digitCountThresholds[]{ ... };

JSONIFIER_INLINE uint64_t fastDigitCount(const uint64_t inputValue) {
const uint64_t originalDigitCount{ digitCounts[simd_internal::lzcnt(inputValue)] };
return originalDigitCount + static_cast<uint64_t>(inputValue > digitCountThresholds[originalDigitCount]);
}
```

This method works by using a static array to hold the precomputed digit counts and another array for threshold values that determine the exact number of digits in a `uint64_t`. The key optimization lies in the efficient use of a bit manipulation technique and direct threshold checking to avoid unnecessary computations.

### [Benchmark Results](https://github.com/RealTimeChris/BenchmarkSuite/blob/digit-c...)

I ran performance benchmarks comparing my new RTC-64-bit method with Lemire’s approach and the traditional `log10` method across various platforms and compilers. The results were consistently impressive:

#### GCC/Ubuntu:
- *RTC-64-bit* outperforms *Lemire-32-bit* by *27.33%*.
- *Lemire-32-bit* beats *Log10-32-bit* by a massive *814.16%*.

#### Clang/Ubuntu:
- *RTC-64-bit* outperforms *Lemire-32-bit* by *143.34%*.
- *Lemire-32-bit* beats *Log10-32-bit* by *522.01%*.

#### MSVC/Windows:
- *RTC-64-bit* is *12.50%* faster than *Lemire-32-bit*.
- *Lemire-32-bit* beats *Log10-32-bit* by *515.90%*.

#### Clang/MacOS:
- *RTC-64-bit* is *25.37%* faster than *Lemire-32-bit*.
- *Lemire-32-bit* beats *Log10-32-bit* by *343.97%*.

### Key Takeaways

The RTC-64-bit method not only delivers improved performance on modern hardware but also significantly reduces the overhead of traditional methods by eliminating the need for a large lookup table. This is especially beneficial for high-performance applications where every cycle counts, such as in JSON serialization and parsing, where speed is critical.