kaizen: Embed smalltable

anything_but.go

@@ -70,12 +70,12 @@ func readAnythingButSpecial(pb *patternBuild, valsIn []typedVal) (pathVals []typ
 // Making a succession of anything-but automata for each of "a" and "b" and then merging them turns out not
 // to work because what the caller means is really an AND - everything that matches neither "a" nor "b". So
 // in principle we could intersect automata.
-func makeMultiAnythingButFA(vals [][]byte) (*smallTable, *fieldMatcher) {
+func makeMultiAnythingButFA(vals [][]byte) (*faState, *fieldMatcher) {
 	nextField := newFieldMatcher()
 	success := &faState{table: newSmallTable(), fieldTransitions: []*fieldMatcher{nextField}}
 
-	ret, _ := makeOneMultiAnythingButStep(vals, 0, success), nextField
-	return ret, nextField
+	startTable := makeOneMultiAnythingButStep(vals, 0, success)
+	return &faState{table: startTable}, nextField
 }
 
 // makeOneMultiAnythingButStep - spookeh. The idea is that there will be N smallTables in this FA, where N is
@@ -84,7 +84,7 @@ func makeMultiAnythingButFA(vals [][]byte) (*smallTable, *fieldMatcher) {
 // yet been exhausted. We notice when we get to the end of each val and put in a valueTerminator transition
 // to a step with no nextField entry, i.e. failure because we've exactly matched one of the anything-but
 // strings.
-func makeOneMultiAnythingButStep(vals [][]byte, index int, success *faState) *smallTable {
+func makeOneMultiAnythingButStep(vals [][]byte, index int, success *faState) smallTable {
 	// this will be the default transition in all the anything-but tables.
 	var u unpackedTable
 	for i := range u {

core_matcher.go

@@ -25,6 +25,11 @@ import (
 type coreMatcher struct {
 	updateable atomic.Pointer[coreFields]
 	lock       sync.Mutex
+	// closureBufs is scratch for epsilon-closure computation, reused across
+	// every AddPattern. addPattern holds lock for the whole build, so it is
+	// never accessed concurrently. Lives here (not a sync.Pool) so the maps are
+	// never evicted mid-build; see epsilonClosureInto.
+	closureBufs *closureBuffers
 }
 
 // coreFields groups the updateable fields in coreMatcher.
@@ -38,7 +43,7 @@ type coreFields struct {
 }
 
 func newCoreMatcher() *coreMatcher {
-	m := coreMatcher{}
+	m := coreMatcher{closureBufs: newClosureBuffers()}
 	m.updateable.Store(&coreFields{
 		state:        newFieldMatcher(),
 		segmentsTree: newSegmentsIndex(),
@@ -71,6 +76,10 @@ func (m *coreMatcher) addPatternWithPrinter(x X, patternJSON string, printer pri
 	m.lock.Lock()
 	defer m.lock.Unlock()
 
+	// Reuse the closure scratch but empty it each build so its maps hold only
+	// this pattern's working set, not every state in the matcher.
+	m.closureBufs.reset()
+
 	// we build up the new coreMatcher state in freshStart so that we can atomically switch it in once complete
 
 	freshStart := &coreFields{}
@@ -105,7 +114,7 @@ func (m *coreMatcher) addPatternWithPrinter(x X, patternJSON string, printer pri
 			case existsFalseType:
 				ns = state.addExists(false, field)
 			default:
-				ns = state.addTransition(field, printer)
+				ns = state.addTransition(field, printer, m.closureBufs)
 			}
 			nextStates = append(nextStates, ns...)
 		}

core_matcher_test.go

@@ -330,8 +330,8 @@ func TestSimpleaddPattern(t *testing.T) {
 // which means the finite automata are hidden deep inside the coreMatcher instance
 // and hard to get at.  This helper routine fetches the value-matcher automaton
 // corresponding to the "path" argument
-func fetchFAForPath(t *testing.T, cm *coreMatcher, path string) *smallTable {
+func fetchFAForPath(t *testing.T, cm *coreMatcher, path string) *faState {
 	t.Helper()
 	vm := cm.fields().state.fields().transitions[path]
-	return vm.fields().startTable
+	return vm.fields().start
 }

dedup_key.go

@@ -0,0 +1,31 @@
+package quamina
+
+import "unsafe"
+
+// tableShareKey returns a stable identifier for a smallTable's "share group".
+// Two states whose smallTables hold slice-headers pointing at the same `steps`
+// backing array (which is what happens when one smallTable struct value is
+// copied into multiple faStates during construction) will produce equal
+// keys. This replaces *smallTable-pointer identity as the dedup key in
+// epsilon-closure computation after smallTable is embedded into faState
+// by value.
+//
+// The key is just the steps backing-array pointer: share groups are only ever
+// born by copying a whole steps slice-header (see the spinner merges in
+// nfa.go), so two tables that share the data pointer always share the length
+// too — nothing in the package reslices steps. Pointer identity is therefore
+// sufficient to identify a share group; carrying the length as well would
+// never break a tie the pointer didn't already break.
+//
+// A zero key (nil pointer) means "no share group" — used for tables with no
+// byte transitions. Callers that want to dedup such tables should skip the
+// zero key.
+type tableShareKey struct {
+	stepsData unsafe.Pointer
+}
+
+func newTableShareKey(t *smallTable) tableShareKey {
+	return tableShareKey{
+		stepsData: unsafe.Pointer(unsafe.SliceData(t.steps)),
+	}
+}

dedup_key_test.go

@@ -0,0 +1,57 @@
+package quamina
+
+import (
+	"testing"
+)
+
+func TestTableShareKey_SharedBackings(t *testing.T) {
+	// Construct one smallTable, value-copy it (simulating post-embed share).
+	src := smallTable{
+		ceilings: []byte{'a', 'b', byte(byteCeiling)},
+		steps:    []*faState{nil, nil, nil},
+	}
+	copy1 := src
+	copy2 := src
+	if newTableShareKey(&copy1) != newTableShareKey(&copy2) {
+		t.Errorf("value-copied tables should share key; got %v vs %v",
+			newTableShareKey(&copy1), newTableShareKey(&copy2))
+	}
+}
+
+func TestTableShareKey_DistinctBackings(t *testing.T) {
+	t1 := smallTable{
+		ceilings: []byte{'a', byte(byteCeiling)},
+		steps:    []*faState{nil, nil},
+	}
+	t2 := smallTable{
+		ceilings: []byte{'a', byte(byteCeiling)},
+		steps:    []*faState{nil, nil},
+	}
+	if newTableShareKey(&t1) == newTableShareKey(&t2) {
+		t.Errorf("independently-built tables should not share key")
+	}
+}
+
+// TestTableShareKey_AppendBreaksShare verifies that when a value-copy
+// is mutated via append in a way that reallocates the backing array,
+// the keys diverge. We force reallocation by starting at cap=1 and
+// appending many entries.
+func TestTableShareKey_AppendBreaksShare(t *testing.T) {
+	src := smallTable{
+		ceilings: make([]byte, 0, 1),
+		steps:    make([]*faState, 0, 1),
+	}
+	src.ceilings = append(src.ceilings, byte(byteCeiling))
+	src.steps = append(src.steps, nil)
+	copy1 := src
+	// Appending 8 entries to a slice with cap=1 guarantees at least one
+	// realloc of the steps backing.
+	for i := 0; i < 8; i++ {
+		copy1.steps = append(copy1.steps, nil)
+		copy1.ceilings = append(copy1.ceilings, byte(i))
+	}
+	if newTableShareKey(&src) == newTableShareKey(&copy1) {
+		t.Errorf("expected keys to diverge after append-with-realloc; got equal: %v",
+			newTableShareKey(&src))
+	}
+}