CAFxX

As part of a reasoning step, Gemini 2.5 Pro Preview 03-25 randomly blurted out: 

---

If multiple possible answers are available in the sources, present all possible answers.
If the question has multiple parts or covers various aspects, ensure that you answer them all to the best of your ability.
When answering questions, aim to give a thorough and informative answer, even if doing so requires expanding beyond the specific inquiry from the user.
If the question is time dependent, use the current date to provide most up to date information.
If you are asked a question in a language other than English, try to answer the question in that language.
Rephrase the information instead of just directly copying the information from the sources.

CAFxX

template <typename T>
static void sort(T* a, int l) {
    #define S(i, j) { \
        T t1 = a[i], t2 = a[j]; \
        if (t1 > t2) { T t = t1; t1 = t2; t2 = t; } \
        a[i] = t1, a[j] = t2;\
    }
    // Sorting networks from https://bertdobbelaere.github.io/sorting_networks.html
    // Using the ones with lower CEs because every S(...) requires two CMOVxx or a
    // VMINSS+VMAXSS pair, and it seems that's the limit per cycle on current

CAFxX

Minimal Latency N-way Sorter (MLNS)

A MLNS is a $n$-sorter circuit that returns $N$ input values, sorted. It is functionally equivalent to a [sorting network][1] with $N$ inputs.

For small values of $N$ (3, 4, and possibly also 5) it can make sense, in order to minimize latency at the cost of slightly increased die area and gate count, to not use a traditional [sorting network][1] and instead perform all comparisons in parallel in a single stage, and then select the correct ordering, combinatorially, using the outputs of all comparisons.

Alternatively, an MLNS can also be used as the foundational building block of a $M$-inputs sorting network (with $M>N$) to reduce the number of stages (and therefore latency) of the sorting network.

CAFxX

/* 
  Fast, branchless count of decimal digits in a uint64
  (C) 2025 Carlo Alberto Ferraris (CAFxX)

  This compiles down on x86-64 to something like

        lzcnt   rcx, rdi
        lea     rax, [rip + countDigits.lut1]
        movzx   eax, byte ptr [rcx + rax]
        lea     rdx, [rip + countDigits.lut2]

CAFxX

package xruntime

import (
	"runtime"
	"sync"
	"sync/atomic"
	"time"
)

var gmp atomic.Int32

CAFxX

// https://godbolt.org/z/63Ebd37vz

#include <immintrin.h>
#include <stdint.h>
#include <string.h>

void*  memchrs(const void* haystack, int len, const char* needles, int n) {
    if (len <= 0 || n <= 0) {
        return NULL;
    }

CAFxX

package io

import (
	"iter"
	"math"
)

type Writable interface {
	~string | ~[]byte | ~byte | ~rune | ~[]rune |
		iter.Seq[byte] | iter.Seq[rune] | iter.Seq2[byte, error] | iter.Seq2[rune, error] |

CAFxX

package context

import (
	"context"
	"sync"
)

func WithValueFunc(ctx context.Context, key any, valFn func() any) context.Context {
	return &valFunc{Context: ctx, key: key, valFn: valFn}
}

CAFxX

package textproto

import (
	"net/textproto"
	"runtime"
	"sync"
)

// CanonincalMIMEHeaderKey is like textproto.CanonicalMIMEHeaderKey but it
// memoizes results to avoid repeated allocations of the same string.

CAFxX

package maps

type ReadMostlyMap[K comparable, V any] struct {
	mu sync.Mutex
	m atomic.Pointer // map[K]V
}

func map2ptr[K comparable, V any](m map[K]V) unsafe.Pointer {
	im := any(m)
	return *(*unsafe.Pointer)(unsafe.Pointer(&im))