catapult/tracing/tracing/metrics/v8/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/v8/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.v8.gcMetric(values, model);
     return values;
   }

   test('topEvents', function() {
     var events = {
       'V8.GCCompactor': 'v8-gc-full-mark-compactor',
       'V8.GCFinalizeMC': 'v8-gc-latency-mark-compactor',
       'V8.GCFinalizeMCReduceMemory': 'v8-gc-memory-mark-compactor',
       'V8.GCIncrementalMarking': 'v8-gc-incremental-step',
       'V8.GCIncrementalMarkingFinalize': 'v8-gc-incremental-finalize',
       'V8.GCIncrementalMarkingStart': 'v8-gc-incremental-start',
       'V8.GCPhantomHandleProcessingCallback' : 'v8-gc-phantom-handle-callback',
       'V8.GCScavenger': 'v8-gc-scavenger'
     };
     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 value = tr.b.getOnlyElement(actual.getValuesNamed(telemetryName));
       assert.strictEqual(value.running.sum, 100);
       assert.strictEqual(value.numValues, 1);
       assert.strictEqual(value.average, 100);
       assert.strictEqual(value.running.max, 100);
       assert.closeTo(value.getApproximatePercentile(0.90), 100, 1);

       value = tr.b.getOnlyElement(actual.getValuesNamed(
           telemetryName + '_idle_deadline_overrun'));
       assert.strictEqual(value.running.sum, 0);
       assert.strictEqual(value.numValues, 1);
       assert.strictEqual(value.average, 0);
       assert.strictEqual(value.running.max, 0);

       value = tr.b.getOnlyElement(actual.getValuesNamed(
           telemetryName + '_outside_idle'));
       assert.strictEqual(value.running.sum, 100);
       assert.strictEqual(value.numValues, 1);
       assert.strictEqual(value.average, 100);

       value = tr.b.getOnlyElement(actual.getValuesNamed(
           telemetryName + '_percentage_idle'));
       assert.strictEqual(value.average, 0);
     });
   });

   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: 'V8.GCFinalizeMC', args: {}, start: 110, end: 190,
         cpuStart: 110, cpuEnd: 190
       }
     ];
     var actual = run(slices);

     var value = tr.b.getOnlyElement(actual.getValuesNamed(
           'v8-gc-latency-mark-compactor'));
     assert.strictEqual(value.running.sum, 80);
     assert.strictEqual(value.numValues, 1);
     assert.strictEqual(value.average, 80);
     assert.strictEqual(value.running.max, 80);

     value = tr.b.getOnlyElement(actual.getValuesNamed(
         'v8-gc-latency-mark-compactor_idle_deadline_overrun'));
     assert.strictEqual(value.running.sum, 0);
     assert.strictEqual(value.average, 0);
     assert.strictEqual(value.running.max, 0);

     value = tr.b.getOnlyElement(actual.getValuesNamed(
         'v8-gc-latency-mark-compactor_outside_idle'));
     assert.strictEqual(value.running.sum, 0);
     assert.strictEqual(value.average, 0);
     assert.strictEqual(value.running.max, 0);

     value = tr.b.getOnlyElement(actual.getValuesNamed(
         'v8-gc-latency-mark-compactor_percentage_idle'));
     assert.strictEqual(value.average, 1);
   });

   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: 'V8.GCFinalizeMC', args: {}, start: 110, end: 190,
         cpuStart: 110, cpuEnd: 190
       }
     ];
     var actual = run(slices);

     var value = tr.b.getOnlyElement(actual.getValuesNamed(
           'v8-gc-latency-mark-compactor'));
     assert.strictEqual(value.running.sum, 80);
     assert.strictEqual(value.numValues, 1);
     assert.strictEqual(value.average, 80);
     assert.strictEqual(value.running.max, 80);

     value = tr.b.getOnlyElement(actual.getValuesNamed(
         'v8-gc-latency-mark-compactor_idle_deadline_overrun'));
     assert.strictEqual(value.running.sum, 70);
     assert.strictEqual(value.average, 70);
     assert.strictEqual(value.running.max, 70);

     value = tr.b.getOnlyElement(actual.getValuesNamed(
         'v8-gc-latency-mark-compactor_outside_idle'));
     assert.strictEqual(value.running.sum, 70);
     assert.strictEqual(value.average, 70);
     assert.strictEqual(value.running.max, 70);

     value = tr.b.getOnlyElement(actual.getValuesNamed(
         'v8-gc-latency-mark-compactor_percentage_idle'));
     assert.closeTo(value.average, 1 / 8, 1e-6);
   });

   test('subEvents', function() {
     var values = new tr.v.ValueSet();
     var slices = [
       {
         title: 'V8.GCFinalizeMC', args: {}, start: 100, end: 200,
         cpuStart: 100, cpuEnd: 200
       },
       {
         title: 'V8.GC_MC_MARK', args: {}, start: 110, end: 190,
         cpuStart: 110, cpuEnd: 190
       },
     ];
     var actual = run(slices);
     var telemetryName = 'v8-gc-latency-mark-compactor-mark';
     var value = tr.b.getOnlyElement(actual.getValuesNamed(telemetryName));
     assert.strictEqual(value.average, 80);
     assert.strictEqual(value.running.max, 80);
     assert.closeTo(value.getApproximatePercentile(0.90), 80, 1);
   });

   test('total', function() {
     var values = new tr.v.ValueSet();
     var slices = [
       {
         title: 'V8.GCFinalizeMC', args: {}, start: 100, end: 200,
         cpuStart: 100, cpuEnd: 200
       },
       {
         title: 'V8.GCIncrementalMarking', args: {}, start: 210, end: 290,
         cpuStart: 210, cpuEnd: 290
       }
     ];
     var actual = run(slices);

     var value = tr.b.getOnlyElement(actual.getValuesNamed('v8-gc-total'));
     assert.strictEqual(value.running.sum, 180);
     assert.strictEqual(value.numValues, 2);
     assert.strictEqual(value.average, 90);
     assert.strictEqual(value.running.max, 100);

     value = tr.b.getOnlyElement(actual.getValuesNamed(
         'v8-gc-total_idle_deadline_overrun'));
     assert.strictEqual(value.running.sum, 0);
     assert.strictEqual(value.average, 0);
     assert.strictEqual(value.running.max, 0);

     value = tr.b.getOnlyElement(actual.getValuesNamed(
         'v8-gc-total_outside_idle'));
     assert.strictEqual(value.running.sum, 180);
     assert.strictEqual(value.average, 90);
     assert.strictEqual(value.running.max, 100);

     value = tr.b.getOnlyElement(actual.getValuesNamed(
         'v8-gc-total_percentage_idle'));
     assert.strictEqual(value.average, 0);
   });

   test('percentageInV8Execute', function() {
     var values = new tr.v.ValueSet();
     var slices = [
       {
         title: 'V8.Execute',
         args: {}, start: 100, end: 200,
         cpuStart: 100, cpuEnd: 200
       },
       {
         title: 'V8.GCFinalizeMC', args: {}, start: 110, end: 190,
         cpuStart: 110, cpuEnd: 190
       },
       {
         title: 'V8.GCFinalizeMC', args: {}, start: 210, end: 220,
         cpuStart: 210, cpuEnd: 220
       }
     ];
     var actual = run(slices);
     var value = tr.b.getOnlyElement(actual.getValuesNamed(
         'v8-gc-latency-mark-compactor_percentage_in_v8_execute'));
     assert.strictEqual(value.average,
         (190 - 110) / ((190 - 110) + (220 - 210)));
   });

   test('mutatorUtilization', function() {
     var values = new tr.v.ValueSet();
     var slices = [
       {
         title: 'V8.Execute', args: {}, start: 100, end: 200,
         cpuStart: 100, cpuEnd: 200
       },
       {
         title: 'V8.GCFinalizeMC', args: {}, start: 150, end: 160,
         cpuStart: 150, cpuEnd: 160
       },
       {
         title: 'V8.Execute', args: {}, start: 1000, end: 1200,
         cpuStart: 1000, cpuEnd: 1200
       },
       {
         title: 'V8.GCIncrementalMarking', args: {}, start: 1010, end: 1020,
         cpuStart: 1010, cpuEnd: 1020
       }
     ];
     var mutatorUtilization = tr.metrics.v8.utils.mutatorUtilization(
         0, 300, tr.metrics.v8.WINDOW_SIZE_MS,
         [{start: 50, end: 60}, {start: 110, end: 120}]);
     var actual = run(slices);

     var value = tr.b.getOnlyElement(actual.getValuesNamed(
         'v8-execute-mutator-utilization_pct_095'));
     assert.closeTo(value.average,
         mutatorUtilization.percentile(1 - 0.95), 1e-2);

     value = tr.b.getOnlyElement(actual.getValuesNamed(
         'v8-execute-mutator-utilization_pct_099'));
     assert.closeTo(value.average,
         mutatorUtilization.percentile(1 - 0.99), 1e-2);
  });
 });
 </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/v8/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.v8.gcMetric(values, model);
	return values;
	}

	test('topEvents', function() {
	var events = {
	'V8.GCCompactor': 'v8-gc-full-mark-compactor',
	'V8.GCFinalizeMC': 'v8-gc-latency-mark-compactor',
	'V8.GCFinalizeMCReduceMemory': 'v8-gc-memory-mark-compactor',
	'V8.GCIncrementalMarking': 'v8-gc-incremental-step',
	'V8.GCIncrementalMarkingFinalize': 'v8-gc-incremental-finalize',
	'V8.GCIncrementalMarkingStart': 'v8-gc-incremental-start',
	'V8.GCPhantomHandleProcessingCallback' : 'v8-gc-phantom-handle-callback',
	'V8.GCScavenger': 'v8-gc-scavenger'
	};
	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 value = tr.b.getOnlyElement(actual.getValuesNamed(telemetryName));
	assert.strictEqual(value.running.sum, 100);
	assert.strictEqual(value.numValues, 1);
	assert.strictEqual(value.average, 100);
	assert.strictEqual(value.running.max, 100);
	assert.closeTo(value.getApproximatePercentile(0.90), 100, 1);

	value = tr.b.getOnlyElement(actual.getValuesNamed(
	telemetryName + '_idle_deadline_overrun'));
	assert.strictEqual(value.running.sum, 0);
	assert.strictEqual(value.numValues, 1);
	assert.strictEqual(value.average, 0);
	assert.strictEqual(value.running.max, 0);

	value = tr.b.getOnlyElement(actual.getValuesNamed(
	telemetryName + '_outside_idle'));
	assert.strictEqual(value.running.sum, 100);
	assert.strictEqual(value.numValues, 1);
	assert.strictEqual(value.average, 100);

	value = tr.b.getOnlyElement(actual.getValuesNamed(
	telemetryName + '_percentage_idle'));
	assert.strictEqual(value.average, 0);
	});
	});

	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: 'V8.GCFinalizeMC', args: {}, start: 110, end: 190,
	cpuStart: 110, cpuEnd: 190
	}
	];
	var actual = run(slices);

	var value = tr.b.getOnlyElement(actual.getValuesNamed(
	'v8-gc-latency-mark-compactor'));
	assert.strictEqual(value.running.sum, 80);
	assert.strictEqual(value.numValues, 1);
	assert.strictEqual(value.average, 80);
	assert.strictEqual(value.running.max, 80);

	value = tr.b.getOnlyElement(actual.getValuesNamed(
	'v8-gc-latency-mark-compactor_idle_deadline_overrun'));
	assert.strictEqual(value.running.sum, 0);
	assert.strictEqual(value.average, 0);
	assert.strictEqual(value.running.max, 0);

	value = tr.b.getOnlyElement(actual.getValuesNamed(
	'v8-gc-latency-mark-compactor_outside_idle'));
	assert.strictEqual(value.running.sum, 0);
	assert.strictEqual(value.average, 0);
	assert.strictEqual(value.running.max, 0);

	value = tr.b.getOnlyElement(actual.getValuesNamed(
	'v8-gc-latency-mark-compactor_percentage_idle'));
	assert.strictEqual(value.average, 1);
	});

	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: 'V8.GCFinalizeMC', args: {}, start: 110, end: 190,
	cpuStart: 110, cpuEnd: 190
	}
	];
	var actual = run(slices);

	var value = tr.b.getOnlyElement(actual.getValuesNamed(
	'v8-gc-latency-mark-compactor'));
	assert.strictEqual(value.running.sum, 80);
	assert.strictEqual(value.numValues, 1);
	assert.strictEqual(value.average, 80);
	assert.strictEqual(value.running.max, 80);

	value = tr.b.getOnlyElement(actual.getValuesNamed(
	'v8-gc-latency-mark-compactor_idle_deadline_overrun'));
	assert.strictEqual(value.running.sum, 70);
	assert.strictEqual(value.average, 70);
	assert.strictEqual(value.running.max, 70);

	value = tr.b.getOnlyElement(actual.getValuesNamed(
	'v8-gc-latency-mark-compactor_outside_idle'));
	assert.strictEqual(value.running.sum, 70);
	assert.strictEqual(value.average, 70);
	assert.strictEqual(value.running.max, 70);

	value = tr.b.getOnlyElement(actual.getValuesNamed(
	'v8-gc-latency-mark-compactor_percentage_idle'));
	assert.closeTo(value.average, 1 / 8, 1e-6);
	});

	test('subEvents', function() {
	var values = new tr.v.ValueSet();
	var slices = [
	{
	title: 'V8.GCFinalizeMC', args: {}, start: 100, end: 200,
	cpuStart: 100, cpuEnd: 200
	},
	{
	title: 'V8.GC_MC_MARK', args: {}, start: 110, end: 190,
	cpuStart: 110, cpuEnd: 190
	},
	];
	var actual = run(slices);
	var telemetryName = 'v8-gc-latency-mark-compactor-mark';
	var value = tr.b.getOnlyElement(actual.getValuesNamed(telemetryName));
	assert.strictEqual(value.average, 80);
	assert.strictEqual(value.running.max, 80);
	assert.closeTo(value.getApproximatePercentile(0.90), 80, 1);
	});

	test('total', function() {
	var values = new tr.v.ValueSet();
	var slices = [
	{
	title: 'V8.GCFinalizeMC', args: {}, start: 100, end: 200,
	cpuStart: 100, cpuEnd: 200
	},
	{
	title: 'V8.GCIncrementalMarking', args: {}, start: 210, end: 290,
	cpuStart: 210, cpuEnd: 290
	}
	];
	var actual = run(slices);

	var value = tr.b.getOnlyElement(actual.getValuesNamed('v8-gc-total'));
	assert.strictEqual(value.running.sum, 180);
	assert.strictEqual(value.numValues, 2);
	assert.strictEqual(value.average, 90);
	assert.strictEqual(value.running.max, 100);

	value = tr.b.getOnlyElement(actual.getValuesNamed(
	'v8-gc-total_idle_deadline_overrun'));
	assert.strictEqual(value.running.sum, 0);
	assert.strictEqual(value.average, 0);
	assert.strictEqual(value.running.max, 0);

	value = tr.b.getOnlyElement(actual.getValuesNamed(
	'v8-gc-total_outside_idle'));
	assert.strictEqual(value.running.sum, 180);
	assert.strictEqual(value.average, 90);
	assert.strictEqual(value.running.max, 100);

	value = tr.b.getOnlyElement(actual.getValuesNamed(
	'v8-gc-total_percentage_idle'));
	assert.strictEqual(value.average, 0);
	});

	test('percentageInV8Execute', function() {
	var values = new tr.v.ValueSet();
	var slices = [
	{
	title: 'V8.Execute',
	args: {}, start: 100, end: 200,
	cpuStart: 100, cpuEnd: 200
	},
	{
	title: 'V8.GCFinalizeMC', args: {}, start: 110, end: 190,
	cpuStart: 110, cpuEnd: 190
	},
	{
	title: 'V8.GCFinalizeMC', args: {}, start: 210, end: 220,
	cpuStart: 210, cpuEnd: 220
	}
	];
	var actual = run(slices);
	var value = tr.b.getOnlyElement(actual.getValuesNamed(
	'v8-gc-latency-mark-compactor_percentage_in_v8_execute'));
	assert.strictEqual(value.average,
	(190 - 110) / ((190 - 110) + (220 - 210)));
	});

	test('mutatorUtilization', function() {
	var values = new tr.v.ValueSet();
	var slices = [
	{
	title: 'V8.Execute', args: {}, start: 100, end: 200,
	cpuStart: 100, cpuEnd: 200
	},
	{
	title: 'V8.GCFinalizeMC', args: {}, start: 150, end: 160,
	cpuStart: 150, cpuEnd: 160
	},
	{
	title: 'V8.Execute', args: {}, start: 1000, end: 1200,
	cpuStart: 1000, cpuEnd: 1200
	},
	{
	title: 'V8.GCIncrementalMarking', args: {}, start: 1010, end: 1020,
	cpuStart: 1010, cpuEnd: 1020
	}
	];
	var mutatorUtilization = tr.metrics.v8.utils.mutatorUtilization(
	0, 300, tr.metrics.v8.WINDOW_SIZE_MS,
	[{start: 50, end: 60}, {start: 110, end: 120}]);
	var actual = run(slices);

	var value = tr.b.getOnlyElement(actual.getValuesNamed(
	'v8-execute-mutator-utilization_pct_095'));
	assert.closeTo(value.average,
	mutatorUtilization.percentile(1 - 0.95), 1e-2);

	value = tr.b.getOnlyElement(actual.getValuesNamed(
	'v8-execute-mutator-utilization_pct_099'));
	assert.closeTo(value.average,
	mutatorUtilization.percentile(1 - 0.99), 1e-2);
	});
	});
	</script>