[Feature Request / Optimization] Super-fast AVX2 SIMD alternative for `full_formatter` timestamps

[leagem]

Hi @gabime and spdlog maintainers,

I have designed and implemented a highly optimized AVX2 SIMD alternative for spdlog's full_formatter time-formatting logic (which produces patterns like [2026-07-14 12:34:56.789] ).

By utilizing vector addition and 64-bit integer packaging for subsecond volatility, it completely eliminates runtime branching, modulo/division calculations, and character-by-character memory copying during high-frequency microsecond/millisecond log formatting.

---

The Performance Pain Point in Current full_formatter

Currently, full_formatter relies on multiple append_int, pad2, and pad3 calls, which process each date/time digit sequentially. While the seconds part is cached, formatting the subseconds (milliseconds) and joining brackets/spaces requires multiple branches and memory stores.
In low-latency applications (e.g., high-frequency trading), these tiny operations at the log call-site easily degrade the CPU's Instruction-Level Parallelism (ILP).

Our SIMD (AVX2) Optimization Strategy

1. Branchless Single Vector Addition (_mm256_add_epi8)

Instead of formatting digits and selecting separators via branches or masking/blends, we pre-package a 32-byte SYMBOL_MASK containing ASCII base offsets '0' (48) for digit channels and raw ASCII values for symbols ([, -, :, ).
With our raw_digits aligned with zeroes at symbol channels, we do exactly one hardware instruction to simultaneously convert all digits to ASCII and format separators:

v_digits = raw_digits + SYMBOL_MASK

// Symbols: '[' (91), '-' (45), ' ' (32), ':' (58), '.' (46)
alignas(32) static constexpr uint8_t SYMBOL_MASK[32] = {
    91, 48, 48, 48, 48, 45, 48, 48, 45, 48, 48, 32, 48, 48, 58, 48, 48, 58, 48, 48, 46,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};

2. Subsecond & Bracket Packaging (Single 64-bit Store)

For the milliseconds and closing brackets ] , we don't call pad3. Instead, we package ., ms, ] and space into a single 64-bit integer on registers and execute one single uint64_t store into the tail buffer:

uint64_t tail_pack = ('0' + (msec / 100))
                   | (('0' + ((msec / 10) % 10)) << 8)
                   | (('0' + (msec % 10)) << 16)
                   | (static_cast<uint64_t>(']') << 24)
                   | (static_cast<uint64_t>(' ') << 32);

*reinterpret_cast<uint64_t*>(&time_buf[20]) = tail_pack;

---

Benchmark Results (Google Benchmark)

We ran the benchmark comparing the native formatting pipeline vs. our AVX2 optimization.

Note: In local benchmarking, MSVC's extremely heavy thread_local storage (TLS) lookup wrapper added ~4.3ns to the loops, but when testing the core conversion algorithm (No-TLS / localized pointer context), we saw true hardware-level performance.

Environment

• CPU: Intel i9-14900K
• Compiler (Linux): Clang -O3, -mavx2, -std=c++26

Test Case	Native spdlog	AVX2 SIMD Optimized	Speedup
Cache Hit (Same Sec)	0.683 ns	0.513 ns	~1.33x
Cache Miss (New Sec)	6.360 ns	3.140 ns	~2.02x

Here is the benchmark source code:
https://github.com/leagem/Test/blob/master/spdlog/bench_spdlog_time.cc

---

Proposed Integration Code in full_formatter

