catapult/tracing/tracing/metrics/blink/gc_metric_test.html - platform/external/chromium-trace - Git at Google

 <!DOCTYPE html>
 <!--
 Copyright 2016 The Chromium Authors. All rights reserved.
 Use of this source code is governed by a BSD-style license that can be
 found in the LICENSE file.
 -->

 <link rel="import" href="/tracing/core/test_utils.html">
 <link rel="import" href="/tracing/extras/importer/trace_event_importer.html">
 <link rel="import" href="/tracing/metrics/blink/gc_metric.html">
 <link rel="import" href="/tracing/model/slice_group.html">
 <link rel="import" href="/tracing/value/value_set.html">

 <script>
 'use strict';

 tr.b.unittest.testSuite(function() {

   function createModel(start, end, slices) {
     var opts = {
       customizeModelCallback: function(model) {
         var process = model.getOrCreateProcess(1);
         var thread = process.getOrCreateThread(2);
         var group = thread.sliceGroup;
         slices.forEach(function(slice) {
           group.pushSlice(tr.c.TestUtils.newSliceEx(slice));
         });
         group.createSubSlices();
       }
     };
     var model = tr.c.TestUtils.newModelWithEvents([], opts);
     return model;
   }

   function constructName(name, suffix) {
     return name + '_' + suffix;
   }

   function run(slices) {
     var values = new tr.v.ValueSet();
     var startTime = slices.reduce((acc, slice) => (Math.min(acc, slice.start)));
     var endTime = slices.reduce((acc, slice) => (Math.max(acc, slice.end)));
     var model = createModel(startTime - 1, endTime + 1, slices);
     tr.metrics.blink.blinkGcMetric(values, model);
     var result = {};
     values.valueDicts.forEach(function(value) {
       result[value.name] = value.numeric.value;
     });
     return result;
   }

   test('topEvents', function() {
     var events = {
       'BlinkGCMarking': 'blink-gc-marking',
       'ThreadState::completeSweep': 'blink-gc-complete-sweep',
       'ThreadState::performIdleLazySweep': 'blink-gc-idle-lazy-sweep'
     };
     tr.b.iterItems(events, function(timelineName, telemetryName) {
       var slices = [
         {
           title: timelineName, args: {}, start: 100, end: 200,
           cpuStart: 100, cpuEnd: 200
         }
       ];
       var actual = run(slices);
       var expected = {
         sum: 100,
         count: 1,
         avg: 100,
         max: 100,
         idle_deadline_overrun_sum: 0,
         idle_deadline_overrun_avg: 0,
         idle_deadline_overrun_max: 0,
         outside_idle_sum: 100,
         outside_idle_avg: 100,
         outside_idle_max: 100,
         percentage_idle: 0
       };
       tr.b.iterItems(expected, function(key, value) {
         var name = constructName(telemetryName, key);
         assert.equal(name + ':' + actual[name], name + ':' + value);
       });
       assert.closeTo(actual[constructName(telemetryName, 'pct_090')], 100, 1);
     });
   });

   test('idleTimes', function() {
     var values = new tr.v.ValueSet();
     var slices = [
       {
         title: 'SingleThreadIdleTaskRunner::RunTask',
         args: {'allotted_time_ms' : 100}, start: 100, end: 200,
         cpuStart: 100, cpuEnd: 200
       },
       {
         title: 'BlinkGCMarking', args: {}, start: 110, end: 190,
         cpuStart: 110, cpuEnd: 190
       }
     ];
     var actual = run(slices);
     var expected = {
       sum: 80,
       count: 1,
       avg: 80,
       max: 80,
       idle_deadline_overrun_sum: 0,
       idle_deadline_overrun_avg: 0,
       idle_deadline_overrun_max: 0,
       outside_idle_sum: 0,
       outside_idle_avg: 0,
       outside_idle_max: 0,
       percentage_idle: 100
     };
     tr.b.iterItems(expected, function(key, value) {
       var name = constructName('blink-gc-marking', key);
       assert.equal(name + ':' + actual[name], name + ':' + value);
     });
   });

   test('idleTimeOverrun', function() {
     var values = new tr.v.ValueSet();
     var slices = [
       {
         title: 'SingleThreadIdleTaskRunner::RunTask',
         args: {'allotted_time_ms' : 10}, start: 100, end: 200,
         cpuStart: 100, cpuEnd: 200
       },
       {
         title: 'BlinkGCMarking', args: {}, start: 110, end: 190,
         cpuStart: 110, cpuEnd: 190
       }
     ];
     var actual = run(slices);
     var expected = {
       sum: 80,
       count: 1,
       avg: 80,
       max: 80,
       idle_deadline_overrun_sum: 70,
       idle_deadline_overrun_avg: 70,
       idle_deadline_overrun_max: 70,
       outside_idle_sum: 70,
       outside_idle_avg: 70,
       outside_idle_max: 70,
       percentage_idle: 100 / 8
     };
     tr.b.iterItems(expected, function(key, value) {
       var name = constructName('blink-gc-marking', key);
       assert.equal(name + ':' + actual[name], name + ':' + value);
     });
   });

   test('total', function() {
     var values = new tr.v.ValueSet();
     var slices = [
       {
         title: 'BlinkGCMarking', args: {}, start: 100, end: 200,
         cpuStart: 100, cpuEnd: 200
       },
       {
         title: 'ThreadState::performIdleLazySweep', args: {}, start: 210,
         end: 290, cpuStart: 210, cpuEnd: 290
       }
     ];
     var actual = run(slices);
     var expected = {
       sum: 180,
       count: 2,
       avg: 90,
       max: 100,
       idle_deadline_overrun_sum: 0,
       idle_deadline_overrun_avg: 0,
       idle_deadline_overrun_max: 0,
       outside_idle_sum: 180,
       outside_idle_avg: 90,
       outside_idle_max: 100,
       percentage_idle: 0
     };
     tr.b.iterItems(expected, function(key, value) {
       var name = constructName('blink-gc-total', key);
       assert.equal(name + ':' + actual[name], name + ':' + value);
     });
   });

 });
 </script>
	<!DOCTYPE html>
	<!--
	Copyright 2016 The Chromium Authors. All rights reserved.
	Use of this source code is governed by a BSD-style license that can be
	found in the LICENSE file.
	-->

	<link rel="import" href="/tracing/core/test_utils.html">
	<link rel="import" href="/tracing/extras/importer/trace_event_importer.html">
	<link rel="import" href="/tracing/metrics/blink/gc_metric.html">
	<link rel="import" href="/tracing/model/slice_group.html">
	<link rel="import" href="/tracing/value/value_set.html">

	<script>
	'use strict';

	tr.b.unittest.testSuite(function() {

	function createModel(start, end, slices) {
	var opts = {
	customizeModelCallback: function(model) {
	var process = model.getOrCreateProcess(1);
	var thread = process.getOrCreateThread(2);
	var group = thread.sliceGroup;
	slices.forEach(function(slice) {
	group.pushSlice(tr.c.TestUtils.newSliceEx(slice));
	});
	group.createSubSlices();
	}
	};
	var model = tr.c.TestUtils.newModelWithEvents([], opts);
	return model;
	}

	function constructName(name, suffix) {
	return name + '_' + suffix;
	}

	function run(slices) {
	var values = new tr.v.ValueSet();
	var startTime = slices.reduce((acc, slice) => (Math.min(acc, slice.start)));
	var endTime = slices.reduce((acc, slice) => (Math.max(acc, slice.end)));
	var model = createModel(startTime - 1, endTime + 1, slices);
	tr.metrics.blink.blinkGcMetric(values, model);
	var result = {};
	values.valueDicts.forEach(function(value) {
	result[value.name] = value.numeric.value;
	});
	return result;
	}

	test('topEvents', function() {
	var events = {
	'BlinkGCMarking': 'blink-gc-marking',
	'ThreadState::completeSweep': 'blink-gc-complete-sweep',
	'ThreadState::performIdleLazySweep': 'blink-gc-idle-lazy-sweep'
	};
	tr.b.iterItems(events, function(timelineName, telemetryName) {
	var slices = [
	{
	title: timelineName, args: {}, start: 100, end: 200,
	cpuStart: 100, cpuEnd: 200
	}
	];
	var actual = run(slices);
	var expected = {
	sum: 100,
	count: 1,
	avg: 100,
	max: 100,
	idle_deadline_overrun_sum: 0,
	idle_deadline_overrun_avg: 0,
	idle_deadline_overrun_max: 0,
	outside_idle_sum: 100,
	outside_idle_avg: 100,
	outside_idle_max: 100,
	percentage_idle: 0
	};
	tr.b.iterItems(expected, function(key, value) {
	var name = constructName(telemetryName, key);
	assert.equal(name + ':' + actual[name], name + ':' + value);
	});
	assert.closeTo(actual[constructName(telemetryName, 'pct_090')], 100, 1);
	});
	});

	test('idleTimes', function() {
	var values = new tr.v.ValueSet();
	var slices = [
	{
	title: 'SingleThreadIdleTaskRunner::RunTask',
	args: {'allotted_time_ms' : 100}, start: 100, end: 200,
	cpuStart: 100, cpuEnd: 200
	},
	{
	title: 'BlinkGCMarking', args: {}, start: 110, end: 190,
	cpuStart: 110, cpuEnd: 190
	}
	];
	var actual = run(slices);
	var expected = {
	sum: 80,
	count: 1,
	avg: 80,
	max: 80,
	idle_deadline_overrun_sum: 0,
	idle_deadline_overrun_avg: 0,
	idle_deadline_overrun_max: 0,
	outside_idle_sum: 0,
	outside_idle_avg: 0,
	outside_idle_max: 0,
	percentage_idle: 100
	};
	tr.b.iterItems(expected, function(key, value) {
	var name = constructName('blink-gc-marking', key);
	assert.equal(name + ':' + actual[name], name + ':' + value);
	});
	});

	test('idleTimeOverrun', function() {
	var values = new tr.v.ValueSet();
	var slices = [
	{
	title: 'SingleThreadIdleTaskRunner::RunTask',
	args: {'allotted_time_ms' : 10}, start: 100, end: 200,
	cpuStart: 100, cpuEnd: 200
	},
	{
	title: 'BlinkGCMarking', args: {}, start: 110, end: 190,
	cpuStart: 110, cpuEnd: 190
	}
	];
	var actual = run(slices);
	var expected = {
	sum: 80,
	count: 1,
	avg: 80,
	max: 80,
	idle_deadline_overrun_sum: 70,
	idle_deadline_overrun_avg: 70,
	idle_deadline_overrun_max: 70,
	outside_idle_sum: 70,
	outside_idle_avg: 70,
	outside_idle_max: 70,
	percentage_idle: 100 / 8
	};
	tr.b.iterItems(expected, function(key, value) {
	var name = constructName('blink-gc-marking', key);
	assert.equal(name + ':' + actual[name], name + ':' + value);
	});
	});

	test('total', function() {
	var values = new tr.v.ValueSet();
	var slices = [
	{
	title: 'BlinkGCMarking', args: {}, start: 100, end: 200,
	cpuStart: 100, cpuEnd: 200
	},
	{
	title: 'ThreadState::performIdleLazySweep', args: {}, start: 210,
	end: 290, cpuStart: 210, cpuEnd: 290
	}
	];
	var actual = run(slices);
	var expected = {
	sum: 180,
	count: 2,
	avg: 90,
	max: 100,
	idle_deadline_overrun_sum: 0,
	idle_deadline_overrun_avg: 0,
	idle_deadline_overrun_max: 0,
	outside_idle_sum: 180,
	outside_idle_avg: 90,
	outside_idle_max: 100,
	percentage_idle: 0
	};
	tr.b.iterItems(expected, function(key, value) {
	var name = constructName('blink-gc-total', key);
	assert.equal(name + ':' + actual[name], name + ':' + value);
	});
	});

	});
	</script>