mirror of
https://github.com/ARM-software/workload-automation.git
synced 2025-02-07 13:41:24 +00:00
718f2c1c90
Expose the context to the initialize and finalize functions for Output Processors. This was found to be necessary for the upcoming PostgreSQL Output Processor.
150 lines
6.3 KiB
Python
Executable File
150 lines
6.3 KiB
Python
Executable File
# Copyright 2015-2018 ARM Limited
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
#
|
|
|
|
from collections import OrderedDict
|
|
|
|
from devlib.utils.csvutil import csvwriter
|
|
|
|
from wa import OutputProcessor, Parameter
|
|
from wa.utils.cpustates import report_power_stats
|
|
|
|
|
|
def _get_cpustates_description():
|
|
"""
|
|
Reuse the description for report_power_stats() but strip away it's
|
|
parameter docs, as they are not relevant to the OuputProcessor.
|
|
"""
|
|
output_lines = []
|
|
lines = iter(report_power_stats.__doc__.split('\n'))
|
|
line = next(lines)
|
|
while True:
|
|
try:
|
|
if line.strip().startswith(':param'):
|
|
while line.strip():
|
|
line = next(lines)
|
|
output_lines.append(line)
|
|
line = next(lines)
|
|
except StopIteration:
|
|
break
|
|
return '\n'.join(output_lines)
|
|
|
|
|
|
class CpuStatesProcessor(OutputProcessor):
|
|
|
|
name = 'cpustates'
|
|
|
|
description = _get_cpustates_description()
|
|
|
|
parameters = [
|
|
Parameter('use_ratios', kind=bool, default=False,
|
|
description="""
|
|
By default proportional values will be reported as
|
|
percentages, if this flag is enabled, they will be reported
|
|
as ratios instead.
|
|
"""),
|
|
Parameter('no_idle', kind=bool, default=False,
|
|
description="""
|
|
Indicate that there will be no idle transitions in the trace.
|
|
By default, a core will be reported as being in an "unknown"
|
|
state until the first idle transtion for that core. Normally,
|
|
this is not an issue, as cores are "nudged" as part of the
|
|
setup to ensure that there is an idle transtion before the
|
|
meassured region. However, if all idle states for the core
|
|
have been disabled, or if the kernel does not have cpuidle,
|
|
the nudge will not result in an idle transition, which would
|
|
cause the cores to be reported to be in "unknown" state for
|
|
the entire execution.
|
|
|
|
If this parameter is set to ``True``, the processor will
|
|
assume that cores are running prior to the begining of the
|
|
issue, and they will leave unknown state on the first
|
|
frequency transition.
|
|
"""),
|
|
Parameter('split_wfi_states', kind=bool, default=False,
|
|
description="""
|
|
WFI is a very shallow idle state. The core remains powered on
|
|
when in this state, which means the power usage while in this
|
|
state will depend on the current voltage, and therefore current
|
|
frequency.
|
|
|
|
Setting this to ``True`` will track time spent in WFI at
|
|
each frequency separately, allowing to gain the most accurate
|
|
picture of energy usage.
|
|
"""),
|
|
]
|
|
|
|
def initialize(self, context):
|
|
self.iteration_reports = OrderedDict() # pylint: disable=attribute-defined-outside-init
|
|
|
|
def process_job_output(self, output, target_info, run_output): # pylint: disable=unused-argument
|
|
trace_file = output.get_artifact_path('trace-cmd-txt')
|
|
if not trace_file:
|
|
self.logger.warning('Text trace does not appear to have been generated; skipping this iteration.')
|
|
return
|
|
|
|
self.logger.info('Generating power state reports from trace...')
|
|
reports = report_power_stats( # pylint: disable=unbalanced-tuple-unpacking
|
|
trace_file=trace_file,
|
|
output_basedir=output.basepath,
|
|
cpus=target_info.cpus,
|
|
use_ratios=self.use_ratios,
|
|
no_idle=self.no_idle,
|
|
split_wfi_states=self.split_wfi_states,
|
|
)
|
|
|
|
for report in reports.values():
|
|
output.add_artifact(report.name, report.filepath, kind='data')
|
|
|
|
iteration_id = (output.id, output.label, output.iteration)
|
|
self.iteration_reports[iteration_id] = reports
|
|
|
|
# pylint: disable=too-many-locals,unused-argument
|
|
def process_run_output(self, output, target_info):
|
|
if not self.iteration_reports:
|
|
self.logger.warning('No power state reports generated.')
|
|
return
|
|
|
|
parallel_rows = []
|
|
powerstate_rows = []
|
|
for iteration_id, reports in self.iteration_reports.items():
|
|
job_id, workload, iteration = iteration_id
|
|
parallel_report = reports['parallel-stats']
|
|
powerstate_report = reports['power-state-stats']
|
|
|
|
for record in parallel_report.values:
|
|
parallel_rows.append([job_id, workload, iteration] + record)
|
|
for state in sorted(powerstate_report.state_stats):
|
|
stats = powerstate_report.state_stats[state]
|
|
powerstate_rows.append([job_id, workload, iteration, state] +
|
|
['{:.3f}'.format(s if s is not None else 0)
|
|
for s in stats])
|
|
|
|
outpath = output.get_path('parallel-stats.csv')
|
|
with csvwriter(outpath) as writer:
|
|
writer.writerow(['id', 'workload', 'iteration', 'cluster',
|
|
'number_of_cores', 'total_time',
|
|
'%time', '%running_time'])
|
|
writer.writerows(parallel_rows)
|
|
output.add_artifact('run-parallel-stats', outpath, kind='export')
|
|
|
|
outpath = output.get_path('power-state-stats.csv')
|
|
with csvwriter(outpath) as writer:
|
|
headers = ['id', 'workload', 'iteration', 'state']
|
|
headers += ['{} CPU{}'.format(c, i)
|
|
for i, c in enumerate(powerstate_report.core_names)]
|
|
writer.writerow(headers)
|
|
writer.writerows(powerstate_rows)
|
|
output.add_artifact('run-power-state-stats', outpath, kind='export')
|