Upload Kmake

deps/v8/test/js-perf-test/ClassFields/classes.js

@@ -0,0 +1,117 @@
+// Copyright 2021 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+"use strict";
+
+let i = 0;
+function EvaluateSinglePublicFieldClass() {
+  return class SinglePublicFieldClass {
+    x = i;
+
+    check() {
+      return this.x === i;
+    }
+  };
+}
+
+function EvaluateMultiPublicFieldClass() {
+  return class MultiPublicFieldClass {
+    x = i;
+    y = i+1;
+    z = i+2;
+    q = i+3;
+    r = i+4;
+    a = i+5;
+
+    check() {
+      return this.x + 1 === this.y && this.y + 1 === this.z &&
+            this.z + 1 === this.q && this.q + 1 === this.r &&
+            this.r + 1 === this.a;
+    }
+  };
+}
+
+function EvaluateSinglePrivateFieldClass() {
+  return class SinglePrivateFieldClass {
+    #x = i;
+
+    check() {
+      return this.#x === i;
+    }
+  }
+}
+
+function EvaluateMultiPrivateFieldClass() {
+  return class MultiPrivateFieldClass {
+    #x = i;
+    #y = i+1;
+    #z = i+2;
+    #q = i+3;
+    #r = i+4;
+    #a = i+5;
+
+    check() {
+      return this.#x + 1 === this.#y && this.#y + 1 === this.#z &&
+            this.#z + 1 === this.#q && this.#q + 1 === this.#r &&
+            this.#r + 1 === this.#a;
+    }
+  };
+}
+
+function EvaluateSinglePrivateMethodClass() {
+  return class PrivateSingleMethodClass {
+    #x() { return 0; }
+
+    check() {
+      return this.#x() === 0;
+    }
+  };
+}
+
+function EvaluateMultiPrivateMethodClass() {
+  return class PrivateMultiMethodClass {
+    #x() { return 0; }
+    #y() { return 1; }
+    #z() { return 2; }
+    #q() { return 3; }
+    #r() { return 4; }
+    #a() { return 5; }
+
+    check() {
+      return this.#x() + 1 === this.#y() && this.#y() + 1 === this.#z() &&
+            this.#z() + 1 === this.#q() && this.#q() + 1 === this.#r() &&
+            this.#r() + 1 === this.#a();
+    }
+  };
+}
+
+function key(i) {
+  return 'abcdefghijklmnopqrstuvwxyz'[i];
+}
+
+function EvaluateSingleComputedFieldClass() {
+  return class SingleComputedFieldClass {
+    [key(0)] = i;
+
+    check() {
+      return this[key(0)] === i;
+    }
+  }
+}
+
+function EvaluateMultiComputedFieldClass() {
+  return class MultiComputedFieldClass {
+    [key(0)] = i;
+    [key(1)] = i+1;
+    [key(2)] = i+2;
+    [key(3)] = i+3;
+    [key(4)] = i+4;
+    [key(5)] = i+5;
+
+    check() {
+      return this[key(0)] + 1 === this[key(1)] && this[key(1)] + 1 === this[key(2)] &&
+            this[key(2)] + 1 === this[key(3)] && this[key(3)] + 1 === this[key(4)] &&
+            this[key(4)] + 1 === this[key(5)];
+    }
+  };
+}

deps/v8/test/js-perf-test/ClassFields/evaluate-class.js

@@ -0,0 +1,107 @@
+// Copyright 2021 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+'use strict';
+
+d8.file.execute('classes.js');
+
+function CreateBenchmark(name, optimize) {
+  let factory;
+  let array;
+
+  switch (name) {
+    case "EvaluateSinglePublicFieldClass":
+      factory = EvaluateSinglePublicFieldClass;
+      break;
+    case "EvaluateMultiPublicFieldClass":
+      factory = EvaluateMultiPublicFieldClass;
+      break;
+    case "EvaluateSinglePrivateFieldClass":
+      factory = EvaluateSinglePrivateFieldClass;
+      break;
+    case "EvaluateMultiPrivateFieldClass":
+      factory = EvaluateMultiPrivateFieldClass;
+      break;
+    case "EvaluateSinglePrivateMethodClass":
+      factory = EvaluateSinglePrivateMethodClass;
+      break;
+    case "EvaluateMultiPrivateMethodClass":
+      factory = EvaluateMultiPrivateMethodClass;
+      break;
+    case "EvaluateSingleComputedFieldClass":
+      factory = EvaluateSingleComputedFieldClass;
+      break;
+    case "EvaluateMultiComputedFieldClass":
+      factory = EvaluateMultiComputedFieldClass;
+      break;
+    default:
+      throw new Error("Unknown optimization configuration " + arguments.join(' '));
+  }
+
+  if (optimize) {
+    %PrepareFunctionForOptimization(factory);
+  } else {
+    %NeverOptimizeFunction(factory);
+  }
+
+  function setUp() {
+    array = [factory(), factory()];
+    // Populate the array first to reduce the impact of
+    // array allocations.
+    for (let i = 0; i < LOCAL_ITERATIONS - 2; ++i) {
+      array.push(array[0]);
+    }
+    if (optimize) {
+      %OptimizeFunctionOnNextCall(factory);
+    }
+  }
+
+  function runBenchmark() {
+    for (let i = 0; i < LOCAL_ITERATIONS; ++i) {
+      array[i] = factory();
+    }
+  }
+
+  function tearDown() {
+    if (array.length < 3) {
+      throw new Error(`Check failed, array length ${array.length}`);
+    }
+
+    for (const klass of array) {
+      const instance = new klass();
+      if (!instance.check())
+        throw new Error(`instance.check() failed`);
+    }
+  }
+
+  const DETERMINISTIC_RUNS = 1;
+  const LOCAL_ITERATIONS = 100;
+
+  const benchName = `${name}${optimize ? "Opt" : "NoOpt"}`
+  new BenchmarkSuite(benchName, [1000], [
+    new Benchmark(
+      benchName,
+      false, false, DETERMINISTIC_RUNS, runBenchmark, setUp, tearDown)
+  ]);
+}
+
+let optimize;
+switch (arguments[1]) {
+  case 'opt':
+    optimize = true;
+    break;
+  case 'noopt':
+    optimize = false;
+    break;
+  default:
+    throw new Error("Unknown optimization configuration " + arguments.join(' '));
+}
+
+CreateBenchmark("EvaluateSinglePublicFieldClass", optimize);
+CreateBenchmark("EvaluateMultiPublicFieldClass", optimize);
+CreateBenchmark("EvaluateSinglePrivateFieldClass", optimize);
+CreateBenchmark("EvaluateMultiPrivateFieldClass", optimize);
+CreateBenchmark("EvaluateSinglePrivateMethodClass", optimize);
+CreateBenchmark("EvaluateMultiPrivateMethodClass", optimize);
+CreateBenchmark("EvaluateSingleComputedFieldClass", optimize);
+CreateBenchmark("EvaluateMultiComputedFieldClass", optimize);

