Artifact [46b98f1a74]

Artifact 46b98f1a74a6c2600aa77f47a95385b1c94854e9f74c1b6855f4c57db699d56f:

• File internal/content/export_test.go — part of check-in [e690ff7ad2] at 2026-10-29 12:46:27 on branch perf/463-memo-trees — test(content): measure the memo's trees after a full read and over all history

  The corpus test timed horizons cold and warm, but not the case HZ-6.2-10 left open: a full read of the store (an arrival a held artifact cited) dropped every tree the memo had read. It now times a horizon again after one, and a second test walks the whole history to report what keeping every tree costs in heap and time. (user: [email protected], size: 2164) [annotate] [blame] [check-ins using]

package content

import (
	"context"
	"maps"
	"slices"

	"github.com/danmestas/go-libfossil/db"
)

// LoadAbsencesWithin is LoadAbsencesContext under injected budgets, and
// reports what classification read. The tests that use it are an external
// package: their fixtures need the manifest writer, which imports this one.
func LoadAbsencesWithin(
	ctx context.Context, q db.Querier, refs ReferenceBudget, treePerCheckin int64,
) (*Absences, ReferenceWork, error) {
	treeMax := treePerCheckin << 10
	if treeMax > defaultReferenceLimits.treeMax {
		treeMax = defaultReferenceLimits.treeMax
	}
	a, err := loadAbsences(ctx, q, referenceLimits{
		refs: refs, treePerCheckin: treePerCheckin, treeMax: treeMax,
	})
	if a == nil {
		return nil, ReferenceWork{}, err
	}
	return a, a.work, err
}

// LoadAbsencesWork is LoadAbsencesContext, reporting what classification
// read under the default budgets.
func LoadAbsencesWork(ctx context.Context, q db.Querier) (*Absences, ReferenceWork, error) {
	limits := defaultReferenceLimits
	return LoadAbsencesWithin(ctx, q, limits.refs, limits.treePerCheckin)
}

// TreesRead names the trees v's horizon walks read from the store, and
// counts the reads.
func (v *MemoView) TreesRead() (names []string, reads int) {
	return slices.Collect(maps.Keys(v.trees)), v.treeReads
}

// TreeBytes is what m charges for the trees it keeps.
func (m *Memo) TreeBytes() int64 {
	m.mu.Lock()
	defer m.mu.Unlock()
	if m.trees == nil {
		return 0
	}
	return m.trees.bytes
}

// LimitTrees sets the most m keeps of its walks' trees.
func (m *Memo) LimitTrees(bytes int64) {
	m.mu.Lock()
	defer m.mu.Unlock()
	m.treeLimit = bytes
}

// TreeChainDepth is the most set differences any tree m keeps lies from
// one kept whole.
func (m *Memo) TreeChainDepth() int {
	m.mu.Lock()
	defer m.mu.Unlock()
	depth := 0
	if m.trees != nil {
		for _, p := range m.trees.pieces {
			depth = max(depth, p.depth)
		}
	}
	return depth
}

// ForgetStore makes m's next view read its store in full, as one does after
// an arrival a held artifact cited, keeping what else m holds.
func (m *Memo) ForgetStore() {
	m.mu.Lock()
	defer m.mu.Unlock()
	m.store = nil
}