test/js-perf-test/ArraySort/sort-base.js

// Copyright 2018 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.

const kArraySize = 4000;
let template_array = [];

for (let i = 0; i < kArraySize; ++i) {
  template_array[i] = Math.floor(Math.random() * kArraySize);
}

let array_to_sort = [];

function AssertPackedSmiElements() {
  assert(%HasFastPackedElements(array_to_sort) &&
         %HasSmiElements(array_to_sort),
         "Element kind is not PACKED_SMI_ELEMENTS");
}

function AssertPackedDoubleElements() {
  assert(%HasFastPackedElements(array_to_sort) &&
         %HasDoubleElements(array_to_sort),
         "Element kind is not PACKED_DOUBLE_ELEMENTS");
}

function AssertPackedObjectElements() {
  assert(%HasFastPackedElements(array_to_sort) &&
         %HasObjectElements(array_to_sort),
         "Element kind is not PACKED_ELEMENTS");
}

function AssertHoleySmiElements() {
  assert(%HasHoleyElements(array_to_sort) &&
         %HasSmiElements(array_to_sort),
         "Element kind is not HOLEY_SMI_ELEMENTS");
}

function AssertHoleyDoubleElements() {
  assert(%HasHoleyElements(array_to_sort) &&
         %HasDoubleElements(array_to_sort),
         "Element kind is not HOLEY_DOUBLE_ELEMENTS");
}

function AssertHoleyObjectElements() {
  assert(%HasHoleyElements(array_to_sort) &&
         %HasObjectElements(array_to_sort),
         "Element kind is not HOLEY_ELEMENTS");
}

function AssertDictionaryElements() {
  assert(%HasDictionaryElements(array_to_sort),
         "Element kind is not DICTIONARY_ELEMENTS");
}

function CreatePackedSmiArray() {
  array_to_sort = Array.from(template_array);
  AssertPackedSmiElements();
}

function CreatePackedDoubleArray() {
  array_to_sort = Array.from(template_array, (x,_) => x + 0.1);
  AssertPackedDoubleElements();
}

function CreatePackedObjectArray() {
  array_to_sort = Array.from(template_array, (x,_) => `value ${x}`);
  AssertPackedObjectElements();
}

function CreateHoleySmiArray() {
  array_to_sort = Array.from(template_array);
  delete array_to_sort[0];
  AssertHoleySmiElements();
}

function CreateHoleyDoubleArray() {
  array_to_sort = new Array(kArraySize);
  for (let i = 0; i < kArraySize; ++i) {
    array_to_sort[i] = template_array[i] + 0.1;
  }

  AssertHoleyDoubleElements();
}

function CreateHoleyObjectArray() {
  array_to_sort = new Array(kArraySize);
  for (let i = 0; i < kArraySize; ++i) {
    array_to_sort[i] = `value ${template_array[i]}`;
  }

  AssertHoleyObjectElements();
}

function CreateDictionaryArray() {
  array_to_sort = Array.from(template_array);
  Object.defineProperty(array_to_sort, kArraySize - 2,
    { get: () => this.foo,
      set: (v) => this.foo = v });

  AssertDictionaryElements();
}

function Sort() {
  array_to_sort.sort();
}

function CreateSortFn(comparefns = []) {
  return () => {
    for (let cmpfn of comparefns) {
      array_to_sort.sort(cmpfn);
    }
  }
}

function cmp_smaller(a, b) {
  if (a < b) return -1;
  if (b < a) return 1;
  return 0;
}

function cmp_greater(a, b) { return cmp_smaller(b, a); }

// The counter is used in some benchmarks to trigger actions during sorting.
// To keep benchmarks deterministic, the counter needs to be reset for each
// iteration.
let counter = 0;

// Sorting benchmarks need to execute setup and tearDown for each iteration.
// Otherwise the benchmarks would mainly measure sorting already sorted arrays
// which, depending on the strategy, is either the worst- or best case.
function createSortSuite(name, reference, run, setup, tearDown = () => {}) {
  let run_fn = () => {
    counter = 0;

    setup();
    run();
    tearDown();
  };

  return createSuite(name, reference, run_fn);
}