fusefrontend: upgrade to three-entry dirCachev1.7-rc1

3 entries should work well for up to three parallel users.
It works well for extractloop.bash (two parallel tar extracts).

1 files changed, 86 insertions, 39 deletions

diff --git a/internal/fusefrontend/dircache.go b/internal/fusefrontend/dircache.go
index 5ae6d6b..9039f41 100644
--- a/internal/fusefrontend/dircache.go
+++ b/internal/fusefrontend/dircache.go
@@ -11,40 +11,60 @@ import (
 	"github.com/rfjakob/gocryptfs/internal/tlog"
 )
 
-type dirCacheStruct struct {
-	sync.Mutex
+const (
+	// Number of entries in the dirCache. Three entries work well for two
+	// (probably also three) parallel tar extracts (hit rate around 92%).
+	dirCacheSize = 3
+	// Enable Lookup/Store/Clear debug messages
+	enableDebugMessages = false
+	// Enable hit rate statistics printing
+	enableStats = true
+)
+
+type dirCacheEntryStruct struct {
 	// relative plaintext path to the directory
 	dirRelPath string
 	// fd to the directory (opened with O_PATH!)
 	fd int
 	// content of gocryptfs.diriv in this directory
 	iv []byte
-	// on the first Lookup(), the expire thread is stared, and this is set
+}
+
+func (e *dirCacheEntryStruct) Clear() {
+	// An earlier clear may have already closed the fd, or the cache
+	// has never been filled (fd is 0 in that case).
+	if e.fd > 0 {
+		err := syscall.Close(e.fd)
+		if err != nil {
+			tlog.Warn.Printf("dirCache.Clear: Close failed: %v", err)
+		}
+	}
+	e.fd = -1
+	e.dirRelPath = ""
+	e.iv = nil
+}
+
+type dirCacheStruct struct {
+	sync.Mutex
+	// Cache entries
+	entries [dirCacheSize]dirCacheEntryStruct
+	// Where to store the next entry (index into entries)
+	nextIndex int
+	// On the first Lookup(), the expire thread is stared, and this flag is set
 	// to true.
 	expireThreadRunning bool
+	// Hit rate stats. Evaluated and reset by the expire thread.
+	lookups uint64
+	hits    uint64
 }
 
 // Clear clears the cache contents.
 func (d *dirCacheStruct) Clear() {
 	d.Lock()
 	defer d.Unlock()
-	d.doClear()
-}
-
-// doClear closes the fd and clears the cache contents.
-// Caller must hold d.Lock()!
-func (d *dirCacheStruct) doClear() {
-	// An earlier clear may have already closed the fd, or the cache
-	// has never been filled (fd is 0 in that case).
-	if d.fd > 0 {
-		err := syscall.Close(d.fd)
-		if err != nil {
-			tlog.Warn.Printf("dirCache.Clear: Close failed: %v", err)
-		}
+	for i := range d.entries {
+		d.entries[i].Clear()
 	}
-	d.fd = -1
-	d.dirRelPath = ""
-	d.iv = nil
 }
 
 // Store the entry in the cache. The passed "fd" will be Dup()ed, and the caller
@@ -55,17 +75,20 @@ func (d *dirCacheStruct) Store(dirRelPath string, fd int, iv []byte) {
 	}
 	d.Lock()
 	defer d.Unlock()
+	e := &d.entries[d.nextIndex]
+	// Round-robin works well enough
+	d.nextIndex = (d.nextIndex + 1) % dirCacheSize
 	// Close the old fd
-	d.doClear()
+	e.Clear()
 	fd2, err := syscall.Dup(fd)
 	if err != nil {
 		tlog.Warn.Printf("dirCache.Store: Dup failed: %v", err)
 		return
 	}
-	d.fd = fd2
 	d.dbg("Store: %q %d %x\n", dirRelPath, fd2, iv)
-	d.dirRelPath = dirRelPath
-	d.iv = iv
+	e.fd = fd2
+	e.dirRelPath = dirRelPath
+	e.iv = iv
 	// expireThread is started on the first Lookup()
 	if !d.expireThreadRunning {
 		d.expireThreadRunning = true
@@ -73,31 +96,45 @@ func (d *dirCacheStruct) Store(dirRelPath string, fd int, iv []byte) {
 	}
 }
 
-// Lookup checks if relPath is in the cache, and returns and (fd, iv) pair.
+// Lookup checks if relPath is in the cache, and returns an (fd, iv) pair.
 // It returns (-1, nil) if not found. The fd is internally Dup()ed and the
 // caller must close it when done.
 func (d *dirCacheStruct) Lookup(dirRelPath string) (fd int, iv []byte) {
 	d.Lock()
 	defer d.Unlock()
-	if d.fd <= 0 {
-		// Cache is empty
-		d.dbg("Lookup %q: empty\n", dirRelPath)
-		return -1, nil
+	if enableStats {
+		d.lookups++
+	}
+	for i := range d.entries {
+		e := &d.entries[i]
+		if e.fd <= 0 {
+			// Cache slot is empty
+			continue
+		}
+		if dirRelPath != e.dirRelPath {
+			// Not the right path
+			continue
+		}
+		var err error
+		fd, err = syscall.Dup(e.fd)
+		if err != nil {
+			tlog.Warn.Printf("dirCache.Lookup: Dup failed: %v", err)
+			return -1, nil
+		}
+		iv = e.iv
 	}
-	if dirRelPath != d.dirRelPath {
+	if fd == 0 {
 		d.dbg("Lookup %q: miss\n", dirRelPath)
 		return -1, nil
 	}
-	fd, err := syscall.Dup(d.fd)
-	if err != nil {
-		tlog.Warn.Printf("dirCache.Lookup: Dup failed: %v", err)
-		return -1, nil
+	if enableStats {
+		d.hits++
 	}
-	if fd <= 0 || len(d.iv) != nametransform.DirIVLen {
-		log.Panicf("Lookup sanity check failed: fd=%d len=%d", fd, len(d.iv))
+	if fd <= 0 || len(iv) != nametransform.DirIVLen {
+		log.Panicf("Lookup sanity check failed: fd=%d len=%d", fd, len(iv))
 	}
-	d.dbg("Lookup %q: hit %d %x\n", dirRelPath, fd, d.iv)
-	return fd, d.iv
+	d.dbg("Lookup %q: hit %d %x\n", dirRelPath, fd, iv)
+	return fd, iv
 }
 
 // expireThread is started on the first Lookup()
@@ -105,13 +142,23 @@ func (d *dirCacheStruct) expireThread() {
 	for {
 		time.Sleep(1 * time.Second)
 		d.Clear()
+		if enableStats {
+			d.Lock()
+			lookups := d.lookups
+			hits := d.hits
+			d.lookups = 0
+			d.hits = 0
+			d.Unlock()
+			if lookups > 0 {
+				fmt.Printf("dirCache: hits=%3d lookups=%3d, rate=%3d%%\n", hits, lookups, (hits*100)/lookups)
+			}
+		}
 	}
 }
 
 // dbg prints a debug message. Usually disabled.
 func (d *dirCacheStruct) dbg(format string, a ...interface{}) {
-	const EnableDebugMessages = false
-	if EnableDebugMessages {
+	if enableDebugMessages {
 		fmt.Printf(format, a...)
 	}
 }