mirror of
https://github.com/servo/servo.git
synced 2025-06-29 11:33:39 +01:00
327 lines
9.4 KiB
JavaScript
327 lines
9.4 KiB
JavaScript
// Copyright 2013, Google Inc.
|
|
// All rights reserved.
|
|
//
|
|
// Redistribution and use in source and binary forms, with or without
|
|
// modification, are permitted provided that the following conditions are
|
|
// met:
|
|
//
|
|
// * Redistributions of source code must retain the above copyright
|
|
// notice, this list of conditions and the following disclaimer.
|
|
// * Redistributions in binary form must reproduce the above
|
|
// copyright notice, this list of conditions and the following disclaimer
|
|
// in the documentation and/or other materials provided with the
|
|
// distribution.
|
|
// * Neither the name of Google Inc. nor the names of its
|
|
// contributors may be used to endorse or promote products derived from
|
|
// this software without specific prior written permission.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
|
|
// Utilities for example applications (for both main and worker thread).
|
|
|
|
var results = {};
|
|
|
|
function getTimeStamp() {
|
|
return Date.now();
|
|
}
|
|
|
|
function formatResultInKiB(size, timePerMessageInMs, stddevTimePerMessageInMs,
|
|
speed, printSize) {
|
|
if (printSize) {
|
|
return (size / 1024) +
|
|
'\t' + timePerMessageInMs.toFixed(3) +
|
|
(stddevTimePerMessageInMs == -1 ?
|
|
'' :
|
|
'\t' + stddevTimePerMessageInMs.toFixed(3)) +
|
|
'\t' + speed.toFixed(3);
|
|
} else {
|
|
return speed.toString();
|
|
}
|
|
}
|
|
|
|
function clearAverageData() {
|
|
results = {};
|
|
}
|
|
|
|
function reportAverageData(config) {
|
|
config.addToSummary(
|
|
'Size[KiB]\tAverage time[ms]\tStddev time[ms]\tSpeed[KB/s]');
|
|
for (var size in results) {
|
|
var averageTimePerMessageInMs = results[size].sum_t / results[size].n;
|
|
var speed = calculateSpeedInKB(size, averageTimePerMessageInMs);
|
|
// Calculate sample standard deviation
|
|
var stddevTimePerMessageInMs = Math.sqrt(
|
|
(results[size].sum_t2 / results[size].n -
|
|
averageTimePerMessageInMs * averageTimePerMessageInMs) *
|
|
results[size].n /
|
|
(results[size].n - 1));
|
|
config.addToSummary(formatResultInKiB(
|
|
size, averageTimePerMessageInMs, stddevTimePerMessageInMs, speed,
|
|
true));
|
|
}
|
|
}
|
|
|
|
function calculateSpeedInKB(size, timeSpentInMs) {
|
|
return Math.round(size / timeSpentInMs * 1000) / 1000;
|
|
}
|
|
|
|
function calculateAndLogResult(config, size, startTimeInMs, totalSize,
|
|
isWarmUp) {
|
|
var timeSpentInMs = getTimeStamp() - startTimeInMs;
|
|
var speed = calculateSpeedInKB(totalSize, timeSpentInMs);
|
|
var timePerMessageInMs = timeSpentInMs / (totalSize / size);
|
|
if (!isWarmUp) {
|
|
config.measureValue(timePerMessageInMs);
|
|
if (!results[size]) {
|
|
results[size] = {n: 0, sum_t: 0, sum_t2: 0};
|
|
}
|
|
results[size].n ++;
|
|
results[size].sum_t += timePerMessageInMs;
|
|
results[size].sum_t2 += timePerMessageInMs * timePerMessageInMs;
|
|
}
|
|
config.addToLog(formatResultInKiB(size, timePerMessageInMs, -1, speed,
|
|
config.printSize));
|
|
}
|
|
|
|
function repeatString(str, count) {
|
|
var data = '';
|
|
var expChunk = str;
|
|
var remain = count;
|
|
while (true) {
|
|
if (remain % 2) {
|
|
data += expChunk;
|
|
remain = (remain - 1) / 2;
|
|
} else {
|
|
remain /= 2;
|
|
}
|
|
|
|
if (remain == 0)
|
|
break;
|
|
|
|
expChunk = expChunk + expChunk;
|
|
}
|
|
return data;
|
|
}
|
|
|
|
function fillArrayBuffer(buffer, c) {
|
|
var i;
|
|
|
|
var u32Content = c * 0x01010101;
|
|
|
|
var u32Blocks = Math.floor(buffer.byteLength / 4);
|
|
var u32View = new Uint32Array(buffer, 0, u32Blocks);
|
|
// length attribute is slow on Chrome. Don't use it for loop condition.
|
|
for (i = 0; i < u32Blocks; ++i) {
|
|
u32View[i] = u32Content;
|
|
}
|
|
|
|
// Fraction
|
|
var u8Blocks = buffer.byteLength - u32Blocks * 4;
|
|
var u8View = new Uint8Array(buffer, u32Blocks * 4, u8Blocks);
|
|
for (i = 0; i < u8Blocks; ++i) {
|
|
u8View[i] = c;
|
|
}
|
|
}
|
|
|
|
function verifyArrayBuffer(buffer, expectedChar) {
|
|
var i;
|
|
|
|
var expectedU32Value = expectedChar * 0x01010101;
|
|
|
|
var u32Blocks = Math.floor(buffer.byteLength / 4);
|
|
var u32View = new Uint32Array(buffer, 0, u32Blocks);
|
|
for (i = 0; i < u32Blocks; ++i) {
|
|
if (u32View[i] != expectedU32Value) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
var u8Blocks = buffer.byteLength - u32Blocks * 4;
|
|
var u8View = new Uint8Array(buffer, u32Blocks * 4, u8Blocks);
|
|
for (i = 0; i < u8Blocks; ++i) {
|
|
if (u8View[i] != expectedChar) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
function verifyBlob(config, blob, expectedChar, doneCallback) {
|
|
var reader = new FileReader(blob);
|
|
reader.onerror = function() {
|
|
config.addToLog('FileReader Error: ' + reader.error.message);
|
|
doneCallback(blob.size, false);
|
|
}
|
|
reader.onloadend = function() {
|
|
var result = verifyArrayBuffer(reader.result, expectedChar);
|
|
doneCallback(blob.size, result);
|
|
}
|
|
reader.readAsArrayBuffer(blob);
|
|
}
|
|
|
|
function verifyAcknowledgement(config, message, size) {
|
|
if (typeof message != 'string') {
|
|
config.addToLog('Invalid ack type: ' + typeof message);
|
|
return false;
|
|
}
|
|
var parsedAck = parseInt(message);
|
|
if (isNaN(parsedAck)) {
|
|
config.addToLog('Invalid ack value: ' + message);
|
|
return false;
|
|
}
|
|
if (parsedAck != size) {
|
|
config.addToLog(
|
|
'Expected ack for ' + size + 'B but received one for ' + parsedAck +
|
|
'B');
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
function cloneConfig(obj) {
|
|
var newObj = {};
|
|
for (key in obj) {
|
|
newObj[key] = obj[key];
|
|
}
|
|
return newObj;
|
|
}
|
|
|
|
var tasks = [];
|
|
|
|
function runNextTask(config) {
|
|
var task = tasks.shift();
|
|
if (task == undefined) {
|
|
config.addToLog('Finished');
|
|
cleanup();
|
|
return;
|
|
}
|
|
timerID = setTimeout(task, 0);
|
|
}
|
|
|
|
function buildLegendString(config) {
|
|
var legend = ''
|
|
if (config.printSize)
|
|
legend = 'Message size in KiB, Time/message in ms, ';
|
|
legend += 'Speed in kB/s';
|
|
return legend;
|
|
}
|
|
|
|
function addTasks(config, stepFunc) {
|
|
for (var i = 0;
|
|
i < config.numWarmUpIterations + config.numIterations; ++i) {
|
|
var multiplierIndex = 0;
|
|
for (var size = config.startSize;
|
|
size <= config.stopThreshold;
|
|
++multiplierIndex) {
|
|
var task = stepFunc.bind(
|
|
null,
|
|
size,
|
|
config,
|
|
i < config.numWarmUpIterations);
|
|
tasks.push(task);
|
|
var multiplier = config.multipliers[
|
|
multiplierIndex % config.multipliers.length];
|
|
if (multiplier <= 1) {
|
|
config.addToLog('Invalid multiplier ' + multiplier);
|
|
config.notifyAbort();
|
|
throw new Error('Invalid multipler');
|
|
}
|
|
size = Math.ceil(size * multiplier);
|
|
}
|
|
}
|
|
}
|
|
|
|
function addResultReportingTask(config, title) {
|
|
tasks.push(function(){
|
|
timerID = null;
|
|
config.addToSummary(title);
|
|
reportAverageData(config);
|
|
clearAverageData();
|
|
runNextTask(config);
|
|
});
|
|
}
|
|
|
|
function sendBenchmark(config) {
|
|
config.addToLog('Send benchmark');
|
|
config.addToLog(buildLegendString(config));
|
|
|
|
tasks = [];
|
|
clearAverageData();
|
|
addTasks(config, sendBenchmarkStep);
|
|
addResultReportingTask(config, 'Send Benchmark ' + getConfigString(config));
|
|
startBenchmark(config);
|
|
}
|
|
|
|
function receiveBenchmark(config) {
|
|
config.addToLog('Receive benchmark');
|
|
config.addToLog(buildLegendString(config));
|
|
|
|
tasks = [];
|
|
clearAverageData();
|
|
addTasks(config, receiveBenchmarkStep);
|
|
addResultReportingTask(config,
|
|
'Receive Benchmark ' + getConfigString(config));
|
|
startBenchmark(config);
|
|
}
|
|
|
|
function stop(config) {
|
|
clearTimeout(timerID);
|
|
timerID = null;
|
|
tasks = [];
|
|
config.addToLog('Stopped');
|
|
cleanup();
|
|
}
|
|
|
|
var worker;
|
|
|
|
function initWorker(connectionType, origin) {
|
|
var scriptPath =
|
|
connectionType === 'WebSocket' ? '/benchmark.js' :
|
|
connectionType === 'XHR' ? '/xhr_benchmark.js' :
|
|
'/fetch_benchmark.js'; // connectionType === 'fetch'
|
|
worker = new Worker(origin + scriptPath);
|
|
}
|
|
|
|
function doAction(config, isWindowToWorker, action) {
|
|
if (isWindowToWorker) {
|
|
worker.onmessage = function(addToLog, addToSummary,
|
|
measureValue, notifyAbort, message) {
|
|
if (message.data.type === 'addToLog')
|
|
addToLog(message.data.data);
|
|
else if (message.data.type === 'addToSummary')
|
|
addToSummary(message.data.data);
|
|
else if (message.data.type === 'measureValue')
|
|
measureValue(message.data.data);
|
|
else if (message.data.type === 'notifyAbort')
|
|
notifyAbort();
|
|
}.bind(undefined, config.addToLog, config.addToSummary,
|
|
config.measureValue, config.notifyAbort);
|
|
config.addToLog = undefined;
|
|
config.addToSummary = undefined;
|
|
config.measureValue = undefined;
|
|
config.notifyAbort = undefined;
|
|
worker.postMessage({type: action, config: config});
|
|
} else {
|
|
if (action === 'sendBenchmark')
|
|
sendBenchmark(config);
|
|
else if (action === 'receiveBenchmark')
|
|
receiveBenchmark(config);
|
|
else if (action === 'batchBenchmark')
|
|
batchBenchmark(config);
|
|
else if (action === 'stop')
|
|
stop(config);
|
|
}
|
|
}
|