We can optionally enable this using macro guards (#if defined(__AVX2__)) so it gracefully falls back to the native portable implementation on other architectures (ARM/SVE can have its own neon implementation later):

#include <immintrin.h>

void format(const details::log_msg &msg, const std::tm &tm_time, memory_buf_t &dest) override {
    using std::chrono::duration_cast;
    using std::chrono::milliseconds;
    using std::chrono::seconds;

    auto duration = msg.time.time_since_epoch();
    auto secs = duration_cast<seconds>(duration);

#if defined(__AVX2__)
        alignas(32) static thread_local char time_buf[32];
        static thread_local seconds::rep last_s = -1;

        if (last_s != secs.count()) [[unlikely]] {
            last_s = secs.count();

            auto year = static_cast<int32_t>(tm_time.tm_year + 1900);
            auto month = static_cast<uint32_t>(tm_time.tm_mon + 1);
            auto day = static_cast<uint32_t>(tm_time.tm_mday);
            auto hour = static_cast<uint32_t>(tm_time.tm_hour);
            auto min = static_cast<uint32_t>(tm_time.tm_min);
            auto sec = static_cast<uint32_t>(tm_time.tm_sec);

            int32_t y_hi = year / 100;
            int32_t y_lo = year % 100;

            uint8_t raw_digits[32] = {0,  // '['
                                      static_cast<uint8_t>(y_hi / 10),
                                      static_cast<uint8_t>(y_hi % 10),
                                      static_cast<uint8_t>(y_lo / 10),
                                      static_cast<uint8_t>(y_lo % 10),
                                      0,  // '-'
                                      static_cast<uint8_t>(month / 10),
                                      static_cast<uint8_t>(month % 10),
                                      0,  // '-'
                                      static_cast<uint8_t>(day / 10),
                                      static_cast<uint8_t>(day % 10),
                                      0,  // ' '
                                      static_cast<uint8_t>(hour / 10),
                                      static_cast<uint8_t>(hour % 10),
                                      0,  // ':'
                                      static_cast<uint8_t>(min / 10),
                                      static_cast<uint8_t>(min % 10),
                                      0,  // ':'
                                      static_cast<uint8_t>(sec / 10),
                                      static_cast<uint8_t>(sec % 10),
                                      0,  // '.'
                                      0,
                                      0,
                                      0,
                                      0,
                                      0,
                                      0,
                                      0,
                                      0,
                                      0,
                                      0,
                                      0};

            __m256i v_digits = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(raw_digits));

            alignas(32) static constexpr uint8_t SYMBOL_MASK[32] = {91,  // '['
                                                                    48, 48, 48, 48,
                                                                    45,  // '-'
                                                                    48, 48,
                                                                    45,  // '-'
                                                                    48, 48,
                                                                    32,  // ' '
                                                                    48, 48,
                                                                    58,  // ':'
                                                                    48, 48,
                                                                    58,  // ':'
                                                                    48, 48,
                                                                    46,  // '.'
                                                                    0,  0,  0,  0,  0, 0,
                                                                    0,  0,  0,  0,  0};
            __m256i v_symbols = _mm256_load_si256(reinterpret_cast<const __m256i*>(SYMBOL_MASK));

            v_digits = _mm256_add_epi8(v_digits, v_symbols);
            _mm256_storeu_si256(reinterpret_cast<__m256i*>(time_buf), v_digits);
        }

        auto millis = fmt_helper::time_fraction<milliseconds>(msg.time);
        int msec = static_cast<int>(millis.count());

        uint64_t tail_pack = ('0' + (msec / 100)) | (('0' + ((msec / 10) % 10)) << 8) |
                             (('0' + (msec % 10)) << 16) | (static_cast<uint64_t>(']') << 24) |
                             (static_cast<uint64_t>(' ') << 32);

        *reinterpret_cast<uint64_t*>(&time_buf[21]) = tail_pack;
        dest.append(time_buf, time_buf + 26);
#else
    // Native fallback...
#endif

I would love to contribute this as a Pull Request. Please let me know what you think!

[gabime]

Thanks. That's cool.
However, all this just to get 0.170 ns of speedup per call ? Doesn't worth it imho

[leagem]

Haha true, just wanted to see how far I could push it. Happy to drop it if it hurts readability.

[gabime]

I think the bulk of improvment is the avoidance of the multiple push_back(char) and pad.. calls rather than the AVX. what would be the performance if we avoid the AVX and do something like

uint8_t digits[32] = {0,  // '['
                                      91 + static_cast<uint8_t>(y_hi / 10),
                                      48 + static_cast<uint8_t>(y_hi % 10),
                                      48 + static_cast<uint8_t>(y_lo / 10),
                                      48 + static_cast<uint8_t>(y_lo % 10),
                                      45,  // '-'
                                      48 + static_cast<uint8_t>(month / 10),
                                      48 + static_cast<uint8_t>(month % 10),
                                      45,  // '-'
                                      48 + static_cast<uint8_t>(day / 10),
                                      48 + static_cast<uint8_t>(day % 10),
                                      32,  // ' '
                                      48 + static_cast<uint8_t>(hour / 10),
                                      48 + static_cast<uint8_t>(hour % 10),
                                      32,  // ':'
                                      48 + static_cast<uint8_t>(min / 10),
                                      48 + static_cast<uint8_t>(min % 10),
                                      58,  // ':'
                                      48 + static_cast<uint8_t>(sec / 10),
                                      48 + static_cast<uint8_t>(sec % 10),
                                      46,  // '.'
                                      0,
                                      0,
                                      0,
                                      0,
                                      0,
                                      0,
                                      0,
                                      0,
                                      0,
                                      0,
                                      0};

…
// or even better change the cached_datetime_ member type to uint8[24] and update it directly and call at the end once
dest.append(cached_datetime, 24)

Also, why the TLS? No need. Can be a class member

[leagem]

// =====================================================================
// Spdlog PushBack
// =====================================================================
void FormatViaPushBack(const FakeLogMsg& msg, const std::tm& tm_time, FakeMemoryBuf& dest, std::chrono::seconds& cache_timestamp, FakeMemoryBuf& cached_datetime) {
    using std::chrono::duration_cast;
    using std::chrono::milliseconds;
    using std::chrono::seconds;

    auto duration = msg.time.time_since_epoch();
    auto secs = duration_cast<seconds>(duration);

    if (cache_timestamp != secs || cached_datetime.size_size == 0) {
        cached_datetime.clear();
        cached_datetime.push_back('[');
        fmt_helper::append_int(tm_time.tm_year + 1900, cached_datetime);
        cached_datetime.push_back('-');
        fmt_helper::pad2(tm_time.tm_mon + 1, cached_datetime);
        cached_datetime.push_back('-');
        fmt_helper::pad2(tm_time.tm_mday, cached_datetime);
        cached_datetime.push_back(' ');
        fmt_helper::pad2(tm_time.tm_hour, cached_datetime);
        cached_datetime.push_back(':');
        fmt_helper::pad2(tm_time.tm_min, cached_datetime);
        cached_datetime.push_back(':');
        fmt_helper::pad2(tm_time.tm_sec, cached_datetime);
        cached_datetime.push_back('.');
        cache_timestamp = secs;
    }
    dest.append(cached_datetime.data, cached_datetime.data + cached_datetime.size_size);

    auto sub_ms = duration_cast<milliseconds>(duration).count() % 1000;
    fmt_helper::pad3(static_cast<int>(sub_ms), dest);
    dest.push_back(']');
    dest.push_back(' ');
}

// =====================================================================
// AVX2
// =====================================================================
void FormatViaSIMD(const FakeLogMsg& msg, const std::tm& tm_time, FakeMemoryBuf& dest, int64_t& last_s, char* __restrict time_buf) {
    using std::chrono::duration_cast;
    using std::chrono::milliseconds;
    using std::chrono::seconds;

    auto duration = msg.time.time_since_epoch();
    auto secs = duration_cast<seconds>(duration);

    if (last_s != secs.count()) [[unlikely]] {
        last_s = secs.count();

        auto year = static_cast<int32_t>(tm_time.tm_year + 1900);
        auto month = static_cast<uint32_t>(tm_time.tm_mon + 1);
        auto day = static_cast<uint32_t>(tm_time.tm_mday);
        auto hour = static_cast<uint32_t>(tm_time.tm_hour);
        auto min = static_cast<uint32_t>(tm_time.tm_min);
        auto sec = static_cast<uint32_t>(tm_time.tm_sec);

        uint32_t y_hi = year / 100;
        uint32_t y_lo = year % 100;

        uint8_t raw_digits[32] = {
            0,
            static_cast<uint8_t>(y_hi / 10), static_cast<uint8_t>(y_hi % 10),
            static_cast<uint8_t>(y_lo / 10), static_cast<uint8_t>(y_lo % 10),
            0,
            static_cast<uint8_t>(month / 10), static_cast<uint8_t>(month % 10),
            0,
            static_cast<uint8_t>(day / 10), static_cast<uint8_t>(day % 10),
            0,
            static_cast<uint8_t>(hour / 10), static_cast<uint8_t>(hour % 10),
            0,
            static_cast<uint8_t>(min / 10), static_cast<uint8_t>(min % 10),
            0,
            static_cast<uint8_t>(sec / 10), static_cast<uint8_t>(sec % 10),
            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};

        __m256i v_digits = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(raw_digits));

        alignas(32) static constexpr uint8_t SYMBOL_MASK[32] = {
            91, 48, 48, 48, 48, 45, 48, 48, 45, 48, 48, 32, 48, 48, 58, 48, 48, 58, 48, 48, 46,
            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
        __m256i v_symbols = _mm256_load_si256(reinterpret_cast<const __m256i*>(SYMBOL_MASK));

        v_digits = _mm256_add_epi8(v_digits, v_symbols);
        _mm256_storeu_si256(reinterpret_cast<__m256i*>(time_buf), v_digits);
    }

    auto sub_ms = duration_cast<milliseconds>(duration).count() % 1000;

    uint64_t tail_pack = ('0' + (sub_ms / 100))
                       | (('0' + ((sub_ms / 10) % 10)) << 8)
                       | (('0' + (sub_ms % 10)) << 16)
                       | (static_cast<uint64_t>(']') << 24)
                       | (static_cast<uint64_t>(' ') << 32);

    *reinterpret_cast<uint64_t*>(&time_buf[21]) = tail_pack;

    dest.append(time_buf, time_buf + 26);
}

// =====================================================================
// Array
// =====================================================================
void FormatViaFixedArray(const FakeLogMsg& msg, const std::tm& tm_time, FakeMemoryBuf& dest, int64_t& last_s, char* __restrict time_buf) {
    using std::chrono::duration_cast;
    using std::chrono::milliseconds;
    using std::chrono::seconds;

    auto duration = msg.time.time_since_epoch();
    auto secs = duration_cast<seconds>(duration);

    if (last_s != secs.count()) [[unlikely]] {
        last_s = secs.count();

        auto year = static_cast<int32_t>(tm_time.tm_year + 1900);
        auto month = static_cast<uint32_t>(tm_time.tm_mon + 1);
        auto day = static_cast<uint32_t>(tm_time.tm_mday);
        auto hour = static_cast<uint32_t>(tm_time.tm_hour);
        auto min = static_cast<uint32_t>(tm_time.tm_min);
        auto sec = static_cast<uint32_t>(tm_time.tm_sec);

        uint32_t y_hi = year / 100;
        uint32_t y_lo = year % 100;

        uint8_t raw_digits[24] = {
            '[',
            static_cast<uint8_t>('0' + (y_hi / 10)), static_cast<uint8_t>('0' + (y_hi % 10)),
            static_cast<uint8_t>('0' + (y_lo / 10)), static_cast<uint8_t>('0' + (y_lo % 10)),
            '-',
            static_cast<uint8_t>('0' + (month / 10)), static_cast<uint8_t>('0' + (month % 10)),
            '-',
            static_cast<uint8_t>('0' + (day / 10)), static_cast<uint8_t>('0' + (day % 10)),
            ' ',
            static_cast<uint8_t>('0' + (hour / 10)), static_cast<uint8_t>('0' + (hour % 10)),
            ':',
            static_cast<uint8_t>('0' + (min / 10)), static_cast<uint8_t>('0' + (min % 10)),
            ':',
            static_cast<uint8_t>('0' + (sec / 10)), static_cast<uint8_t>('0' + (sec % 10)),
            '.'};

        std::memcpy(time_buf, raw_digits, 21);
    }

    auto sub_ms = duration_cast<milliseconds>(duration).count() % 1000;

    uint32_t tail4 = ('0' + (sub_ms / 100))
                   | (('0' + ((sub_ms / 10) % 10)) << 8)
                   | (('0' + (sub_ms % 10)) << 16)
                   | (static_cast<uint32_t>(']') << 24);

    std::memcpy(&time_buf[21], &tail4, 4);
    time_buf[25] = ' ';

    // Performance decreases slightly.
    // uint64_t tail_pack = ('0' + (sub_ms / 100))
    //                    | (('0' + ((sub_ms / 10) % 10)) << 8)
    //                    | (('0' + (sub_ms % 10)) << 16)
    //                    | (static_cast<uint64_t>(']') << 24)
    //                    | (static_cast<uint64_t>(' ') << 32);
    // *reinterpret_cast<uint64_t*>(&time_buf[21]) = tail_pack;

    dest.append(time_buf, time_buf + 26);
}

// =====================================================================
// DirectWrite
// =====================================================================
void FormatViaDirectWrite(const FakeLogMsg& msg, const std::tm& tm_time, FakeMemoryBuf& dest, int64_t& last_s, char* __restrict time_buf) {
    using std::chrono::duration_cast;
    using std::chrono::milliseconds;
    using std::chrono::seconds;

    auto duration = msg.time.time_since_epoch();
    auto secs = duration_cast<seconds>(duration);

    if (last_s != secs.count()) [[unlikely]] {
        last_s = secs.count();

        auto year = static_cast<int32_t>(tm_time.tm_year + 1900);
        auto month = static_cast<uint32_t>(tm_time.tm_mon + 1);
        auto day = static_cast<uint32_t>(tm_time.tm_mday);
        auto hour = static_cast<uint32_t>(tm_time.tm_hour);
        auto min = static_cast<uint32_t>(tm_time.tm_min);
        auto sec = static_cast<uint32_t>(tm_time.tm_sec);

        uint32_t y_hi = year / 100;
        uint32_t y_lo = year % 100;

        time_buf[0] = '[';
        time_buf[1] = static_cast<char>('0' + (y_hi / 10));
        time_buf[2] = static_cast<char>('0' + (y_hi % 10));
        time_buf[3] = static_cast<char>('0' + (y_lo / 10));
        time_buf[4] = static_cast<char>('0' + (y_lo % 10));
        time_buf[5] = '-';
        time_buf[6] = static_cast<char>('0' + (month / 10));
        time_buf[7] = static_cast<char>('0' + (month % 10));
        time_buf[8] = '-';
        time_buf[9] = static_cast<char>('0' + (day / 10));
        time_buf[10] = static_cast<char>('0' + (day % 10));
        time_buf[11] = ' ';
        time_buf[12] = static_cast<char>('0' + (hour / 10));
        time_buf[13] = static_cast<char>('0' + (hour % 10));
        time_buf[14] = ':';
        time_buf[15] = static_cast<char>('0' + (min / 10));
        time_buf[16] = static_cast<char>('0' + (min % 10));
        time_buf[17] = ':';
        time_buf[18] = static_cast<char>('0' + (sec / 10));
        time_buf[19] = static_cast<char>('0' + (sec % 10));
        time_buf[20] = '.';
    }

    auto sub_ms = duration_cast<milliseconds>(duration).count() % 1000;

    uint32_t tail4 = ('0' + (sub_ms / 100))
                   | (('0' + ((sub_ms / 10) % 10)) << 8)
                   | (('0' + (sub_ms % 10)) << 16)
                   | (static_cast<uint32_t>(']') << 24);
    std::memcpy(&time_buf[21], &tail4, 4);
    time_buf[25] = ' ';

    // Performance decreases slightly.
    // uint64_t tail_pack = ('0' + (sub_ms / 100))
    //                    | (('0' + ((sub_ms / 10) % 10)) << 8)
    //                    | (('0' + (sub_ms % 10)) << 16)
    //                    | (static_cast<uint64_t>(']') << 24)
    //                    | (static_cast<uint64_t>(' ') << 32);
    // *reinterpret_cast<uint64_t*>(&time_buf[21]) = tail_pack;

    dest.append(time_buf, time_buf + 26);
}

Run on (16 X 3187.2 MHz CPU s)
CPU Caches:
  L1 Data 48 KiB (x8)
  L1 Instruction 32 KiB (x8)
  L2 Unified 2048 KiB (x8)
  L3 Unified 36864 KiB (x1)
Load Average: 0.59, 0.78, 0.59
***WARNING*** ASLR is enabled, the results may have unreproducible noise in them.
-------------------------------------------------------------------
Benchmark                         Time             CPU   Iterations
-------------------------------------------------------------------
BM_PushBack_CacheHit          0.685 ns        0.685 ns    988068731
BM_SIMD_CacheHit              0.520 ns        0.520 ns   1337690459
BM_FixedArray_CacheHit        0.676 ns        0.676 ns   1023294585
BM_DirectWrite_CacheHit       0.686 ns        0.686 ns    965870737
BM_PushBack_CacheMiss          6.44 ns         6.44 ns    105646218
BM_SIMD_CacheMiss              4.35 ns         4.35 ns    160799772
BM_FixedArray_CacheMiss        3.94 ns         3.94 ns    176932490
BM_DirectWrite_CacheMiss       3.97 ns         3.97 ns    177422524

CPU: Intel i9-14900K
Compiler (Linux): Clang -O3, -mavx2, -std=c++26

Here is the benchmark source code:
https://github.com/leagem/Test/blob/master/spdlog/bench_spdlog_time.cc

Given that spdlog is widely adopted in latency-critical environments (like high-frequency trading and low-latency servers), this SIMD optimization could provide a noticeable throughput bump on x86_64 architectures.

Would you be interested in taking a look at a Pull Request (PR) for this? I can easily guard it with preprocessor macros (e.g., #if defined(AVX2)) so it seamlessly falls back to standard pathways on non-supported platforms.

[gabime]

so BM_FixedArray_CacheMiss is the fastest when cache miss.. so no point in SIMD (even in cache hit. its almost same perfomsnce as BM_FixedArray_CachHit)

[leagem]

Hi @gabime,

I have run the comprehensive benchmarks for all potential pathways (PushBack, FixedArray, and AVX2 SIMD). The complete micro-benchmark logs and code variations are provided above for the community's reference.

I completely understand that spdlog prioritizes portability and maintainability over platform-specific hyper-optimizations. Feel free to use these metrics as a design reference for your own caching ideas, or feel free to close this issue if you prefer to keep the mainline codebase strictly scalar.

Thanks for the great library!

[gabime]

Thanks @leagem . These are very useful actually !