Optimize memory allocations for sites matrix vector stores

By

* Caching common sites matrix setups (e.g. the single site in single site setups).
* Adding a fast path to IntSets.HasAnyVector for the common case of single vector input.

```
AssembleDeepSiteWithManySections/depth=3/sectionsPerLevel=2/pagesPerSection=100-10   31.62m ± 46%   30.68m ± 42%  ~ (p=0.310 n=6)

                                                                                   │ master.bench │          perfcommon.bench          │
                                                                                   │     B/op     │     B/op      vs base              │
AssembleDeepSiteWithManySections/depth=3/sectionsPerLevel=2/pagesPerSection=100-10   31.98Mi ± 0%   31.24Mi ± 0%  -2.30% (p=0.002 n=6)

                                                                                   │ master.bench │         perfcommon.bench          │
                                                                                   │  allocs/op   │  allocs/op   vs base              │
AssembleDeepSiteWithManySections/depth=3/sectionsPerLevel=2/pagesPerSection=100-10    460.9k ± 0%   419.9k ± 0%  -8.90% (p=0.002 n=6)
````

Author: bep

common/paths/pathparser.go

@@ -54,7 +54,7 @@ type PathParser struct {
 
 	// Below gets created on demand.
 	initOnce         sync.Once
-	sitesMatrixCache *maps.Cache[string, sitesmatrix.VectorStore] // Maps language code to sites matrix vector store.
+	sitesMatrixCache *maps.Cache[string, sitesmatrix.VectorStore] // Maps language index to sites matrix vector store.
 }
 
 func (pp *PathParser) init() {

config/allconfig/allconfig.go

@@ -878,6 +878,10 @@ func (c *Configs) Init(logger loggers.Logger) error {
 		ConfiguredRoles:     c.Base.Roles.Config,
 	}
 
+	if err := c.ConfiguredDimensions.Init(); err != nil {
+		return err
+	}
+
 	intSetsCfg := sitesmatrix.IntSetsConfig{
 		ApplyDefaults: sitesmatrix.IntSetsConfigApplyDefaultsIfNotSet,
 	}

hugolib/content_map_page_assembler.go

@@ -575,7 +575,7 @@ func (a *allPagesAssembler) doCreatePages(prefix string) error {
 				func() error {
 					if i := len(missingVectorsForHomeOrRootSection); i > 0 {
 						// Pick one, the rest will be created later.
-						vec := missingVectorsForHomeOrRootSection.Sample()
+						vec := missingVectorsForHomeOrRootSection.VectorSample()
 
 						kind := kinds.KindSection
 						if s == "" {

hugolib/content_map_page_contentnode.go

@@ -426,12 +426,25 @@ func (n contentNodesMap) sample() contentNode {
 }
 
 func (n contentNodesMap) siteVectors() sitesmatrix.VectorIterator {
-	return sitesmatrix.VectorIteratorFunc(func(yield func(v sitesmatrix.Vector) bool) bool {
-		for k := range n {
-			if !yield(k) {
-				return false
-			}
+	return n
+}
+
+func (n contentNodesMap) ForEachVector(yield func(v sitesmatrix.Vector) bool) bool {
+	for v := range n {
+		if !yield(v) {
+			return false
 		}
-		return true
-	})
+	}
+	return true
+}
+
+func (n contentNodesMap) LenVectors() int {
+	return len(n)
+}
+
+func (n contentNodesMap) VectorSample() sitesmatrix.Vector {
+	for v := range n {
+		return v
+	}
+	panic("no vectors")
 }

hugolib/roles/roles.go

@@ -76,6 +76,10 @@ type RolesInternal struct {
 	Sorted      []RoleInternal
 }
 
+func (r RolesInternal) Len() int {
+	return len(r.Sorted)
+}
+
 func (r RolesInternal) IndexDefault() int {
 	for i, role := range r.Sorted {
 		if role.Default {

hugolib/sitesmatrix/dimensions.go

@@ -76,9 +76,13 @@ func (v1 Vector) HasVector(v2 Vector) bool {
 }
 
 func (v1 Vector) HasAnyVector(vp VectorProvider) bool {
-	if vp.LenVectors() == 0 {
+	n := vp.LenVectors()
+	if n == 0 {
 		return false
 	}
+	if n == 1 {
+		return v1 == vp.VectorSample()
+	}
 
 	return !vp.ForEachVector(func(v2 Vector) bool {
 		if v1 == v2 {
@@ -144,12 +148,16 @@ func (vs Vectors) ForEachVector(yield func(v Vector) bool) bool {
 	return true
 }
 
+func (vs Vectors) LenVectors() int {
+	return len(vs)
+}
+
 func (vs Vectors) ToVectorStore() VectorStore {
 	return newVectorStoreMapFromVectors(vs)
 }
 
-// Sample returns one of the vectors in the set.
-func (vs Vectors) Sample() Vector {
+// VectorSample returns one of the vectors in the set.
+func (vs Vectors) VectorSample() Vector {
 	for v := range vs {
 		return v
 	}
@@ -161,14 +169,15 @@ type (
 		// ForEachVector iterates over all vectors in the provider.
 		// It returns false if the iteration was stopped early.
 		ForEachVector(func(v Vector) bool) bool
-	}
-)
 
-type VectorIteratorFunc func(func(v Vector) bool) bool
+		// LenVectors returns the number of vectors in the provider.
+		LenVectors() int
 
-func (f VectorIteratorFunc) ForEachVector(yield func(v Vector) bool) bool {
-	return f(yield)
-}
+		// VectorSample returns one of the vectors in the provider, usually the first or the only one.
+		// This will panic if the provider is empty.
+		VectorSample() Vector
+	}
+)
 
 // Bools holds boolean values for each dimension in the Hugo build matrix.
 type Bools [3]bool
@@ -198,13 +207,6 @@ type VectorProvider interface {
 	// HasAnyVector returns true if any of the vectors in the provider matches any of the vectors in v.
 	HasAnyVector(v VectorProvider) bool
 
-	// LenVectors returns the number of vectors in the provider.
-	LenVectors() int
-
-	// VectorSample returns one of the vectors in the provider, usually the first or the only one.
-	// This will panic if the provider is empty.
-	VectorSample() Vector
-
 	// Equals returns true if this provider is equal to the other provider.
 	EqualsVector(other VectorProvider) bool
 }
@@ -227,6 +229,22 @@ type ToVectorStoreProvider interface {
 	ToVectorStore() VectorStore
 }
 
+func VectorIteratorToStore(vi VectorIterator) VectorStore {
+	switch v := vi.(type) {
+	case VectorStore:
+		return v
+	case ToVectorStoreProvider:
+		return v.ToVectorStore()
+	}
+
+	vectors := make(Vectors)
+	vi.ForEachVector(func(v Vector) bool {
+		vectors[v] = struct{}{}
+		return true
+	})
+	return vectors.ToVectorStore()
+}
+
 type weightedVectorStore struct {
 	VectorStore
 	weight int

hugolib/sitesmatrix/vectorstores.go

@@ -71,10 +71,6 @@ func (s *vectorStoreMap) setVector(vec Vector) {
 	s.sets[vec] = struct{}{}
 }
 
-func (s *vectorStoreMap) Ordinal() int {
-	return 0
-}
-
 func (s *vectorStoreMap) KeysSorted() ([]int, []int, []int) {
 	var k0, k1, k2 []int
 	for v := range s.sets {
@@ -271,12 +267,45 @@ type ConfiguredDimension interface {
 	ResolveIndex(string) int
 	ResolveName(int) string
 	ForEachIndex() iter.Seq[int]
+	Len() int
 }
 
+// ConfiguredDimensions holds the configured dimensions for the site matrix.
 type ConfiguredDimensions struct {
 	ConfiguredLanguages ConfiguredDimension
 	ConfiguredVersions  ConfiguredDimension
 	ConfiguredRoles     ConfiguredDimension
+	CommonSitesMatrix   CommonSitestMatrix
+
+	singleVectorStoreCache *maps.Cache[Vector, *IntSets]
+}
+
+func (c *ConfiguredDimensions) IsSingleVector() bool {
+	return c.ConfiguredLanguages.Len() == 1 && c.ConfiguredRoles.Len() == 1 && c.ConfiguredVersions.Len() == 1
+}
+
+// GetOrCreateSingleVectorStore returns a VectorStore for the given vector.
+func (c *ConfiguredDimensions) GetOrCreateSingleVectorStore(vec Vector) *IntSets {
+	store, _ := c.singleVectorStoreCache.GetOrCreate(vec, func() (*IntSets, error) {
+		is := &IntSets{}
+		is.setValuesInNilSets(vec, true, true, true)
+		return is, nil
+	})
+	return store
+}
+
+func (c *ConfiguredDimensions) Init() error {
+	c.singleVectorStoreCache = maps.NewCache[Vector, *IntSets]()
+	b := NewIntSetsBuilder(c).WithDefaultsIfNotSet().Build()
+	defaultVec := b.VectorSample()
+	c.singleVectorStoreCache.Set(defaultVec, b)
+	c.CommonSitesMatrix.DefaultSite = b
+
+	return nil
+}
+
+type CommonSitestMatrix struct {
+	DefaultSite VectorStore
 }
 
 func (c *ConfiguredDimensions) ResolveNames(v Vector) types.Strings3 {
@@ -317,6 +346,8 @@ type IntSets struct {
 	h *hashOnce
 }
 
+var NilStore *IntSets = nil
+
 type hashOnce struct {
 	once sync.Once
 	hash uint64
@@ -363,7 +394,7 @@ func (s *IntSets) Intersects(other *IntSets) bool {
 // Complement returns a new VectorStore that contains all vectors in s that are not in any of ss.
 func (s *IntSets) Complement(ss ...VectorProvider) VectorStore {
 	if len(ss) == 0 || (len(ss) == 1 && ss[0] == s) {
-		return nil
+		return NilStore
 	}
 
 	for _, v := range ss {
@@ -372,8 +403,7 @@ func (s *IntSets) Complement(ss ...VectorProvider) VectorStore {
 			continue
 		}
 		if vv.IsSuperSet(s) {
-			var s *IntSets
-			return s
+			return NilStore
 		}
 	}
 
@@ -484,6 +514,9 @@ func (s *IntSets) HasLanguage(lang int) bool {
 	return s.languages.Has(lang)
 }
 
+// LenVectors returns the total number of vectors represented by the IntSets.
+// This is the Cartesian product of the lengths of the individual sets.
+// This will be 0 if s is nil or any of the sets is empty.
 func (s *IntSets) LenVectors() int {
 	if s == nil {
 		return 0
@@ -526,6 +559,10 @@ func (s *IntSets) HasAnyVector(v VectorProvider) bool {
 	if s.LenVectors() == 0 || v.LenVectors() == 0 {
 		return false
 	}
+	if v.LenVectors() == 1 {
+		// Fast path.
+		return s.HasVector(v.VectorSample())
+	}
 
 	if vs, ok := v.(*IntSets); ok {
 		// Fast path.
@@ -688,6 +725,14 @@ type IntSetsBuilder struct {
 
 func (b *IntSetsBuilder) Build() *IntSets {
 	b.s.init()
+
+	if b.s.LenVectors() == 1 {
+		// Cache it or use the existing cached version, which will allow b.s to be GCed.
+		bb, _ := b.cfg.singleVectorStoreCache.GetOrCreate(b.s.VectorSample(), func() (*IntSets, error) {
+			return b.s, nil
+		})
+		return bb
+	}
 	return b.s
 }
 
@@ -889,6 +934,10 @@ type testDimension struct {
 	names []string
 }
 
+func (m testDimension) Len() int {
+	return len(m.names)
+}
+
 func (m testDimension) IndexDefault() int {
 	return 0
 }
@@ -933,9 +982,13 @@ func (m *testDimension) IndexMatch(match predicate.P[string]) (iter.Seq[int], er
 
 // NewTestingDimensions creates a new ConfiguredDimensions for testing.
 func NewTestingDimensions(languages, versions, roles []string) *ConfiguredDimensions {
-	return &ConfiguredDimensions{
+	c := &ConfiguredDimensions{
 		ConfiguredLanguages: &testDimension{names: languages},
 		ConfiguredVersions:  &testDimension{names: versions},
 		ConfiguredRoles:     &testDimension{names: roles},
 	}
+	if err := c.Init(); err != nil {
+		panic(err)
+	}
+	return c
 }