| Sampler = Utilities.createClass( |
| function(seriesCount, expectedSampleCount, processor) |
| { |
| this._processor = processor; |
| |
| this.samples = []; |
| for (var i = 0; i < seriesCount; ++i) { |
| var array = new Array(expectedSampleCount); |
| array.fill(0); |
| this.samples[i] = array; |
| } |
| this.sampleCount = 0; |
| }, { |
| |
| record: function() { |
| // Assume that arguments.length == this.samples.length |
| for (var i = 0; i < arguments.length; i++) { |
| this.samples[i][this.sampleCount] = arguments[i]; |
| } |
| ++this.sampleCount; |
| }, |
| |
| processSamples: function() |
| { |
| var results = {}; |
| |
| // Remove unused capacity |
| this.samples = this.samples.map(function(array) { |
| return array.slice(0, this.sampleCount); |
| }, this); |
| |
| this._processor.processSamples(results); |
| |
| return results; |
| } |
| }); |
| |
| Controller = Utilities.createClass( |
| function(benchmark, options) |
| { |
| // Initialize timestamps relative to the start of the benchmark |
| // In start() the timestamps are offset by the start timestamp |
| this._startTimestamp = 0; |
| this._endTimestamp = options["test-interval"]; |
| // Default data series: timestamp, complexity, estimatedFrameLength |
| var sampleSize = options["sample-capacity"] || (60 * options["test-interval"] / 1000); |
| this._sampler = new Sampler(options["series-count"] || 3, sampleSize, this); |
| this._marks = {}; |
| |
| this._frameLengthEstimator = new SimpleKalmanEstimator(options["kalman-process-error"], options["kalman-measurement-error"]); |
| this._isFrameLengthEstimatorEnabled = true; |
| |
| // Length of subsequent intervals; a value of 0 means use no intervals |
| this.intervalSamplingLength = 100; |
| |
| this.initialComplexity = 1; |
| }, { |
| |
| set isFrameLengthEstimatorEnabled(enabled) { |
| this._isFrameLengthEstimatorEnabled = enabled; |
| }, |
| |
| start: function(startTimestamp, stage) |
| { |
| this._startTimestamp = startTimestamp; |
| this._endTimestamp += startTimestamp; |
| this._previousTimestamp = startTimestamp; |
| this._measureAndResetInterval(startTimestamp); |
| this.recordFirstSample(startTimestamp, stage); |
| }, |
| |
| recordFirstSample: function(startTimestamp, stage) |
| { |
| this._sampler.record(startTimestamp, stage.complexity(), -1); |
| this.mark(Strings.json.samplingStartTimeOffset, startTimestamp); |
| }, |
| |
| mark: function(comment, timestamp, data) { |
| data = data || {}; |
| data.time = timestamp; |
| data.index = this._sampler.sampleCount; |
| this._marks[comment] = data; |
| }, |
| |
| containsMark: function(comment) { |
| return comment in this._marks; |
| }, |
| |
| _measureAndResetInterval: function(currentTimestamp) |
| { |
| var sampleCount = this._sampler.sampleCount; |
| var averageFrameLength = 0; |
| |
| if (this._intervalEndTimestamp) { |
| var intervalStartTimestamp = this._sampler.samples[0][this._intervalStartIndex]; |
| averageFrameLength = (currentTimestamp - intervalStartTimestamp) / (sampleCount - this._intervalStartIndex); |
| } |
| |
| this._intervalStartIndex = sampleCount; |
| this._intervalEndTimestamp = currentTimestamp + this.intervalSamplingLength; |
| |
| return averageFrameLength; |
| }, |
| |
| update: function(timestamp, stage) |
| { |
| var lastFrameLength = timestamp - this._previousTimestamp; |
| this._previousTimestamp = timestamp; |
| |
| var frameLengthEstimate = -1, intervalAverageFrameLength = -1; |
| var didFinishInterval = false; |
| if (!this.intervalSamplingLength) { |
| if (this._isFrameLengthEstimatorEnabled) { |
| this._frameLengthEstimator.sample(lastFrameLength); |
| frameLengthEstimate = this._frameLengthEstimator.estimate; |
| } |
| } else if (timestamp >= this._intervalEndTimestamp) { |
| var intervalStartTimestamp = this._sampler.samples[0][this._intervalStartIndex]; |
| intervalAverageFrameLength = this._measureAndResetInterval(timestamp); |
| if (this._isFrameLengthEstimatorEnabled) { |
| this._frameLengthEstimator.sample(intervalAverageFrameLength); |
| frameLengthEstimate = this._frameLengthEstimator.estimate; |
| } |
| didFinishInterval = true; |
| this.didFinishInterval(timestamp, stage, intervalAverageFrameLength); |
| } |
| |
| this._sampler.record(timestamp, stage.complexity(), frameLengthEstimate); |
| this.tune(timestamp, stage, lastFrameLength, didFinishInterval, intervalAverageFrameLength); |
| }, |
| |
| didFinishInterval: function(timestamp, stage, intervalAverageFrameLength) |
| { |
| }, |
| |
| tune: function(timestamp, stage, lastFrameLength, didFinishInterval, intervalAverageFrameLength) |
| { |
| }, |
| |
| shouldStop: function(timestamp) |
| { |
| return timestamp > this._endTimestamp; |
| }, |
| |
| results: function() |
| { |
| return this._sampler.processSamples(); |
| }, |
| |
| _processComplexitySamples: function(complexitySamples, complexityAverageSamples) |
| { |
| complexityAverageSamples.addField(Strings.json.complexity, 0); |
| complexityAverageSamples.addField(Strings.json.frameLength, 1); |
| complexityAverageSamples.addField(Strings.json.measurements.stdev, 2); |
| |
| complexitySamples.sort(function(a, b) { |
| return complexitySamples.getFieldInDatum(a, Strings.json.complexity) - complexitySamples.getFieldInDatum(b, Strings.json.complexity); |
| }); |
| |
| // Samples averaged based on complexity |
| var currentComplexity = -1; |
| var experimentAtComplexity; |
| function addSample() { |
| var mean = experimentAtComplexity.mean(); |
| var stdev = experimentAtComplexity.standardDeviation(); |
| |
| var averageSample = complexityAverageSamples.createDatum(); |
| complexityAverageSamples.push(averageSample); |
| complexityAverageSamples.setFieldInDatum(averageSample, Strings.json.complexity, currentComplexity); |
| complexityAverageSamples.setFieldInDatum(averageSample, Strings.json.frameLength, mean); |
| complexityAverageSamples.setFieldInDatum(averageSample, Strings.json.measurements.stdev, stdev); |
| } |
| complexitySamples.forEach(function(sample) { |
| var sampleComplexity = complexitySamples.getFieldInDatum(sample, Strings.json.complexity); |
| if (sampleComplexity != currentComplexity) { |
| if (currentComplexity > -1) |
| addSample(); |
| |
| currentComplexity = sampleComplexity; |
| experimentAtComplexity = new Experiment; |
| } |
| experimentAtComplexity.sample(complexitySamples.getFieldInDatum(sample, Strings.json.frameLength)); |
| }); |
| // Finish off the last one |
| addSample(); |
| }, |
| |
| processSamples: function(results) |
| { |
| var complexityExperiment = new Experiment; |
| var smoothedFrameLengthExperiment = new Experiment; |
| |
| var samples = this._sampler.samples; |
| |
| for (var markName in this._marks) |
| this._marks[markName].time -= this._startTimestamp; |
| results[Strings.json.marks] = this._marks; |
| |
| results[Strings.json.samples] = {}; |
| |
| var controllerSamples = new SampleData; |
| results[Strings.json.samples][Strings.json.controller] = controllerSamples; |
| |
| controllerSamples.addField(Strings.json.time, 0); |
| controllerSamples.addField(Strings.json.complexity, 1); |
| controllerSamples.addField(Strings.json.frameLength, 2); |
| controllerSamples.addField(Strings.json.smoothedFrameLength, 3); |
| |
| var complexitySamples = new SampleData(controllerSamples.fieldMap); |
| results[Strings.json.samples][Strings.json.complexity] = complexitySamples; |
| |
| samples[0].forEach(function(timestamp, i) { |
| var sample = controllerSamples.createDatum(); |
| controllerSamples.push(sample); |
| complexitySamples.push(sample); |
| |
| // Represent time in milliseconds |
| controllerSamples.setFieldInDatum(sample, Strings.json.time, timestamp - this._startTimestamp); |
| controllerSamples.setFieldInDatum(sample, Strings.json.complexity, samples[1][i]); |
| |
| if (i == 0) |
| controllerSamples.setFieldInDatum(sample, Strings.json.frameLength, 1000/60); |
| else |
| controllerSamples.setFieldInDatum(sample, Strings.json.frameLength, timestamp - samples[0][i - 1]); |
| |
| if (samples[2][i] != -1) |
| controllerSamples.setFieldInDatum(sample, Strings.json.smoothedFrameLength, samples[2][i]); |
| }, this); |
| |
| var complexityAverageSamples = new SampleData; |
| results[Strings.json.samples][Strings.json.complexityAverage] = complexityAverageSamples; |
| this._processComplexitySamples(complexitySamples, complexityAverageSamples); |
| } |
| }); |
| |
| FixedController = Utilities.createSubclass(Controller, |
| function(benchmark, options) |
| { |
| Controller.call(this, benchmark, options); |
| this.initialComplexity = options["complexity"]; |
| this.intervalSamplingLength = 0; |
| } |
| ); |
| |
| StepController = Utilities.createSubclass(Controller, |
| function(benchmark, options) |
| { |
| Controller.call(this, benchmark, options); |
| this.initialComplexity = options["complexity"]; |
| this.intervalSamplingLength = 0; |
| this._stepped = false; |
| this._stepTime = options["test-interval"] / 2; |
| }, { |
| |
| start: function(startTimestamp, stage) |
| { |
| Controller.prototype.start.call(this, startTimestamp, stage); |
| this._stepTime += startTimestamp; |
| }, |
| |
| tune: function(timestamp, stage) |
| { |
| if (this._stepped || timestamp < this._stepTime) |
| return; |
| |
| this.mark(Strings.json.samplingEndTimeOffset, timestamp); |
| this._stepped = true; |
| stage.tune(stage.complexity() * 3); |
| } |
| }); |
| |
| AdaptiveController = Utilities.createSubclass(Controller, |
| function(benchmark, options) |
| { |
| // Data series: timestamp, complexity, estimatedIntervalFrameLength |
| Controller.call(this, benchmark, options); |
| |
| // All tests start at 0, so we expect to see 60 fps quickly. |
| this._samplingTimestamp = options["test-interval"] / 2; |
| this._startedSampling = false; |
| this._targetFrameRate = options["frame-rate"]; |
| this._pid = new PIDController(this._targetFrameRate); |
| |
| this._intervalFrameCount = 0; |
| this._numberOfFramesToMeasurePerInterval = 4; |
| }, { |
| |
| start: function(startTimestamp, stage) |
| { |
| Controller.prototype.start.call(this, startTimestamp, stage); |
| |
| this._samplingTimestamp += startTimestamp; |
| this._intervalTimestamp = startTimestamp; |
| }, |
| |
| recordFirstSample: function(startTimestamp, stage) |
| { |
| this._sampler.record(startTimestamp, stage.complexity(), -1); |
| }, |
| |
| update: function(timestamp, stage) |
| { |
| if (!this._startedSampling && timestamp >= this._samplingTimestamp) { |
| this._startedSampling = true; |
| this.mark(Strings.json.samplingStartTimeOffset, this._samplingTimestamp); |
| } |
| |
| // Start the work for the next frame. |
| ++this._intervalFrameCount; |
| |
| if (this._intervalFrameCount < this._numberOfFramesToMeasurePerInterval) { |
| this._sampler.record(timestamp, stage.complexity(), -1); |
| return; |
| } |
| |
| // Adjust the test to reach the desired FPS. |
| var intervalLength = timestamp - this._intervalTimestamp; |
| this._frameLengthEstimator.sample(intervalLength / this._numberOfFramesToMeasurePerInterval); |
| var intervalEstimatedFrameRate = 1000 / this._frameLengthEstimator.estimate; |
| var tuneValue = -this._pid.tune(timestamp - this._startTimestamp, intervalLength, intervalEstimatedFrameRate); |
| tuneValue = tuneValue > 0 ? Math.floor(tuneValue) : Math.ceil(tuneValue); |
| stage.tune(tuneValue); |
| |
| this._sampler.record(timestamp, stage.complexity(), this._frameLengthEstimator.estimate); |
| |
| // Start the next interval. |
| this._intervalFrameCount = 0; |
| this._intervalTimestamp = timestamp; |
| } |
| }); |
| |
| RampController = Utilities.createSubclass(Controller, |
| function(benchmark, options) |
| { |
| // The tier warmup takes at most 5 seconds |
| options["sample-capacity"] = (options["test-interval"] / 1000 + 5) * 60; |
| Controller.call(this, benchmark, options); |
| |
| // Initially start with a tier test to find the bounds |
| // The number of objects in a tier test is 10^|_tier| |
| this._tier = -.5; |
| // The timestamp is first set after the first interval completes |
| this._tierStartTimestamp = 0; |
| this._minimumComplexity = 1; |
| this._maximumComplexity = 1; |
| |
| // After the tier range is determined, figure out the number of ramp iterations |
| var minimumRampLength = 3000; |
| var totalRampIterations = Math.max(1, Math.floor(this._endTimestamp / minimumRampLength)); |
| // Give a little extra room to run since the ramps won't be exactly this length |
| this._rampLength = Math.floor((this._endTimestamp - totalRampIterations * this.intervalSamplingLength) / totalRampIterations); |
| this._rampDidWarmup = false; |
| this._rampRegressions = []; |
| |
| this._finishedTierSampling = false; |
| this._changePointEstimator = new Experiment; |
| this._minimumComplexityEstimator = new Experiment; |
| // Estimates all frames within an interval |
| this._intervalFrameLengthEstimator = new Experiment; |
| }, { |
| |
| // If the engine can handle the tier's complexity at the desired frame rate, test for a short |
| // period, then move on to the next tier |
| tierFastTestLength: 250, |
| // If the engine is under stress, let the test run a little longer to let the measurement settle |
| tierSlowTestLength: 750, |
| |
| rampWarmupLength: 200, |
| |
| // Used for regression calculations in the ramps |
| frameLengthDesired: 1000/60, |
| // Add some tolerance; frame lengths shorter than this are considered to be @ the desired frame length |
| frameLengthDesiredThreshold: 1000/58, |
| // During tier sampling get at least this slow to find the right complexity range |
| frameLengthTierThreshold: 1000/30, |
| // Try to make each ramp get this slow so that we can cross the break point |
| frameLengthRampLowerThreshold: 1000/45, |
| // Do not let the regression calculation at the maximum complexity of a ramp get slower than this threshold |
| frameLengthRampUpperThreshold: 1000/20, |
| |
| start: function(startTimestamp, stage) |
| { |
| Controller.prototype.start.call(this, startTimestamp, stage); |
| this._rampStartTimestamp = 0; |
| this.intervalSamplingLength = 100; |
| }, |
| |
| didFinishInterval: function(timestamp, stage, intervalAverageFrameLength) |
| { |
| if (!this._finishedTierSampling) { |
| if (this._tierStartTimestamp > 0 && timestamp < this._tierStartTimestamp + this.tierFastTestLength) |
| return; |
| |
| var currentComplexity = stage.complexity(); |
| var currentFrameLength = this._frameLengthEstimator.estimate; |
| if (currentFrameLength < this.frameLengthTierThreshold) { |
| var isAnimatingAt60FPS = currentFrameLength < this.frameLengthDesiredThreshold; |
| var hasFinishedSlowTierTest = timestamp > this._tierStartTimestamp + this.tierSlowTestLength; |
| |
| if (!isAnimatingAt60FPS && !hasFinishedSlowTierTest) |
| return; |
| |
| // We're measuring at 60 fps, so quickly move on to the next tier, or |
| // we've slower than 60 fps, but we've let this tier run long enough to |
| // get an estimate |
| this._lastTierComplexity = currentComplexity; |
| this._lastTierFrameLength = currentFrameLength; |
| |
| this._tier += .5; |
| var nextTierComplexity = Math.round(Math.pow(10, this._tier)); |
| stage.tune(nextTierComplexity - currentComplexity); |
| |
| // Some tests may be unable to go beyond a certain capacity. If so, don't keep moving up tiers |
| if (stage.complexity() - currentComplexity > 0 || nextTierComplexity == 1) { |
| this._tierStartTimestamp = timestamp; |
| this.mark("Complexity: " + nextTierComplexity, timestamp); |
| return; |
| } |
| } else if (timestamp < this._tierStartTimestamp + this.tierSlowTestLength) |
| return; |
| |
| this._finishedTierSampling = true; |
| this.isFrameLengthEstimatorEnabled = false; |
| this.intervalSamplingLength = 120; |
| |
| // Extend the test length so that the full test length is made of the ramps |
| this._endTimestamp += timestamp; |
| this.mark(Strings.json.samplingStartTimeOffset, timestamp); |
| |
| this._minimumComplexity = 1; |
| this._possibleMinimumComplexity = this._minimumComplexity; |
| this._minimumComplexityEstimator.sample(this._minimumComplexity); |
| |
| // Sometimes this last tier will drop the frame length well below the threshold. |
| // Avoid going down that far since it means fewer measurements are taken in the 60 fps area. |
| // Interpolate a maximum complexity that gets us around the lowest threshold. |
| // Avoid doing this calculation if we never get out of the first tier (where this._lastTierComplexity is undefined). |
| if (this._lastTierComplexity && this._lastTierComplexity != currentComplexity) |
| this._maximumComplexity = Math.floor(Utilities.lerp(Utilities.progressValue(this.frameLengthTierThreshold, this._lastTierFrameLength, currentFrameLength), this._lastTierComplexity, currentComplexity)); |
| else { |
| // If the browser is capable of handling the most complex version of the test, use that |
| this._maximumComplexity = currentComplexity; |
| } |
| this._possibleMaximumComplexity = this._maximumComplexity; |
| |
| // If we get ourselves onto a ramp where the maximum complexity does not yield slow enough FPS, |
| // We'll use this as a boundary to find a higher maximum complexity for the next ramp |
| this._lastTierComplexity = currentComplexity; |
| this._lastTierFrameLength = currentFrameLength; |
| |
| // First ramp |
| stage.tune(this._maximumComplexity - currentComplexity); |
| this._rampDidWarmup = false; |
| // Start timestamp represents start of ramp iteration and warm up |
| this._rampStartTimestamp = timestamp; |
| return; |
| } |
| |
| if ((timestamp - this._rampStartTimestamp) < this.rampWarmupLength) |
| return; |
| |
| if (this._rampDidWarmup) |
| return; |
| |
| this._rampDidWarmup = true; |
| this._currentRampLength = this._rampStartTimestamp + this._rampLength - timestamp; |
| // Start timestamp represents start of ramp down, after warm up |
| this._rampStartTimestamp = timestamp; |
| this._rampStartIndex = this._sampler.sampleCount; |
| }, |
| |
| tune: function(timestamp, stage, lastFrameLength, didFinishInterval, intervalAverageFrameLength) |
| { |
| if (!this._rampDidWarmup) |
| return; |
| |
| this._intervalFrameLengthEstimator.sample(lastFrameLength); |
| if (!didFinishInterval) |
| return; |
| |
| var currentComplexity = stage.complexity(); |
| var intervalFrameLengthMean = this._intervalFrameLengthEstimator.mean(); |
| var intervalFrameLengthStandardDeviation = this._intervalFrameLengthEstimator.standardDeviation(); |
| |
| if (intervalFrameLengthMean < this.frameLengthDesiredThreshold && this._intervalFrameLengthEstimator.cdf(this.frameLengthDesiredThreshold) > .9) { |
| this._possibleMinimumComplexity = Math.max(this._possibleMinimumComplexity, currentComplexity); |
| } else if (intervalFrameLengthStandardDeviation > 2) { |
| // In the case where we might have found a previous interval where 60fps was reached. We hit a significant blip, |
| // so we should resample this area in the next ramp. |
| this._possibleMinimumComplexity = 1; |
| } |
| if (intervalFrameLengthMean - intervalFrameLengthStandardDeviation > this.frameLengthRampLowerThreshold) |
| this._possibleMaximumComplexity = Math.min(this._possibleMaximumComplexity, currentComplexity); |
| this._intervalFrameLengthEstimator.reset(); |
| |
| var progress = (timestamp - this._rampStartTimestamp) / this._currentRampLength; |
| |
| if (progress < 1) { |
| // Reframe progress percentage so that the last interval of the ramp can sample at minimum complexity |
| progress = (timestamp - this._rampStartTimestamp) / (this._currentRampLength - this.intervalSamplingLength); |
| stage.tune(Math.max(this._minimumComplexity, Math.floor(Utilities.lerp(progress, this._maximumComplexity, this._minimumComplexity))) - currentComplexity); |
| return; |
| } |
| |
| var regression = new Regression(this._sampler.samples, this._getComplexity, this._getFrameLength, |
| this._sampler.sampleCount - 1, this._rampStartIndex, { desiredFrameLength: this.frameLengthDesired }); |
| this._rampRegressions.push(regression); |
| |
| var frameLengthAtMaxComplexity = regression.valueAt(this._maximumComplexity); |
| if (frameLengthAtMaxComplexity < this.frameLengthRampLowerThreshold) |
| this._possibleMaximumComplexity = Math.floor(Utilities.lerp(Utilities.progressValue(this.frameLengthRampLowerThreshold, frameLengthAtMaxComplexity, this._lastTierFrameLength), this._maximumComplexity, this._lastTierComplexity)); |
| // If the regression doesn't fit the first segment at all, keep the minimum bound at 1 |
| if ((timestamp - this._sampler.samples[0][this._sampler.sampleCount - regression.n1]) / this._currentRampLength < .25) |
| this._possibleMinimumComplexity = 1; |
| |
| this._minimumComplexityEstimator.sample(this._possibleMinimumComplexity); |
| this._minimumComplexity = Math.round(this._minimumComplexityEstimator.mean()); |
| |
| if (frameLengthAtMaxComplexity < this.frameLengthRampUpperThreshold) { |
| this._changePointEstimator.sample(regression.complexity); |
| // Ideally we'll target the change point in the middle of the ramp. If the range of the ramp is too small, there isn't enough |
| // range along the complexity (x) axis for a good regression calculation to be made, so force at least a range of 5 |
| // particles. Make it possible to increase the maximum complexity in case unexpected noise caps the regression too low. |
| this._maximumComplexity = Math.round(this._minimumComplexity + |
| Math.max(5, |
| this._possibleMaximumComplexity - this._minimumComplexity, |
| (this._changePointEstimator.mean() - this._minimumComplexity) * 2)); |
| } else { |
| // The slowest samples weighed the regression too heavily |
| this._maximumComplexity = Math.max(Math.round(.8 * this._maximumComplexity), this._minimumComplexity + 5); |
| } |
| |
| // Next ramp |
| stage.tune(this._maximumComplexity - stage.complexity()); |
| this._rampDidWarmup = false; |
| // Start timestamp represents start of ramp iteration and warm up |
| this._rampStartTimestamp = timestamp; |
| this._possibleMinimumComplexity = 1; |
| this._possibleMaximumComplexity = this._maximumComplexity; |
| }, |
| |
| _getComplexity: function(samples, i) { |
| return samples[1][i]; |
| }, |
| |
| _getFrameLength: function(samples, i) { |
| return samples[0][i] - samples[0][i - 1]; |
| }, |
| |
| processSamples: function(results) |
| { |
| Controller.prototype.processSamples.call(this, results); |
| |
| // Have samplingTimeOffset represent time 0 |
| var startTimestamp = this._marks[Strings.json.samplingStartTimeOffset].time; |
| |
| for (var markName in results[Strings.json.marks]) { |
| results[Strings.json.marks][markName].time -= startTimestamp; |
| } |
| |
| var controllerSamples = results[Strings.json.samples][Strings.json.controller]; |
| controllerSamples.forEach(function(timeSample) { |
| controllerSamples.setFieldInDatum(timeSample, Strings.json.time, controllerSamples.getFieldInDatum(timeSample, Strings.json.time) - startTimestamp); |
| }); |
| |
| // Aggregate all of the ramps into one big complexity-frameLength dataset |
| var complexitySamples = new SampleData(controllerSamples.fieldMap); |
| results[Strings.json.samples][Strings.json.complexity] = complexitySamples; |
| |
| results[Strings.json.controller] = []; |
| this._rampRegressions.forEach(function(ramp) { |
| var startIndex = ramp.startIndex, endIndex = ramp.endIndex; |
| var startTime = controllerSamples.getFieldInDatum(startIndex, Strings.json.time); |
| var endTime = controllerSamples.getFieldInDatum(endIndex, Strings.json.time); |
| var startComplexity = controllerSamples.getFieldInDatum(startIndex, Strings.json.complexity); |
| var endComplexity = controllerSamples.getFieldInDatum(endIndex, Strings.json.complexity); |
| |
| var regression = {}; |
| results[Strings.json.controller].push(regression); |
| |
| var percentage = (ramp.complexity - startComplexity) / (endComplexity - startComplexity); |
| var inflectionTime = startTime + percentage * (endTime - startTime); |
| |
| regression[Strings.json.regressions.segment1] = [ |
| [startTime, ramp.s2 + ramp.t2 * startComplexity], |
| [inflectionTime, ramp.s2 + ramp.t2 * ramp.complexity] |
| ]; |
| regression[Strings.json.regressions.segment2] = [ |
| [inflectionTime, ramp.s1 + ramp.t1 * ramp.complexity], |
| [endTime, ramp.s1 + ramp.t1 * endComplexity] |
| ]; |
| regression[Strings.json.complexity] = ramp.complexity; |
| regression[Strings.json.regressions.startIndex] = startIndex; |
| regression[Strings.json.regressions.endIndex] = endIndex; |
| regression[Strings.json.regressions.profile] = ramp.profile; |
| |
| for (var j = startIndex; j <= endIndex; ++j) |
| complexitySamples.push(controllerSamples.at(j)); |
| }); |
| |
| var complexityAverageSamples = new SampleData; |
| results[Strings.json.samples][Strings.json.complexityAverage] = complexityAverageSamples; |
| this._processComplexitySamples(complexitySamples, complexityAverageSamples); |
| } |
| }); |
| |
| Ramp30Controller = Utilities.createSubclass(RampController, |
| function(benchmark, options) |
| { |
| RampController.call(this, benchmark, options); |
| }, { |
| |
| frameLengthDesired: 1000/30, |
| frameLengthDesiredThreshold: 1000/29, |
| frameLengthTierThreshold: 1000/20, |
| frameLengthRampLowerThreshold: 1000/20, |
| frameLengthRampUpperThreshold: 1000/12 |
| }); |
| |
| Stage = Utilities.createClass( |
| function() |
| { |
| }, { |
| |
| initialize: function(benchmark) |
| { |
| this._benchmark = benchmark; |
| this._element = document.getElementById("stage"); |
| this._element.setAttribute("width", document.body.offsetWidth); |
| this._element.setAttribute("height", document.body.offsetHeight); |
| this._size = Point.elementClientSize(this._element).subtract(Insets.elementPadding(this._element).size); |
| }, |
| |
| get element() |
| { |
| return this._element; |
| }, |
| |
| get size() |
| { |
| return this._size; |
| }, |
| |
| complexity: function() |
| { |
| return 0; |
| }, |
| |
| tune: function() |
| { |
| throw "Not implemented"; |
| }, |
| |
| animate: function() |
| { |
| throw "Not implemented"; |
| }, |
| |
| clear: function() |
| { |
| return this.tune(-this.tune(0)); |
| } |
| }); |
| |
| Utilities.extendObject(Stage, { |
| random: function(min, max) |
| { |
| return (Pseudo.random() * (max - min)) + min; |
| }, |
| |
| randomBool: function() |
| { |
| return !!Math.round(Pseudo.random()); |
| }, |
| |
| randomSign: function() |
| { |
| return Pseudo.random() >= .5 ? 1 : -1; |
| }, |
| |
| randomInt: function(min, max) |
| { |
| return Math.floor(this.random(min, max + 1)); |
| }, |
| |
| randomPosition: function(maxPosition) |
| { |
| return new Point(this.randomInt(0, maxPosition.x), this.randomInt(0, maxPosition.y)); |
| }, |
| |
| randomSquareSize: function(min, max) |
| { |
| var side = this.random(min, max); |
| return new Point(side, side); |
| }, |
| |
| randomVelocity: function(maxVelocity) |
| { |
| return this.random(maxVelocity / 8, maxVelocity); |
| }, |
| |
| randomAngle: function() |
| { |
| return this.random(0, Math.PI * 2); |
| }, |
| |
| randomColor: function() |
| { |
| var min = 32; |
| var max = 256 - 32; |
| return "#" |
| + this.randomInt(min, max).toString(16) |
| + this.randomInt(min, max).toString(16) |
| + this.randomInt(min, max).toString(16); |
| }, |
| |
| randomStyleMixBlendMode: function() |
| { |
| var mixBlendModeList = [ |
| 'normal', |
| 'multiply', |
| 'screen', |
| 'overlay', |
| 'darken', |
| 'lighten', |
| 'color-dodge', |
| 'color-burn', |
| 'hard-light', |
| 'soft-light', |
| 'difference', |
| 'exclusion', |
| 'hue', |
| 'saturation', |
| 'color', |
| 'luminosity' |
| ]; |
| |
| return mixBlendModeList[this.randomInt(0, mixBlendModeList.length)]; |
| }, |
| |
| randomStyleFilter: function() |
| { |
| var filterList = [ |
| 'grayscale(50%)', |
| 'sepia(50%)', |
| 'saturate(50%)', |
| 'hue-rotate(180)', |
| 'invert(50%)', |
| 'opacity(50%)', |
| 'brightness(50%)', |
| 'contrast(50%)', |
| 'blur(10px)', |
| 'drop-shadow(10px 10px 10px gray)' |
| ]; |
| |
| return filterList[this.randomInt(0, filterList.length)]; |
| }, |
| |
| randomElementInArray: function(array) |
| { |
| return array[Stage.randomInt(0, array.length - 1)]; |
| }, |
| |
| rotatingColor: function(cycleLengthMs, saturation, lightness) |
| { |
| return "hsl(" |
| + Stage.dateFractionalValue(cycleLengthMs) * 360 + ", " |
| + ((saturation || .8) * 100).toFixed(0) + "%, " |
| + ((lightness || .35) * 100).toFixed(0) + "%)"; |
| }, |
| |
| // Returns a fractional value that wraps around within [0,1] |
| dateFractionalValue: function(cycleLengthMs) |
| { |
| return (Date.now() / (cycleLengthMs || 2000)) % 1; |
| }, |
| |
| // Returns an increasing value slowed down by factor |
| dateCounterValue: function(factor) |
| { |
| return Date.now() / factor; |
| }, |
| |
| randomRotater: function() |
| { |
| return new Rotater(this.random(1000, 10000)); |
| } |
| }); |
| |
| Rotater = Utilities.createClass( |
| function(rotateInterval) |
| { |
| this._timeDelta = 0; |
| this._rotateInterval = rotateInterval; |
| this._isSampling = false; |
| }, { |
| |
| get interval() |
| { |
| return this._rotateInterval; |
| }, |
| |
| next: function(timeDelta) |
| { |
| this._timeDelta = (this._timeDelta + timeDelta) % this._rotateInterval; |
| }, |
| |
| degree: function() |
| { |
| return (360 * this._timeDelta) / this._rotateInterval; |
| }, |
| |
| rotateZ: function() |
| { |
| return "rotateZ(" + Math.floor(this.degree()) + "deg)"; |
| }, |
| |
| rotate: function(center) |
| { |
| return "rotate(" + Math.floor(this.degree()) + ", " + center.x + "," + center.y + ")"; |
| } |
| }); |
| |
| Benchmark = Utilities.createClass( |
| function(stage, options) |
| { |
| this._animateLoop = this._animateLoop.bind(this); |
| |
| this._stage = stage; |
| this._stage.initialize(this, options); |
| |
| switch (options["time-measurement"]) |
| { |
| case "performance": |
| if (window.performance && window.performance.now) |
| this._getTimestamp = performance.now.bind(performance); |
| else |
| this._getTimestamp = null; |
| break; |
| case "raf": |
| this._getTimestamp = null; |
| break; |
| case "date": |
| this._getTimestamp = Date.now; |
| break; |
| } |
| |
| options["test-interval"] *= 1000; |
| switch (options["controller"]) |
| { |
| case "fixed": |
| this._controller = new FixedController(this, options); |
| break; |
| case "step": |
| this._controller = new StepController(this, options); |
| break; |
| case "adaptive": |
| this._controller = new AdaptiveController(this, options); |
| break; |
| case "ramp": |
| this._controller = new RampController(this, options); |
| break; |
| case "ramp30": |
| this._controller = new Ramp30Controller(this, options); |
| } |
| }, { |
| |
| get stage() |
| { |
| return this._stage; |
| }, |
| |
| get timestamp() |
| { |
| return this._currentTimestamp - this._startTimestamp; |
| }, |
| |
| backgroundColor: function() |
| { |
| var stage = window.getComputedStyle(document.getElementById("stage")); |
| return stage["background-color"]; |
| }, |
| |
| run: function() |
| { |
| return this.waitUntilReady().then(function() { |
| this._finishPromise = new SimplePromise; |
| this._previousTimestamp = undefined; |
| this._didWarmUp = false; |
| this._stage.tune(this._controller.initialComplexity - this._stage.complexity()); |
| this._animateLoop(); |
| return this._finishPromise; |
| }.bind(this)); |
| }, |
| |
| // Subclasses should override this if they have setup to do prior to commencing. |
| waitUntilReady: function() |
| { |
| var promise = new SimplePromise; |
| promise.resolve(); |
| return promise; |
| }, |
| |
| _animateLoop: function(timestamp) |
| { |
| timestamp = (this._getTimestamp && this._getTimestamp()) || timestamp; |
| this._currentTimestamp = timestamp; |
| |
| if (this._controller.shouldStop(timestamp)) { |
| this._finishPromise.resolve(this._controller.results()); |
| return; |
| } |
| |
| if (!this._didWarmUp) { |
| if (!this._previousTimestamp) |
| this._previousTimestamp = timestamp; |
| else if (timestamp - this._previousTimestamp >= 100) { |
| this._didWarmUp = true; |
| this._startTimestamp = timestamp; |
| this._controller.start(timestamp, this._stage); |
| this._previousTimestamp = timestamp; |
| } |
| |
| this._stage.animate(0); |
| requestAnimationFrame(this._animateLoop); |
| return; |
| } |
| |
| this._controller.update(timestamp, this._stage); |
| this._stage.animate(timestamp - this._previousTimestamp); |
| this._previousTimestamp = timestamp; |
| requestAnimationFrame(this._animateLoop); |
| } |
| }); |
