Make ReadAhead related const into optional arguments.

api/common/config.go

@@ -55,6 +55,10 @@ type FlagStorage struct {
 	DebugFuse  bool
 	DebugS3    bool
 	Foreground bool
+
+	// Readahead
+	MaxReadAhead   uint32
+	ReadAheadChunk uint32
 }
 
 func (flags *FlagStorage) GetMimeType(fileName string) (retMime *string) {

internal/file.go

@@ -66,9 +66,6 @@ type FileHandle struct {
 	keepPageCache bool // the same value we returned to OpenFile
 }
 
-const MAX_READAHEAD = uint32(400 * 1024 * 1024)
-const READAHEAD_CHUNK = uint32(20 * 1024 * 1024)
-
 // NewFileHandle returns a new file handle for the given `inode` triggered by fuse
 // operation with the given `opMetadata`
 func NewFileHandle(inode *Inode, opMetadata fuseops.OpMetadata) *FileHandle {
@@ -426,14 +423,14 @@ func (fh *FileHandle) readAhead(offset uint64, needAtLeast int) (err error) {
 		existingReadahead += b.size
 	}
 
-	readAheadAmount := MAX_READAHEAD
+	readAheadAmount := fh.inode.fs.flags.MaxReadAhead
 
-	for readAheadAmount-existingReadahead >= READAHEAD_CHUNK {
+	for readAheadAmount-existingReadahead >= fh.inode.fs.flags.ReadAheadChunk {
 		off := offset + uint64(existingReadahead)
 		remaining := fh.inode.Attributes.Size - off
 
 		// only read up to readahead chunk each time
-		size := MinUInt32(readAheadAmount-existingReadahead, READAHEAD_CHUNK)
+		size := MinUInt32(readAheadAmount-existingReadahead, fh.inode.fs.flags.ReadAheadChunk)
 		// but don't read past the file
 		size = uint32(MinUInt64(uint64(size), remaining))
 
@@ -456,7 +453,7 @@ func (fh *FileHandle) readAhead(offset uint64, needAtLeast int) (err error) {
 			}
 		}
 
-		if size != READAHEAD_CHUNK {
+		if size != fh.inode.fs.flags.ReadAheadChunk {
 			// that was the last remaining chunk to readahead
 			break
 		}
@@ -543,7 +540,7 @@ func (fh *FileHandle) readFile(offset int64, buf []byte) (bytesRead int, err err
 		fh.buffers = nil
 	}
 
-	if !fs.flags.Cheap && fh.seqReadAmount >= uint64(READAHEAD_CHUNK) && fh.numOOORead < 3 {
+	if !fs.flags.Cheap && fh.seqReadAmount >= uint64(fh.inode.fs.flags.ReadAheadChunk) && fh.numOOORead < 3 {
 		if fh.reader != nil {
 			fh.inode.logFuse("cutover to the parallel algorithm")
 			fh.reader.Close()

internal/flags.go

@@ -138,6 +138,18 @@ func NewApp() (app *cli.App) {
 				Usage: "GID owner of all inodes.",
 			},
 
+			cli.IntFlag{
+				Name:  "max-readahead",
+				Value: 400 * 1024 * 1024,
+				Usage: "max readahead size.",
+			},
+
+			cli.IntFlag{
+				Name:  "readahead-chunk",
+				Value: 20 * 1024 * 1024,
+				Usage: "readahead chunk size.",
+			},
+
 			/////////////////////////
 			// S3
 			/////////////////////////
@@ -341,6 +353,10 @@ func PopulateFlags(c *cli.Context) (ret *FlagStorage) {
 		DebugFuse:  c.Bool("debug_fuse"),
 		DebugS3:    c.Bool("debug_s3"),
 		Foreground: c.Bool("f"),
+
+		// ReadAhead
+		MaxReadAhead:   uint32(c.Int("max-readahead")),
+		ReadAheadChunk: uint32(c.Int("readahead-chunk")),
 	}
 
 	// S3

internal/goofys_test.go

@@ -61,6 +61,8 @@ import (
 	"runtime/debug"
 )
 
+const READAHEAD_CHUNK = uint32(20 * 1024 * 1024)
+
 // so I don't get complains about unused imports
 var ignored = logrus.DebugLevel