deps/v8/test/js-perf-test/ClassFields/initialize-instance.js

@@ -0,0 +1,106 @@
+// Copyright 2021 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+'use strict';
+
+d8.file.execute('classes.js');
+
+function CreateBenchmark(name, optimize) {
+  let klass;
+  let array;
+
+  switch (name) {
+    case "InitializeSinglePublicFieldClass":
+      klass = EvaluateSinglePublicFieldClass();
+      break;
+    case "InitializeMultiPublicFieldClass":
+      klass = EvaluateMultiPublicFieldClass();
+      break;
+    case "InitializeSinglePrivateFieldClass":
+      klass = EvaluateSinglePrivateFieldClass();
+      break;
+    case "InitializeMultiPrivateFieldClass":
+      klass = EvaluateMultiPrivateFieldClass();
+      break;
+    case "InitializeSinglePrivateMethodClass":
+      klass = EvaluateSinglePrivateMethodClass();
+      break;
+    case "InitializeMultiPrivateMethodClass":
+      klass = EvaluateMultiPrivateMethodClass();
+      break;
+    case "InitializeSingleComputedFieldClass":
+      klass = EvaluateSingleComputedFieldClass();
+      break;
+    case "InitializeMultiComputedFieldClass":
+      klass = EvaluateMultiComputedFieldClass();
+      break;
+    default:
+      throw new Error("Unknown optimization configuration " + arguments.join(' '));
+  }
+
+  if (optimize) {
+    %PrepareFunctionForOptimization(klass);
+  } else {
+    %NeverOptimizeFunction(klass);
+  }
+
+  function setUp() {
+    array = [new klass(), new klass()];
+    // Populate the array first to reduce the impact of
+    // array allocations.
+    for (let i = 0; i < LOCAL_ITERATIONS - 2; ++i) {
+      array.push(array[0]);
+    }
+    if (optimize) {
+      %OptimizeFunctionOnNextCall(klass);
+    }
+  }
+
+  function runBenchmark() {
+    for (let i = 0; i < LOCAL_ITERATIONS; ++i) {
+      array[i] = new klass();
+    }
+  }
+
+  function tearDown() {
+    if (array.length < 3) {
+      throw new Error(`Check failed, array length ${array.length}`);
+    }
+
+    for (const instance of array) {
+      if (!instance.check())
+        throw new Error(`instance.check() failed`);
+    }
+  }
+
+  const DETERMINISTIC_RUNS = 1;
+  const LOCAL_ITERATIONS = 10000;
+
+  const benchName = `${name}${optimize ? "Opt" : "NoOpt"}`
+  new BenchmarkSuite(benchName, [1000], [
+    new Benchmark(
+      benchName,
+      false, false, DETERMINISTIC_RUNS, runBenchmark, setUp, tearDown)
+  ]);
+}
+
+let optimize;
+switch (arguments[1]) {
+  case 'opt':
+    optimize = true;
+    break;
+  case 'noopt':
+    optimize = false;
+    break;
+  default:
+    throw new Error("Unknown optimization configuration " + arguments.join(' '));
+}
+
+CreateBenchmark("InitializeSinglePublicFieldClass", optimize);
+CreateBenchmark("InitializeMultiPublicFieldClass", optimize);
+CreateBenchmark("InitializeSinglePrivateFieldClass", optimize);
+CreateBenchmark("InitializeMultiPrivateFieldClass", optimize);
+CreateBenchmark("InitializeSinglePrivateMethodClass", optimize);
+CreateBenchmark("InitializeMultiPrivateMethodClass", optimize);
+CreateBenchmark("InitializeSingleComputedFieldClass", optimize);
+CreateBenchmark("InitializeMultiComputedFieldClass", optimize);

deps/v8/test/js-perf-test/ClassFields/run.js

@@ -0,0 +1,25 @@
+// Copyright 2021 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+load('../base.js');
+load(arguments[0] + '.js');
+
+var success = true;
+
+function PrintResult(name, result, mean) {
+  print(`${name}-ClassFields(Score): ${result}`);
+}
+
+
+function PrintError(name, error) {
+  PrintResult(name, error);
+  success = false;
+}
+
+
+BenchmarkSuite.config.doWarmup = undefined;
+BenchmarkSuite.config.doDeterministic = undefined;
+
+BenchmarkSuite.RunSuites({ NotifyResult: PrintResult,
+                           NotifyError: PrintError });