connected up cache 5 trial

Author: grantnelson-wf

build/build.go

@@ -1140,8 +1140,10 @@ func (s *Session) readDeclCache(pkg *PackageData) {
 		return
 	}
 
+	declCache := compiler.NewDeclCache(pkg.ImportPath)
+
 	if pkg.StaleCache {
-		s.cachedDecls[pkg.ImportPath] = &compiler.DeclCache{}
+		s.cachedDecls[pkg.ImportPath] = declCache
 		log.Infof(`Cache stale for package %q`, pkg.ImportPath)
 		return
 	}
@@ -1158,14 +1160,11 @@ func (s *Session) readDeclCache(pkg *PackageData) {
 		srcModTime = fileModTime
 	}
 
-	declCache := &compiler.DeclCache{}
 	if !s.buildCache.Load(declCache, pkg.ImportPath, srcModTime) {
 		// Load failed so this cache is stale and any package depending on this
-		// package will also be considered stale.
+		// package will also be considered stale. The declCache will be empty
+		// since it doesn't allow partial population.
 		pkg.StaleCache = true
-		// set a new empty declCache incase the Load left the declCache in a
-		// partially filled state.
-		declCache = &compiler.DeclCache{}
 	}
 	s.cachedDecls[pkg.ImportPath] = declCache
 }

compiler/declCache.go

@@ -1,143 +1,134 @@
 package compiler
 
 import (
+	"errors"
 	"fmt"
-	"sort"
 	"time"
 )
 
 type DeclCache struct {
-	decls   map[string]*Decl
+	importPath    string
+	importedPaths []string
+	importDecls   []*Decl
+	typeDecls     []*Decl
+	varDecls      []*Decl
+	funcDecls     []*Decl
+
 	changed bool
 	stats   declCacheStats
 }
 
+// NewDeclCache creates a new empty enabled decl cache for the package with
+// the given import path.
+//
+// The given import path is used as a secondary check to ensure we do not get
+// hashing collisions when reading a cache from storage.
+func NewDeclCache(importPath string) *DeclCache {
+	return &DeclCache{importPath: importPath}
+}
+
 var declCacheGlobalStats declCacheStats
 
 type declCacheStats struct {
-	reads        int // number of times Read was called (should be 0 or 1 unless global)
-	writes       int // number of times Write was called (should be 0 or 1 unless global)
-	loadedCount  int // number of declarations loaded from storage
-	addedCount   int // number of declarations added to the cache
-	skippedCount int // number of declarations not cached (for being generic or non-unique)
-	usedCount    int // number of times a declaration was retrieved from the cache
-	readDur      time.Duration
-	writeDur     time.Duration
+	reads      int // number of times Read was called (should be 0 or 1 unless global)
+	writes     int // number of times Write was called (should be 0 or 1 unless global)
+	readCount  int // number of declarations loaded from storage
+	writeCount int // number of declarations written to storage
+	readDur    time.Duration
+	writeDur   time.Duration
 }
 
-// Chacnged reports whether the cache has had declarations added to it since
-// it was created or last read from storage or created empty.
-//
-// If there have been no changes, the cache does not need to be written back
-// to storage. Typically declarations will only be added when the cache is
-// empty and not loaded from storage since otherwise all the needed declarations
-// (other than those not being cached) would already be present.
-func (dc *DeclCache) Changed() bool {
-	return dc != nil && dc.changed
-}
+var (
+	errReadDisabled  = errors.New(`attempted to read a DeclCache that is disabled (nil)`)
+	errWriteDisabled = errors.New(`attempted to write a DeclCache that is disabled (nil)`)
+)
 
