CAFxX

📂 Minimize allocations in Go

A collection of tips for when you need to minimize the number of allocations in your Go programs.

Use the go profiler to identify which parts of your program are responsible for most allocations.

⚠️ Never apply these tricks blindly (i.e. without measuring the actual performance benefit/impact). Most of these tricks cause a tradeoff between reducing memory allocations and other aspects (including e.g. higher peak memory usage, higher CPU usage, lower maintainability, higher probability of introducing subtle bugs). Only apply these tricks if the tradeoff in every specfic case is globally positive.

Protobuf

CAFxX

This document lists ISA or processor implementation wishlists/ideas.

They are mostly random ideas; they are not reviewed, guaranteed to work, or even just make sense, but at some point I had good use cases for each one of them.

Third party wishlists

ISA wishlists found elsewhere.

• y-cruncher Technology Wishlist - ISA
• Lockless Inc. X86 Instruction Wishlist

CAFxX

Language/syntax

Shorthand error definition

Instead of things like var ErrFoo = errors.New("foo") or return fmt.Errorf("foo: %d", n) I would like a shorthand syntax that allows to define a new error type.

Simple error

CAFxX

📂 Persistent "pipes" in Linux

In a project I'm working on I ran into the requirement of having some sort of persistent FIFO buffer or pipe in Linux, i.e. something file-like that could accept writes from a process and persist it to disk until a second process reads (and acknowledges) it. The persistence should be both across process restarts as well as OS restarts.

AFAICT unfortunately in the Linux world such a primitive does not exist (named pipes/FIFOs do not persist

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 batchgetter

type Getter[I, T any] interface {
  Get(context.Context, []I) ([]T, error)
}

type BatchGetter[I, T any] struct {
  parent Getter[I, T]
  batchWait time.Duration
  

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))

CAFxX

CAFxX

Suppose you have a type that needs explicit destruction to release resources:

type MyType struct {
  ...
}

func New() *MyType {
  // acquire resources...
  

CAFxX

Verifying that I control the following Nostr public key: npub1j67s9mwffj6ue909esy4ldyhte9xheu5nh2lwed2qycqfdmfjmuq40chpa