Carlo Alberto Ferraris CAFxX

Notes for a proposal to add per-session and/or per-transaction commit delay to postgresql.

Per session/transaction commit delay

Currently postgres has the commit_delay and commit_sibling global configurations.

To better support mixed workloads it would be significantly easier if a bit more flexibility was permitted, e.g. by allowing individual sessions or transactions to specify different acceptable commit delays, while still providing all required guarantees.

Proposal

Transparent heap object reuse for Go

a.k.a. have most hot allocation paths be transparently served by dedicated freelists managed by the compiler and runtime

Important

This document is a work in progress. Early feedback and discussions are welcome.

Known TODOs:

How to handle slices

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.

	// https://go.dev/play/p/374e3zUuZmE

	package main

	import (
	"crypto/rand"
	"flag"
	"fmt"
	"maps"
	"math/big"

	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.

	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

	/*
	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]

	package xruntime

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

	var gmp atomic.Int32

	// 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;
	}

	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] \|