fastmap.go

//go:build go1.19
// +build go1.19

package di

import (
	"reflect"
	"sync"
	"sync/atomic"
	"unsafe"
)

// typeKey: address of reflect.Type – estable mientras el proceso viva.
// func typeKey(t reflect.Type) uintptr { return uintptr(unsafe.Pointer(t)) }

// typeKey devuelve la dirección interna (*rtype) de un reflect.Type.
// Go garantiza que dicho puntero no cambia en tiempo de ejecución.
func typeKey(t reflect.Type) uintptr {
	// La representación de una interface{} en memoria es [2]uintptr:
	// [0] = puntero al descriptor de tipo (itab/itab*), [1] = datos.
	return uintptr((*[2]uintptr)(unsafe.Pointer(&t))[1])
}

type entry struct{ v interface{} }

// safeMap = mapa inmutable con copia-en-escritura.
//   - Lecturas: 1 atomic + lookup => ~4-8 ns.
//   - Escrituras: copia bajo mutex; los lectores nunca se bloquean.
type safeMap struct {
	data atomic.Value // map[uintptr]entry
	mu   sync.Mutex   // serializa Stores
}

func newSafeMap() *safeMap {
	m := &safeMap{}
	m.data.Store(make(map[uintptr]entry))
	return m
}

func (m *safeMap) Load(k uintptr) (e entry, ok bool) {
	e, ok = m.data.Load().(map[uintptr]entry)[k]
	return
}

func (m *safeMap) Store(k uintptr, e entry) {
	m.mu.Lock()
	old := m.data.Load().(map[uintptr]entry)

	if prev, ok := old[k]; ok && prev == e {
		m.mu.Unlock()
		return // sin trabajo
	}

	clone := make(map[uintptr]entry, len(old)+1)
	for k0, v := range old {
		clone[k0] = v
	}
	clone[k] = e
	m.data.Store(clone)
	m.mu.Unlock()
}

func (m *safeMap) Range(fn func(entry) bool) {
	for _, v := range m.data.Load().(map[uintptr]entry) {
		if !fn(v) {
			return
		}
	}
}