Try to use posix_fadvise with CBufferedFile

eklitzke · luke-jr · luke-jr · commit 3f2c08b8202e · 2022-02-22T22:58:10.000Z
This primarily affects blocks when bitcoin is launched with -reindex, as
that causes the block files to be loaded as CBufferedFile objects one at
a time as the reindex progresses.

Co-Authored-By: Luke Dashjr &lt;luke-jr+git@utopios.org&gt;
diff --git a/src/streams.h b/src/streams.h
@@ -10,6 +10,7 @@
 #include <span.h>
 #include <support/allocators/zeroafterfree.h>
 #include <util/overflow.h>
+#include <util/system.h>
 
 #include <algorithm>
 #include <assert.h>
@@ -616,11 +617,10 @@ class CBufferedFile
 
 public:
     CBufferedFile(FILE* fileIn, uint64_t nBufSize, uint64_t nRewindIn, int nTypeIn, int nVersionIn)
-        : nType(nTypeIn), nVersion(nVersionIn), nSrcPos(0), m_read_pos(0), nReadLimit(std::numeric_limits<uint64_t>::max()), nRewind(nRewindIn), vchBuf(nBufSize, std::byte{0})
+        : nType(nTypeIn), nVersion(nVersionIn), src(AdviseSequential(fileIn)), nSrcPos(0), m_read_pos(0), nReadLimit(std::numeric_limits<uint64_t>::max()), nRewind(nRewindIn), vchBuf(nBufSize, std::byte{0})
     {
         if (nRewindIn >= nBufSize)
             throw std::ios_base::failure("Rewind limit must be less than buffer size");
-        src = fileIn;
     }
 
     ~CBufferedFile()
@@ -638,7 +638,7 @@ class CBufferedFile
     void fclose()
     {
         if (src) {
-            ::fclose(src);
+            CloseAndUncache(src);
             src = nullptr;
         }
     }
diff --git a/src/util/system.cpp b/src/util/system.cpp
@@ -1201,7 +1201,8 @@ void AllocateFileRange(FILE *file, unsigned int offset, unsigned int length) {
     ftruncate(fileno(file), static_cast<off_t>(offset) + length);
 #else
     #if defined(HAVE_POSIX_FALLOCATE)
-    // Version using posix_fallocate
+    // Use posix_fallocate to advise the kernel how much data we have to write,
+    // if this system supports it.
     off_t nEndPos = (off_t)offset + length;
     if (0 == posix_fallocate(fileno(file), 0, nEndPos)) return;
     #endif
@@ -1221,6 +1222,46 @@ void AllocateFileRange(FILE *file, unsigned int offset, unsigned int length) {
 #endif
 }
 
+FILE* AdviseSequential(FILE *file) {
+#if _POSIX_C_SOURCE >= 200112L
+    // Since this whole thing is advisory anyway, we can ignore any errors
+    // encountered up to and including the posix_fadvise call. However, we must
+    // rewind the file to the appropriate position if we've changed the seek
+    // offset.
+    if (file == nullptr) {
+        return nullptr;
+    }
+    const int fd = fileno(file);
+    if (fd == -1) {
+        return file;
+    }
+    const off_t start = lseek(fd, 0, SEEK_CUR);
+    if (start == -1) {
+        return file;
+    }
+    posix_fadvise(fd, start, 0, POSIX_FADV_WILLNEED);
+    posix_fadvise(fd, start, 0, POSIX_FADV_SEQUENTIAL);
+#endif
+    return file;
+}
+
+int CloseAndUncache(FILE *file) {
+#if _POSIX_C_SOURCE >= 200112L
+    // Ignore any errors up to and including the posix_fadvise call since it's
+    // advisory.
+    if (file != nullptr) {
+        const int fd = fileno(file);
+        if (fd != -1) {
+            const off_t end = lseek(fd, 0, SEEK_END);
+            if (end != (off_t)-1) {
+                posix_fadvise(fd, 0, end, POSIX_FADV_DONTNEED);
+            }
+        }
+    }
+#endif
+    return fclose(file);
+}
+
 #ifdef WIN32
 fs::path GetSpecialFolderPath(int nFolder, bool fCreate)
 {
diff --git a/src/util/system.h b/src/util/system.h
@@ -89,6 +89,15 @@ bool CheckDiskSpace(const fs::path& dir, uint64_t additional_bytes = 0);
  */
 std::streampos GetFileSize(const char* path, std::streamsize max = std::numeric_limits<std::streamsize>::max());
 
+//! Return the original FILE* unchanged. On systems that support it,
+//! also advise the OS that the file will be accessed sequentially.
+FILE* AdviseSequential(FILE*);
+
+//! Close a file and return the result of fclose(). On systems that
+//! support it, advise the OS to remove the file contents from the page
+//! cache (which can help on memory-constrained systems).
+int CloseAndUncache(FILE*);
+
 /** Release all directory locks. This is used for unit testing only, at runtime
  * the global destructor will take care of the locks.
  */

Original file line number	Diff line number	Diff line change
`@@ -10,6 +10,7 @@`
`10`	`10`	`#include <span.h>`
`11`	`11`	`#include <support/allocators/zeroafterfree.h>`
`12`	`12`	`#include <util/overflow.h>`
	`13`	`+#include <util/system.h>`
`13`	`14`
`14`	`15`	`#include <algorithm>`
`15`	`16`	`#include <assert.h>`
`@@ -616,11 +617,10 @@ class CBufferedFile`
`616`	`617`
`617`	`618`	`public:`
`618`	`619`	`CBufferedFile(FILE* fileIn, uint64_t nBufSize, uint64_t nRewindIn, int nTypeIn, int nVersionIn)`
`619`		`- : nType(nTypeIn), nVersion(nVersionIn), nSrcPos(0), m_read_pos(0), nReadLimit(std::numeric_limits<uint64_t>::max()), nRewind(nRewindIn), vchBuf(nBufSize, std::byte{0})`
	`620`	`+ : nType(nTypeIn), nVersion(nVersionIn), src(AdviseSequential(fileIn)), nSrcPos(0), m_read_pos(0), nReadLimit(std::numeric_limits<uint64_t>::max()), nRewind(nRewindIn), vchBuf(nBufSize, std::byte{0})`
`620`	`621`	`{`
`621`	`622`	`if (nRewindIn >= nBufSize)`
`622`	`623`	`throw std::ios_base::failure("Rewind limit must be less than buffer size");`
`623`		`- src = fileIn;`
`624`	`624`	`}`
`625`	`625`
`626`	`626`	`~CBufferedFile()`
`@@ -638,7 +638,7 @@ class CBufferedFile`
`638`	`638`	`void fclose()`
`639`	`639`	`{`
`640`	`640`	`if (src) {`
`641`		`- ::fclose(src);`
	`641`	`+ CloseAndUncache(src);`
`642`	`642`	`src = nullptr;`
`643`	`643`	`}`
`644`	`644`	`}`