-func (dc *DeclCache) GetDecl(fullname string) *Decl {
+// ImportPath is the import path for the package this cache is for.
+func (dc *DeclCache) ImportPath() string {
 	if dc == nil {
-		return nil // cache is disabled
+		return `[disabled]`
 	}
-	if decl, ok := dc.decls[fullname]; ok {
-		dc.stats.usedCount++
-		declCacheGlobalStats.usedCount++
+	return dc.importPath
+}
 
-		fmt.Printf(">>> GetDecl(%q): Found\n", fullname) // TODO(grantnelson-wf): REMOVE
-		return decl
-	}
+// Changed reports whether the cache has had declarations set to it since
+// it was created (or last read from or write to storage). If there have been
+// no changes, the cache does not need to be written back to storage.
+func (dc *DeclCache) Changed() bool {
+	return dc != nil && dc.changed
+}
 
-	fmt.Printf(">>> GetDecl(%q): Miss\n", fullname) // TODO(grantnelson-wf): REMOVE
-	return nil
+// HasCache indicates that this cache contains at least one declaration in it.
+func (dc *DeclCache) HasCache() bool {
+	return dc.count() > 0
 }
 
-func (dc *DeclCache) PutDecl(decl *Decl) {
+// count reports how many declarations are currently in the cache.
+func (dc *DeclCache) count() int {
 	if dc == nil {
-		return // cache is disabled
-	}
-
-	if decl.ForGeneric {
-		// Do not cache declarations for generic instantiations.
-		// The type arguments may come from a package depending on this one
-		// and not on one of this package's dependencies.
-		//
-		// If one of this package's dependencies changes, the cache will not be used.
-		// However, currently, changes to packages depending on this one
-		// may change and this package's cache may still be used.
-		// Therefore, if the package depending on this one changes a type from
-		// being blocking to non-blocking or vice versa, the cached declaration
-		// may be invalid.
-		//
-		// TODO(grantnelson-wf): We could improve this by tracking which packages
-		// the type arguments come from and allow caching if those are all from
-		// dependencies. Since we don't use cache when a dependency changes,
-		// (i.e. has stale cache) we can use generics in that case. We just can't
-		// cache the instantiations that come from packages depending on this one
-		// since those don't invalidate dependent packages' caches.
-		dc.stats.skippedCount++
-		declCacheGlobalStats.skippedCount++
-		fmt.Printf(">>> PutDecl(%q): Generic\n", decl.FullName) // TODO(grantnelson-wf): REMOVE
-		return
-	}
-
-	if !isUniqueDeclFullName(decl.FullName) {
-		// Only cache declarations with unique names.
-		dc.stats.skippedCount++
-		declCacheGlobalStats.skippedCount++
-		fmt.Printf(">>> PutDecl(%q): Not Unique\n", decl.FullName) // TODO(grantnelson-wf): REMOVE
-		return
+		return 0
 	}
+	return len(dc.importDecls) + len(dc.typeDecls) + len(dc.varDecls) + len(dc.funcDecls)
+}
 
-	if existing, ok := dc.decls[decl.FullName]; ok {
-		if existing != decl {
-			panic(fmt.Errorf(`decl cache conflict: different decls with same name: %q`, decl.FullName))
-		}
-		fmt.Printf(">>> PutDecl(%q): Dup\n", decl.FullName) // TODO(grantnelson-wf): REMOVE
-		return
+func (dc *DeclCache) GetDecls() (importedPaths []string, importDecls, typeDecls, varDecls, funcDecls []*Decl) {
+	if dc == nil {
+		return nil, nil, nil, nil, nil // cache is disabled
 	}
+	return dc.importedPaths, dc.importDecls, dc.typeDecls, dc.varDecls, dc.funcDecls
+}
 
-	if dc.decls == nil {
-		dc.decls = map[string]*Decl{}
+func (dc *DeclCache) SetDecls(importedPaths []string, importDecls, typeDecls, varDecls, funcDecls []*Decl) {
+	if dc == nil {
+		return // cache is disabled
 	}
-	dc.decls[decl.FullName] = decl
+	dc.importedPaths = importedPaths
+	dc.importDecls = importDecls
+	dc.typeDecls = typeDecls
+	dc.varDecls = varDecls
+	dc.funcDecls = funcDecls
 	dc.changed = true
-	dc.stats.addedCount++
-	declCacheGlobalStats.addedCount++
+}
 
-	fmt.Printf(">>> PutDecl(%q): Added\n", decl.FullName) // TODO(grantnelson-wf): REMOVE
+type serializableDeclCache struct {
+	ImportPath    string
+	ImportedPaths []string
+	ImportDecls   []*Decl
+	TypeDecls     []*Decl
+	VarDecls      []*Decl
+	FuncDecls     []*Decl
 }
 
 func (dc *DeclCache) Read(decode func(any) error) error {
 	if dc == nil {
-		return nil // cache is disabled
+		return errReadDisabled
 	}
 
-	dc.stats.reads++
-	declCacheGlobalStats.reads++
 	start := time.Now()
-	var count int
-	if err := decode(&count); err != nil {
-		return err
-	}
 
-	if dc.decls == nil {
-		dc.decls = map[string]*Decl{}
+	ser := serializableDeclCache{}
+	if err := decode(&ser); err != nil {
+		return err
 	}
-	for i := 0; i < count; i++ {
-		decl := &Decl{}
-		if err := decode(decl); err != nil {
-			return err
-		}
-		if decl.ForGeneric || !isUniqueDeclFullName(decl.FullName) {
-			// These declarations should not have been cached.
-			continue
-		}
-		dc.decls[decl.FullName] = decl
+	if dc.importPath != ser.ImportPath {
+		return fmt.Errorf(`read cache for import path %q when wanting %q`, dc.importPath, ser.ImportPath)
 	}
 
-	dc.stats.loadedCount += len(dc.decls)
-	declCacheGlobalStats.loadedCount += len(dc.decls)
+	// Only modify the cache after everything has been checked.
+	dc.importedPaths = ser.ImportedPaths
+	dc.importDecls = ser.ImportDecls
+	dc.typeDecls = ser.TypeDecls
+	dc.varDecls = ser.VarDecls
+	dc.funcDecls = ser.FuncDecls
+	dc.changed = false
+
+	dc.stats.reads++
+	declCacheGlobalStats.reads++
+
+	declCount := dc.count()
+	dc.stats.readCount += declCount
+	declCacheGlobalStats.readCount += declCount
+
 	dur := time.Since(start)
 	dc.stats.readDur += dur
 	declCacheGlobalStats.readDur += dur
@@ -146,28 +137,31 @@ func (dc *DeclCache) Read(decode func(any) error) error {
 
 func (dc *DeclCache) Write(encode func(any) error) error {
 	if dc == nil {
-		return nil // cache is disabled
+		return errWriteDisabled
 	}
 
-	dc.stats.writes++
-	declCacheGlobalStats.writes++
 	start := time.Now()
-	count := len(dc.decls)
-	if err := encode(count); err != nil {
+
+	ser := serializableDeclCache{
+		ImportedPaths: dc.importedPaths,
+		ImportDecls:   dc.importDecls,
+		ImportPath:    dc.importPath,
+		TypeDecls:     dc.typeDecls,
+		VarDecls:      dc.varDecls,
+		FuncDecls:     dc.funcDecls,
+	}
+	if err := encode(ser); err != nil {
 		return err
 	}
+	dc.changed = false
 
-	names := make([]string, 0, count)
-	for name := range dc.decls {
-		names = append(names, name)
-	}
-	sort.Strings(names)
+	dc.stats.writes++
+	declCacheGlobalStats.writes++
+
+	declCount := dc.count()
+	dc.stats.writeCount += declCount
+	declCacheGlobalStats.writeCount += declCount
 
-	for _, name := range names {
-		if err := encode(dc.decls[name]); err != nil {
-			return err
-		}
-	}
 	dur := time.Since(start)
 	dc.stats.writeDur += dur
 	declCacheGlobalStats.writeDur += dur
@@ -178,18 +172,14 @@ func (dc *DeclCache) String() string {
 	if dc == nil {
 		return `[disabled]`
 	}
-	return dc.stats.String()
+	return dc.stats.String() + `, ` + dc.importPath
 }
 
 func (s declCacheStats) String() string {
-	return fmt.Sprintf(`reads=%d, writes=%d, `+
-		`loaded=%d, added=%d, skipped=%d, used=%d, `+
-		`readDur=%s, writeDur=%s`,
-		s.reads, s.writes,
-		s.loadedCount, s.addedCount, s.skippedCount, s.usedCount,
-		s.readDur.String(), s.writeDur.String())
+	return fmt.Sprintf(`reads=%d, writes=%d, readCount=%d, writeCount=%d, readDur=%s, writeDur=%s`,
+		s.reads, s.writes, s.readCount, s.writeCount, s.readDur.String(), s.writeDur.String())
 }
 
 func GlobalDeclCacheStats() string {
-	return declCacheGlobalStats.String()
+	return declCacheGlobalStats.String() + `, [global]`
 }