perf(npm): don't try to cache npm packages we've already cached (#28938)

With `nodeModulesDir: auto` (and `none`, to a lesser extent), we
frequently repeatedly try to cache npm packages during resolution. On a
(private) fresh project, I counted that `sync_resolution_with_fs` was
called 478 times over the course of a fresh build. This reduces the
number of calls to 8, and doing so speeds things up substantially.

```
❯ hyperfine --warmup 2 -N "deno task build" "../deno/target/release-lite/deno task build"
Benchmark 1: deno task build
  Time (mean ± σ):      3.652 s ±  0.042 s    [User: 3.285 s, System: 2.399 s]
  Range (min … max):    3.587 s …  3.712 s    10 runs

Benchmark 2: ../deno/target/release-lite/deno task build
  Time (mean ± σ):      1.356 s ±  0.007 s    [User: 1.961 s, System: 1.108 s]
  Range (min … max):    1.345 s …  1.372 s    10 runs

Summary
  ../deno/target/release-lite/deno task build ran
    2.69 ± 0.03 times faster than deno task build
```

Author: nathanwhit

cli/npm/installer/mod.rs

@@ -13,6 +13,7 @@ use deno_npm::NpmSystemInfo;
 use deno_resolver::npm::managed::NpmResolutionCell;
 use deno_runtime::colors;
 use deno_semver::package::PackageReq;
+use rustc_hash::FxHashSet;
 
 pub use self::common::NpmPackageFsInstaller;
 use self::global::GlobalNpmPackageInstaller;
@@ -49,6 +50,7 @@ pub struct NpmInstaller {
   maybe_lockfile: Option<Arc<CliLockfile>>,
   npm_resolution: Arc<NpmResolutionCell>,
   top_level_install_flag: AtomicFlag,
+  cached_reqs: tokio::sync::Mutex<FxHashSet<PackageReq>>,
 }
 
 impl NpmInstaller {
@@ -100,6 +102,7 @@ impl NpmInstaller {
       npm_resolution_installer,
       maybe_lockfile,
       top_level_install_flag: Default::default(),
+      cached_reqs: Default::default(),
     }
   }
 
@@ -168,7 +171,28 @@ impl NpmInstaller {
     }
     if result.dependencies_result.is_ok() {
       if let Some(caching) = caching {
-        result.dependencies_result = self.cache_packages(caching).await;
+        // the async mutex is unfortunate, but needed to handle the edge case where two workers
+        // try to cache the same package at the same time. we need to hold the lock while we cache
+        // and since that crosses an await point, we need the async mutex.
+        //
+        // should have a negligible perf impact because acquiring the lock is still in the order of nanoseconds
+        // while caching typically takes micro or milli seconds.
+        let mut cached_reqs = self.cached_reqs.lock().await;
+        let uncached = {
+          packages
+            .iter()
+            .filter(|req| !cached_reqs.contains(req))
+            .collect::<Vec<_>>()
+        };
+
+        if !uncached.is_empty() {
+          result.dependencies_result = self.cache_packages(caching).await;
+          if result.dependencies_result.is_ok() {
+            for req in uncached {
+              cached_reqs.insert(req.clone());
+            }
+          }
+        }
       }
     }