refactor(@angular-devkit/core): add cache to normalize

And a benchmark to show the curve, more or less.

Author: hansl

packages/angular_devkit/core/package.json

@@ -11,7 +11,10 @@
     "ajv": "6.5.3",
     "chokidar": "2.0.4",
     "fast-json-stable-stringify": "2.0.0",
-    "source-map": "0.7.3",
-    "rxjs": "6.3.3"
+    "rxjs": "6.3.3",
+    "source-map": "0.7.3"
+  },
+  "devDependencies": {
+    "seedrandom": "^2.4.4"
   }
 }

packages/angular_devkit/core/src/virtual-fs/path.ts

@@ -185,18 +185,51 @@ export function fragment(path: string): PathFragment {
 }
 
 
+/**
+ * normalize() cache to reduce computation. For now this grows and we never flush it, but in the
+ * future we might want to add a few cache flush to prevent this from growing too large.
+ */
+let normalizedCache = new Map<string, Path>();
+
+
+/**
+ * Reset the cache. This is only useful for testing.
+ * @private
+ */
+export function resetNormalizeCache() {
+  normalizedCache = new Map<string, Path>();
+}
+
+
 /**
  * Normalize a string into a Path. This is the only mean to get a Path type from a string that
- * represents a system path. Normalization includes:
+ * represents a system path. This method cache the results as real world paths tend to be
+ * duplicated often.
+ * Normalization includes:
  *   - Windows backslashes `\\` are replaced with `/`.
  *   - Windows drivers are replaced with `/X/`, where X is the drive letter.
  *   - Absolute paths starts with `/`.
  *   - Multiple `/` are replaced by a single one.
  *   - Path segments `.` are removed.
  *   - Path segments `..` are resolved.
  *   - If a path is absolute, having a `..` at the start is invalid (and will throw).
+ * @param path The path to be normalized.
  */
 export function normalize(path: string): Path {
+  let maybePath = normalizedCache.get(path);
+  if (!maybePath) {
+    maybePath = noCacheNormalize(path);
+    normalizedCache.set(path, maybePath);
+  }
+
+  return maybePath;
+}
+
+
+/**
+ * The no cache version of the normalize() function. Used for benchmarking and testing.
+ */
+export function noCacheNormalize(path: string): Path {
   if (path == '' || path == '.') {
     return '' as Path;
   } else if (path == NormalizedRoot) {

packages/angular_devkit/core/src/virtual-fs/path_benchmark.ts

@@ -7,14 +7,82 @@
  */
 // tslint:disable:no-implicit-dependencies
 import { benchmark } from '@_/benchmark';
-import { join, normalize } from './path';
+import { join, noCacheNormalize, normalize, resetNormalizeCache } from './path';
+
+const seedrandom = require('seedrandom');
 
 
 const p1 = '/b/././a/tt/../../../a/b/./d/../c';
 const p2 = '/a/tt/../../../a/b/./d';
 
 
+const numRandomIter = 10000;
+
+
 describe('Virtual FS Path', () => {
-  benchmark('normalize', () => normalize(p1));
-  benchmark('join', () => join(normalize(p1), normalize(p2)));
+  benchmark('join', () => join(normalize(p1), p2));
+
+  describe('normalize', () => {
+    let rng: () => number;
+    let cases: string[];
+
+    // Math.random() doesn't allow us to set a seed, so we use a library.
+    beforeEach(() => {
+      rng = seedrandom('some fixed value');
+
+      function _str(len: number) {
+        let r = '';
+        const space = 'abcdefghijklmnopqrstuvwxyz0123456789';
+        for (let i = 0; i < len; i++) {
+          r += space[Math.floor(rng() * space.length)];
+        }
+
+        return r;
+      }
+
+      // Build test cases.
+      cases = new Array(numRandomIter)
+        .fill(0)
+        .map(() => {
+          return new Array(Math.floor(rng() * 20 + 5))
+            .fill(0)
+            .map(() => _str(rng() * 20 + 3))
+            .join('/');
+        });
+
+      resetNormalizeCache();
+    });
+
+    describe('random (0 cache hits)', () => {
+      benchmark('', i => normalize(cases[i]), i => noCacheNormalize(cases[i]));
+    });
+
+    describe('random (10% cache hits)', () => {
+      beforeEach(() => {
+        cases = cases.map(x => (rng() < 0.1) ? cases[0] : x);
+      });
+      benchmark('', i => normalize(cases[i]), i => noCacheNormalize(cases[i]));
+    });
+
+    describe('random (30% cache hits)', () => {
+      beforeEach(() => {
+        cases = cases.map(x => (rng() < 0.3) ? cases[0] : x);
+      });
+      benchmark('', i => normalize(cases[i]), i => noCacheNormalize(cases[i]));
+    });
+
+    describe('random (50% cache hits)', () => {
+      beforeEach(() => {
+        cases = cases.map(x => (rng() < 0.5) ? cases[0] : x);
+      });
+      benchmark('', i => normalize(cases[i]), i => noCacheNormalize(cases[i]));
+    });
+
+    describe('random (80% cache hits)', () => {
+      beforeEach(() => {
+        cases = cases.map(x => (rng() < 0.8) ? cases[0] : x);
+      });
+      benchmark('', i => normalize(cases[i]), i => noCacheNormalize(cases[i]));
+    });
+  });
 });

yarn.lock

@@ -6731,6 +6731,10 @@ scss-tokenizer@^0.2.3:
     js-base64 "^2.1.8"
     source-map "^0.4.2"
 
+seedrandom@^2.4.4:
+  version "2.4.4"
+  resolved "https://registry.yarnpkg.com/seedrandom/-/seedrandom-2.4.4.tgz#b25ea98632c73e45f58b77cfaa931678df01f9ba"
+
 select-hose@^2.0.0:
   version "2.0.0"
   resolved "https://registry.yarnpkg.com/select-hose/-/select-hose-2.0.0.tgz#625d8658f865af43ec962bfc376a37359a4994ca"