clear_system_cache: Sync dirty pages before ClearCacheForFile(s)

In http://crbug.com/881384#c2 I saw some more evidence that the page cache is
not fully flushed when benchmarking. On Linux/Android calling sync(2) syscall
before evicting individual files should help because the later pagecache
dropping operations become a lot cheaper for the kernel. I could not find good
documentation about sync(2) guarantees on MacOS.

The page cache flushing for individual files is still asynchronous, with no
cheap way to check that it happened. The plan is to sleep for one second after
such operations. Since we would prefer to sleep only once per bulk of
operations, the sleeping will be done on higher levels.

The Windows story is not covered - the operation requires administrator
privileges.

Bug: 811244
Change-Id: Ib71f4f934a0eb4b438bfedbbb50462e07ff64308
Reviewed-on: https://chromium-review.googlesource.com/1211602
Commit-Queue: Egor Pasko <pasko@chromium.org>
Reviewed-by: Bruce Dawson <brucedawson@chromium.org>
Reviewed-by: Albert J. Wong <ajwong@chromium.org>
Cr-Commit-Position: refs/heads/master@{#590266}

base/test/test_file_util.h

@@ -39,6 +39,11 @@ bool EvictFileFromSystemCacheWithRetry(const FilePath& file);
 // success.
 bool DieFileDie(const FilePath& file, bool recurse);
 
+// Synchronize all the dirty pages from the page cache to disk (on POSIX
+// systems). The Windows analogy for this operation is to 'Flush file buffers'.
+// Note: This is currently implemented as a no-op on Windows.
+void SyncPageCacheToDisk();
+
 // Clear a specific file from the system cache. After this call, trying
 // to access this file will result in a cold load from the hard drive.
 bool EvictFileFromSystemCache(const FilePath& file);

base/test/test_file_util_posix.cc

@@ -9,6 +9,7 @@
 #include <stddef.h>
 #include <sys/stat.h>
 #include <sys/types.h>
+#include <unistd.h>
 
 #include <string>
 
@@ -79,6 +80,11 @@ bool DieFileDie(const FilePath& file, bool recurse) {
   return DeleteFile(file, recurse);
 }
 
+void SyncPageCacheToDisk() {
+  // On Linux (and Android) the sync(2) call waits for I/O completions.
+  sync();
+}
+
 #if !defined(OS_LINUX) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
 bool EvictFileFromSystemCache(const FilePath& file) {
   // There doesn't seem to be a POSIX way to cool the disk cache.

base/test/test_file_util_win.cc

@@ -104,6 +104,12 @@ bool DieFileDie(const FilePath& file, bool recurse) {
   return false;
 }
 
+void SyncPageCacheToDisk() {
+  // Approximating this with noop. The proper implementation would require
+  // administrator privilege:
+  // https://docs.microsoft.com/en-us/windows/desktop/api/FileAPI/nf-fileapi-flushfilebuffers
+}
+
 bool EvictFileFromSystemCache(const FilePath& file) {
   base::win::ScopedHandle file_handle(
       CreateFile(file.value().c_str(), GENERIC_READ | GENERIC_WRITE, 0, NULL,

tools/perf/clear_system_cache/clear_system_cache_main.cc

@@ -40,6 +40,11 @@ int main(int argc, const char* argv[]) {
       return 1;
     }
 
+    // Synchronously eliminating the dirty pages from pagecache allows to
+    // minimize adhoc waiting after all of the per-file pagecache dropping is
+    // done.
+    base::SyncPageCacheToDisk();
+
     if (base::DirectoryExists(path)) {
       base::FileEnumerator enumerator(path, should_recurse,
                                       base::FileEnumerator::FILES);