Make JetStream 2
[WebKit-https.git] / PerformanceTests / JetStream2 / ARES-6 / Air / util.js
1 /*
2  * Copyright (C) 2016 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25 "use strict";
26
27 function isRepresentableAsInt32(value)
28 {
29     return (value | 0) === value;
30 }
31
32 function addIndexed(list, cons, ...args)
33 {
34     let result = new cons(list.length, ...args);
35     list.push(result);
36     return result;
37 }
38
39 const stackAlignmentBytes = 16;
40
41 function roundUpToMultipleOf(amount, value)
42 {
43     return Math.ceil(value / amount) * amount;
44 }
45
46 function symbolName(symbol)
47 {
48     let fullString = symbol.toString();
49     return fullString.substring("Symbol(".length, fullString.length - ")".length);
50 }
51
52 function lowerSymbolName(symbol)
53 {
54     return symbolName(symbol).toLowerCase();
55 }
56
57 function setToString(set)
58 {
59     let result = "";
60     for (let value of set) {
61         if (result)
62             result += ", ";
63         result += value;
64     }
65     return result;
66 }
67
68 function mergeIntoSet(target, source)
69 {
70     let didAdd = false;
71     for (let value of source) {
72         if (target.has(value))
73             continue;
74         target.add(value);
75         didAdd = true;
76     }
77     return didAdd;
78 }
79
80 function nonEmptyRangesOverlap(leftMin, leftMax, rightMin, rightMax)
81 {
82     if (leftMin >= leftMax)
83         throw new Error("Bad left range");
84     if (rightMin >= rightMax)
85         throw new Error("Bad right range");
86     
87     if (leftMin <= rightMin && leftMax > rightMin)
88         return true;
89     if (rightMin <= leftMin && rightMax > leftMin)
90         return true;
91     return false;
92 }
93
94 function rangesOverlap(leftMin, leftMax, rightMin, rightMax)
95 {
96     if (leftMin > leftMax)
97         throw new Error("Bad left range");
98     if (rightMin > rightMax)
99         throw new Error("Bad right range");
100     
101     if (leftMin == leftMax)
102         return false;
103     if (rightMin == rightMax)
104         return false;
105     
106     return nonEmptyRangesOverlap(leftMin, leftMax, rightMin, rightMax);
107 }
108
109 function removeAllMatching(array, func)
110 {
111     let srcIndex = 0;
112     let dstIndex = 0;
113     while (srcIndex < array.length) {
114         let value = array[srcIndex++];
115         if (!func(value))
116             array[dstIndex++] = value;
117     }
118     array.length = dstIndex;
119 }
120
121 function bubbleSort(array, lessThan)
122 {
123     function swap(i, j)
124     {
125         var tmp = array[i];
126         array[i] = array[j];
127         array[j] = tmp;
128     }
129     
130     let begin = 0;
131     let end = array.length;
132     for (;;) {
133         let changed = false;
134         
135         function bubble(i, j)
136         {
137             if (lessThan(array[i], array[j])) {
138                 swap(i, j);
139                 changed = true;
140             }
141         }
142     
143         if (end < begin)
144             throw new Error("Begin and end are messed up");
145         
146         let limit = end - begin;
147         for (let i = limit; i-- > 1;)
148             bubble(begin + i, begin + i - 1);
149         if (!changed)
150             return;
151         
152         // After one run, the first element in the list is guaranteed to be the smallest.
153         begin++;
154         
155         // Now go in the other direction. This eliminates most sorting pathologies.
156         changed = false;
157         
158         if (end < begin)
159             throw new Error("Begin and end are messed up");
160         
161         limit = end - begin;
162         for (let i = 1; i < limit; ++i)
163             bubble(begin + i, begin + i - 1);
164         if (!changed)
165             return;
166         
167         // Now the last element is guaranteed to be the largest.
168         end--;
169     }
170 }
171
172 let currentTime;
173 if (this.performance && performance.now)
174     currentTime = function() { return performance.now() };
175 else if (this.preciseTime)
176     currentTime = function() { return preciseTime() * 1000; };
177 else
178     currentTime = function() { return +new Date(); };
179