perf: bypass file system read cache if memory cache is available (#707)

This is for reading pacakge.json and tsconfig.json.

```
resolver/single-thread  time:   [70.355 µs 70.908 µs 71.507 µs]
                        change: [−10.363% −7.0636% −3.8633%] (p = 0.00 < 0.05)
                        Performance has improved.
Found 5 outliers among 100 measurements (5.00%)
  2 (2.00%) high mild
  3 (3.00%) high severe
resolver/multi-thread   time:   [59.697 µs 61.750 µs 64.767 µs]
                        change: [−15.418% −7.3458% +1.2883%] (p = 0.11 > 0.05)
                        No change in performance detected.
Found 3 outliers among 100 measurements (3.00%)
  3 (3.00%) high severe
resolver/resolve from symlinks
                        time:   [25.561 ms 25.734 ms 25.910 ms]
                        change: [−19.181% −17.957% −16.794%] (p = 0.00 < 0.05)
                        Performance has improved.
Found 1 outliers among 100 measurements (1.00%)
  1 (1.00%) high mild
```

---------

Co-authored-by: Codex <[email protected]>

Author: Brooooooklyn

Cargo.lock

@@ -94,6 +94,9 @@ pnp = { version = "0.12.2", optional = true }
 
 document-features = { version = "0.2.11", optional = true }
 
+[target.'cfg(any(target_os = "macos", target_os = "linux"))'.dependencies]
+libc = "0.2"
+
 [target.'cfg(target_os = "windows")'.dependencies]
 windows = { version = "0.62.0", features = ["Win32_Storage_FileSystem"] }
 

Cargo.toml

@@ -119,9 +119,12 @@ impl<Fs: FileSystem> Cache<Fs> {
             .package_json
             .get_or_try_init(|| {
                 let package_json_path = path.path.join("package.json");
-                let Ok(package_json_string) = self.fs.read_to_string(&package_json_path) else {
+                let Ok(package_json_string) =
+                    self.fs.read_to_string_bypass_system_cache(&package_json_path)
+                else {
                     return Ok(None);
                 };
+
                 let real_path = if options.symlinks {
                     self.canonicalize(path)?.join("package.json")
                 } else {
@@ -174,7 +177,7 @@ impl<Fs: FileSystem> Cache<Fs> {
         };
         let mut tsconfig_string = self
             .fs
-            .read_to_string(&tsconfig_path)
+            .read_to_string_bypass_system_cache(&tsconfig_path)
             .map_err(|_| ResolveError::TsconfigNotFound(path.to_path_buf()))?;
         let mut tsconfig =
             TsConfig::parse(root, &tsconfig_path, &mut tsconfig_string).map_err(|error| {

src/cache.rs

@@ -29,6 +29,18 @@ pub trait FileSystem: Send + Sync {
     /// napi env.
     fn read_to_string(&self, path: &Path) -> io::Result<String>;
 
+    /// Reads a file while bypassing the system cache.
+    ///
+    /// This is useful in scenarios where the file content is already cached in memory
+    /// and you want to avoid the overhead of using the system cache.
+    ///
+    /// # Errors
+    ///
+    /// * See [std::fs::read_to_string]
+    fn read_to_string_bypass_system_cache(&self, path: &Path) -> io::Result<String> {
+        self.read_to_string(path)
+    }
+
     /// See [std::fs::metadata]
     ///
     /// # Errors
@@ -126,10 +138,10 @@ pub struct FileSystemOs {
 impl FileSystemOs {
     /// # Errors
     ///
-    /// See [std::fs::read_to_string]
-    pub fn read_to_string(path: &Path) -> io::Result<String> {
+    /// See [std::io::ErrorKind::InvalidData]
+    #[inline]
+    pub fn validate_string(bytes: Vec<u8>) -> io::Result<String> {
         // `simdutf8` is faster than `std::str::from_utf8` which `fs::read_to_string` uses internally
-        let bytes = std::fs::read(path)?;
         if simdutf8::basic::from_utf8(&bytes).is_err() {
             // Same error as `fs::read_to_string` produces (`io::Error::INVALID_UTF8`)
             return Err(io::Error::new(
@@ -141,6 +153,14 @@ impl FileSystemOs {
         Ok(unsafe { String::from_utf8_unchecked(bytes) })
     }
 
+    /// # Errors
+    ///
+    /// See [std::fs::read_to_string]
+    pub fn read_to_string(path: &Path) -> io::Result<String> {
+        let bytes = std::fs::read(path)?;
+        Self::validate_string(bytes)
+    }
+
     /// # Errors
     ///
     /// See [std::fs::metadata]
@@ -219,6 +239,54 @@ impl FileSystem for FileSystemOs {
         Self::read_to_string(path)
     }
 
+    fn read_to_string_bypass_system_cache(&self, path: &Path) -> io::Result<String> {
+        cfg_if! {
+            if #[cfg(feature = "yarn_pnp")] {
+                if self.yarn_pnp {
+                    return match VPath::from(path)? {
+                        VPath::Zip(info) => {
+                            self.pnp_lru.read_to_string(info.physical_base_path(), info.zip_path)
+                        }
+                        VPath::Virtual(info) => Self::read_to_string(&info.physical_base_path()),
+                        VPath::Native(path) => Self::read_to_string(&path),
+                    }
+                }
+            }
+        }
+        #[cfg(target_os = "macos")]
+        {
+            use libc::F_NOCACHE;
+            use std::{io::Read, os::unix::fs::OpenOptionsExt};
+            let mut fd = fs::OpenOptions::new().read(true).custom_flags(F_NOCACHE).open(path)?;
+            let meta = fd.metadata()?;
+            #[allow(clippy::cast_possible_truncation)]
+            let mut buffer = Vec::with_capacity(meta.len() as usize);
+            fd.read_to_end(&mut buffer)?;
+            Self::validate_string(buffer)
+        }
+        #[cfg(target_os = "linux")]
+        {
+            use std::{io::Read, os::fd::AsRawFd};
+            // Avoid `O_DIRECT` on Linux: it requires page-aligned buffers and aligned offsets,
+            // which is incompatible with a regular Vec-based read and many CI filesystems.
+            let mut fd = fs::OpenOptions::new().read(true).open(path)?;
+            // Best-effort hint to avoid polluting the page cache.
+            // SAFETY: `fd` is valid and `posix_fadvise` is safe.
+            let _ = unsafe { libc::posix_fadvise(fd.as_raw_fd(), 0, 0, libc::POSIX_FADV_DONTNEED) };
+            let meta = fd.metadata();
+            let mut buffer = meta.ok().map_or_else(Vec::new, |meta| {
+                #[allow(clippy::cast_possible_truncation)]
+                Vec::with_capacity(meta.len() as usize)
+            });
+            fd.read_to_end(&mut buffer)?;
+            Self::validate_string(buffer)
+        }
+        #[cfg(not(any(target_os = "macos", target_os = "linux")))]
+        {
+            Self::read_to_string(path)
+        }
+    }
+
     fn metadata(&self, path: &Path) -> io::Result<FileMetadata> {
         cfg_if! {
             if #[cfg(feature = "yarn_pnp")] {