#!/usr/bin/env python3
# Copyright 2021 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
import argparse
import json
import logging
import os
import pandas as pd
import plistlib
def GetDictionaryKeys(value, keys):
""" Returns a dictionary containing `keys` from `value` if present. """
return {key: value[key] for key in keys if key in value}
def FlattenDictionary(value, keys=[]):
""" Returns a flattened version of the dictionary `value`, with nested keys
combined as a.b.c. """
result = {}
if type(value) is dict:
for key in value:
result.update(FlattenDictionary(value[key], keys + [key]))
return result
else:
key = '.'.join(keys)
return {key: value}
def GetCoalition(coalitions_data, browser_identifier: str):
""" Returns the coalition data whose name matches the identifier
`browser_identifier`"""
for coalition in coalitions_data:
if coalition['name'] == browser_identifier:
return coalition
return None
def ReadPowerMetricsData(scenario_dir, browser_identifier: str):
with open(os.path.join(scenario_dir, "powermetrics.plist"),
"r") as plist_file:
data = plist_file.read().split('\0')
results = []
for raw_sample in data:
if raw_sample == "":
continue
parsed_sample = plistlib.loads(str.encode(raw_sample))
out_sample = {'elapsed_ns': parsed_sample['elapsed_ns']}
# Processing output of the 'tasks' sampler.
coalition_keys = [
"energy_impact", "gputime_ms", "diskio_byteswritten",
"diskio_bytesread", "idle_wakeups", "intr_wakeups",
"cputime_sample_ms_per_s", "cputime_ns"
]
coalitions_data = parsed_sample['coalitions']
if browser_identifier is not None:
browser_coalition_data = GetCoalition(coalitions_data,
browser_identifier)
out_sample['browser'] = GetDictionaryKeys(browser_coalition_data,
coalition_keys)
out_sample['all'] = GetDictionaryKeys(parsed_sample['all_tasks'],
coalition_keys)
# Add information for coalitions that could be of interest since they
# might execute code on behalf of the browser.
out_sample['window_server'] = GetDictionaryKeys(
GetCoalition(coalitions_data, "com.apple.WindowServer"),
coalition_keys)
out_sample['kernel_coalition'] = GetDictionaryKeys(
GetCoalition(coalitions_data, "kernel_coalition"), coalition_keys)
# Processing output of the 'cpu_power' sampler.
# Expected processor fields on Intel.
out_sample['processor'] = GetDictionaryKeys(parsed_sample['processor'], [
'freq_hz',
'package_joules',
])
# Expected processor fields on M1.
out_sample['processor'].update(
GetDictionaryKeys(parsed_sample['processor'], [
'ane_energy',
'dram_energy',
'cpu_energy',
'gpu_energy',
'package_energy',
]))
if 'clusters' in parsed_sample['processor']:
for cluster in parsed_sample['processor']['clusters']:
out_sample['processor'][cluster['name']] = GetDictionaryKeys(
cluster, ['power', 'idle_ns', 'freq_hz'])
results.append(FlattenDictionary(out_sample))
return results
def NormalizeMicrosecondsSampleTime(sample_time: pd.Series):
# Round sample time to .1s to aggregate similar rows across different sources.
return (sample_time / 1000000.0).round(1)
def main():
parser = argparse.ArgumentParser(
description='Parses, aggregates and summarizes power results')
parser.add_argument("--data_dir",
help="Directory containing benchmark data.",
required=True)
parser.add_argument('--verbose',
action='store_true',
help='Print verbose output.')
args = parser.parse_args()
if args.verbose:
log_level = logging.DEBUG
else:
log_level = logging.INFO
logging.basicConfig(format='%(levelname)s: %(message)s', level=log_level)
for name in os.listdir(args.data_dir):
subdir = os.path.join(args.data_dir, name)
if not os.path.isdir(subdir):
continue
metadata_path = os.path.join(subdir, "metadata.json")
if not os.path.isfile(metadata_path):
continue
with open(metadata_path, 'r') as metadata_file:
metadata = json.load(metadata_file)
logging.info(f'Found scenario {name}')
if 'browser' in metadata:
browser_identifier = metadata['browser']['identifier']
logging.debug(f'Scenario running with {browser_identifier}')
else:
browser_identifier = None
powermetrics_data = ReadPowerMetricsData(subdir, browser_identifier)
powermetrics_dataframe = pd.DataFrame.from_records(powermetrics_data)
# Add sample_time to powermetrics.
powermetrics_dataframe["sample_time"] = NormalizeMicrosecondsSampleTime(
powermetrics_dataframe['elapsed_ns'].cumsum() / 1000.0)
powermetrics_dataframe.set_index('sample_time', inplace=True)
with open(os.path.join(subdir, "power_sampler.json")) as power_file:
power_data = json.load(power_file)
power_dataframe = pd.DataFrame.from_records(
power_data['data_rows'],
columns=[key for key in power_data['column_labels']] + ["sample_time"])
power_dataframe['sample_time'] = NormalizeMicrosecondsSampleTime(
power_dataframe['sample_time'])
power_dataframe.set_index('sample_time', inplace=True)
# Join all data sources by sample_time.
scenario_data = powermetrics_dataframe.join(power_dataframe, how='outer')
summary_path = os.path.join(subdir, 'summary.csv')
logging.info(f'Outputing results in {os.path.abspath(summary_path)}')
scenario_data.to_csv(summary_path)
if __name__ == "__main__":
main()
Codebase Browser
chromium