lts/deps/v8/tools/eval_gc_nvp.py
#!/usr/bin/env python
#
# Copyright 2015 the V8 project authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""This script is used to analyze GCTracer's NVP output."""
# for py2/py3 compatibility
from __future__ import print_function
from argparse import ArgumentParser
from copy import deepcopy
from gc_nvp_common import split_nvp
from math import ceil, log
from sys import stdin
class LinearBucket:
def __init__(self, granularity):
self.granularity = granularity
def value_to_bucket(self, value):
return int(value / self.granularity)
def bucket_to_range(self, bucket):
return (bucket * self.granularity, (bucket + 1) * self.granularity)
class Log2Bucket:
def __init__(self, start):
self.start = int(log(start, 2)) - 1
def value_to_bucket(self, value):
index = int(log(value, 2))
index -= self.start
if index < 0:
index = 0
return index
def bucket_to_range(self, bucket):
if bucket == 0:
return (0, 2 ** (self.start + 1))
bucket += self.start
return (2 ** bucket, 2 ** (bucket + 1))
class Histogram:
def __init__(self, bucket_trait, fill_empty):
self.histogram = {}
self.fill_empty = fill_empty
self.bucket_trait = bucket_trait
def add(self, key):
index = self.bucket_trait.value_to_bucket(key)
if index not in self.histogram:
self.histogram[index] = 0
self.histogram[index] += 1
def __str__(self):
ret = []
keys = self.histogram.keys()
keys.sort()
last = keys[len(keys) - 1]
for i in range(0, last + 1):
(min_value, max_value) = self.bucket_trait.bucket_to_range(i)
if i == keys[0]:
keys.pop(0)
ret.append(" [{0},{1}[: {2}".format(
str(min_value), str(max_value), self.histogram[i]))
else:
if self.fill_empty:
ret.append(" [{0},{1}[: {2}".format(
str(min_value), str(max_value), 0))
return "\n".join(ret)
class Category:
def __init__(self, key, histogram, csv, percentiles):
self.key = key
self.values = []
self.histogram = histogram
self.csv = csv
self.percentiles = percentiles
def process_entry(self, entry):
if self.key in entry:
self.values.append(float(entry[self.key]))
if self.histogram:
self.histogram.add(float(entry[self.key]))
def min(self):
return min(self.values)
def max(self):
return max(self.values)
def avg(self):
if len(self.values) == 0:
return 0.0
return sum(self.values) / len(self.values)
def empty(self):
return len(self.values) == 0
def _compute_percentiles(self):
ret = []
if len(self.values) == 0:
return ret
sorted_values = sorted(self.values)
for percentile in self.percentiles:
index = int(ceil((len(self.values) - 1) * percentile / 100))
ret.append(" {0}%: {1}".format(percentile, sorted_values[index]))
return ret
def __str__(self):
if self.csv:
ret = [self.key]
ret.append(len(self.values))
ret.append(self.min())
ret.append(self.max())
ret.append(self.avg())
ret = [str(x) for x in ret]
return ",".join(ret)
else:
ret = [self.key]
ret.append(" len: {0}".format(len(self.values)))
if len(self.values) > 0:
ret.append(" min: {0}".format(self.min()))
ret.append(" max: {0}".format(self.max()))
ret.append(" avg: {0}".format(self.avg()))
if self.histogram:
ret.append(str(self.histogram))
if self.percentiles:
ret.append("\n".join(self._compute_percentiles()))
return "\n".join(ret)
def __repr__(self):
return "<Category: {0}>".format(self.key)
def make_key_func(cmp_metric):
def key_func(a):
return getattr(a, cmp_metric)()
return key_func
def main():
parser = ArgumentParser(description="Process GCTracer's NVP output")
parser.add_argument('keys', metavar='KEY', type=str, nargs='+',
help='the keys of NVPs to process')
parser.add_argument('--histogram-type', metavar='<linear|log2>',
type=str, nargs='?', default="linear",
help='histogram type to use (default: linear)')
linear_group = parser.add_argument_group('linear histogram specific')
linear_group.add_argument('--linear-histogram-granularity',
metavar='GRANULARITY', type=int, nargs='?',
default=5,
help='histogram granularity (default: 5)')
log2_group = parser.add_argument_group('log2 histogram specific')
log2_group.add_argument('--log2-histogram-init-bucket', metavar='START',
type=int, nargs='?', default=64,
help='initial buck size (default: 64)')
parser.add_argument('--histogram-omit-empty-buckets',
dest='histogram_omit_empty',
action='store_true',
help='omit empty histogram buckets')
parser.add_argument('--no-histogram', dest='histogram',
action='store_false', help='do not print histogram')
parser.set_defaults(histogram=True)
parser.set_defaults(histogram_omit_empty=False)
parser.add_argument('--rank', metavar='<no|min|max|avg>',
type=str, nargs='?',
default="no",
help="rank keys by metric (default: no)")
parser.add_argument('--csv', dest='csv',
action='store_true', help='provide output as csv')
parser.add_argument('--percentiles', dest='percentiles',
type=str, default="",
help='comma separated list of percentiles')
args = parser.parse_args()
histogram = None
if args.histogram:
bucket_trait = None
if args.histogram_type == "log2":
bucket_trait = Log2Bucket(args.log2_histogram_init_bucket)
else:
bucket_trait = LinearBucket(args.linear_histogram_granularity)
histogram = Histogram(bucket_trait, not args.histogram_omit_empty)
percentiles = []
for percentile in args.percentiles.split(','):
try:
percentiles.append(float(percentile))
except ValueError:
pass
categories = [ Category(key, deepcopy(histogram), args.csv, percentiles)
for key in args.keys ]
while True:
line = stdin.readline()
if not line:
break
obj = split_nvp(line)
for category in categories:
category.process_entry(obj)
# Filter out empty categories.
categories = [x for x in categories if not x.empty()]
if args.rank != "no":
categories = sorted(categories, key=make_key_func(args.rank), reverse=True)
for category in categories:
print(category)
if __name__ == '__main__':
main()