mirror of
https://github.com/ARM-software/workload-automation.git
synced 2025-01-19 12:24:32 +00:00
e4fdf0bdb9
Apks contain version number in format X.X therefore when trying to match for versions using X.X.X the apk is never found.
158 lines
6.9 KiB
Python
158 lines
6.9 KiB
Python
# Copyright 2013-2015 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.
|
|
#
|
|
|
|
# pylint: disable=E1101,E0203
|
|
import re
|
|
import os
|
|
|
|
from wlauto import AndroidUiAutoBenchmark, Parameter, Alias
|
|
from wlauto.exceptions import ConfigError
|
|
import wlauto.common.android.resources
|
|
|
|
# These maps provide use-friendly aliases for the most common options.
|
|
USE_CASE_MAP = {
|
|
'egypt': 'GLBenchmark 2.5 Egypt HD',
|
|
'egypt-classic': 'GLBenchmark 2.1 Egypt Classic',
|
|
't-rex': 'GLBenchmark 2.7 T-Rex HD',
|
|
}
|
|
|
|
VARIANT_MAP = {
|
|
'onscreen': 'C24Z16 Onscreen Auto',
|
|
'offscreen': 'C24Z16 Offscreen Auto',
|
|
}
|
|
|
|
|
|
class Glb(AndroidUiAutoBenchmark):
|
|
|
|
name = 'glbenchmark'
|
|
description = """
|
|
Measures the graphics performance of Android devices by testing
|
|
the underlying OpenGL (ES) implementation.
|
|
|
|
http://gfxbench.com/about-gfxbench.jsp
|
|
|
|
From the website:
|
|
|
|
The benchmark includes console-quality high-level 3D animations
|
|
(T-Rex HD and Egypt HD) and low-level graphics measurements.
|
|
|
|
With high vertex count and complex effects such as motion blur, parallax
|
|
mapping and particle systems, the engine of GFXBench stresses GPUs in order
|
|
provide users a realistic feedback on their device.
|
|
|
|
"""
|
|
activity = 'com.glbenchmark.activities.GLBenchmarkDownloaderActivity'
|
|
view = 'com.glbenchmark.glbenchmark27/com.glbenchmark.activities.GLBRender'
|
|
|
|
packages = {
|
|
'2.7': 'com.glbenchmark.glbenchmark27',
|
|
'2.5': 'com.glbenchmark.glbenchmark25',
|
|
}
|
|
# If usecase is not specified the default usecase is the first supported usecase alias
|
|
# for the specified version.
|
|
supported_usecase_aliases = {
|
|
'2.7': ['t-rex', 'egypt'],
|
|
'2.5': ['egypt-classic', 'egypt'],
|
|
}
|
|
|
|
default_iterations = 1
|
|
install_timeout = 500
|
|
|
|
regex = re.compile(r'GLBenchmark (metric|FPS): (.*)')
|
|
|
|
parameters = [
|
|
Parameter('version', default='2.7', allowed_values=['2.7', '2.5'],
|
|
description=('Specifies which version of the benchmark to run (different versions '
|
|
'support different use cases).')),
|
|
Parameter('use_case', default=None,
|
|
description="""Specifies which usecase to run, as listed in the benchmark menu; e.g.
|
|
``'GLBenchmark 2.5 Egypt HD'``. For convenience, two aliases are provided
|
|
for the most common use cases: ``'egypt'`` and ``'t-rex'``. These could
|
|
be use instead of the full use case title. For version ``'2.7'`` it defaults
|
|
to ``'t-rex'``, for version ``'2.5'`` it defaults to ``'egypt-classic'``.
|
|
"""),
|
|
Parameter('variant', default='onscreen',
|
|
description="""Specifies which variant of the use case to run, as listed in the benchmarks
|
|
menu (small text underneath the use case name); e.g. ``'C24Z16 Onscreen Auto'``.
|
|
For convenience, two aliases are provided for the most common variants:
|
|
``'onscreen'`` and ``'offscreen'``. These may be used instead of full variant
|
|
names.
|
|
"""),
|
|
Parameter('times', kind=int, default=1,
|
|
description=('Specfies the number of times the benchmark will be run in a "tight '
|
|
'loop", i.e. without performaing setup/teardown inbetween.')),
|
|
Parameter('timeout', kind=int, default=200,
|
|
description="""Specifies how long, in seconds, UI automation will wait for results screen to
|
|
appear before assuming something went wrong.
|
|
"""),
|
|
]
|
|
|
|
aliases = [
|
|
Alias('glbench'),
|
|
Alias('egypt', use_case='egypt'),
|
|
Alias('t-rex', use_case='t-rex'),
|
|
Alias('egypt_onscreen', use_case='egypt', variant='onscreen'),
|
|
Alias('t-rex_onscreen', use_case='t-rex', variant='onscreen'),
|
|
Alias('egypt_offscreen', use_case='egypt', variant='offscreen'),
|
|
Alias('t-rex_offscreen', use_case='t-rex', variant='offscreen'),
|
|
]
|
|
|
|
def __init__(self, device, **kwargs):
|
|
super(Glb, self).__init__(device, **kwargs)
|
|
self.uiauto_params['version'] = self.version
|
|
|
|
if self.use_case is None:
|
|
self.use_case = self.supported_usecase_aliases[self.version][0]
|
|
if self.use_case.lower() in USE_CASE_MAP:
|
|
if self.use_case not in self.supported_usecase_aliases[self.version]:
|
|
raise ConfigError('usecases {} is not supported in version {}'.format(self.use_case, self.version))
|
|
self.use_case = USE_CASE_MAP[self.use_case.lower()]
|
|
self.uiauto_params['use_case'] = self.use_case.replace(' ', '_')
|
|
|
|
if self.variant.lower() in VARIANT_MAP:
|
|
self.variant = VARIANT_MAP[self.variant.lower()]
|
|
self.uiauto_params['variant'] = self.variant.replace(' ', '_')
|
|
|
|
self.uiauto_params['iterations'] = self.times
|
|
self.run_timeout = 4 * 60 * self.times
|
|
|
|
self.uiauto_params['timeout'] = self.timeout
|
|
self.package = self.packages[self.version]
|
|
|
|
def init_resources(self, context):
|
|
self.apk_file = context.resolver.get(wlauto.common.android.resources.ApkFile(self), version=self.version)
|
|
self.uiauto_file = context.resolver.get(wlauto.common.android.resources.JarFile(self))
|
|
self.device_uiauto_file = self.device.path.join(self.device.working_directory,
|
|
os.path.basename(self.uiauto_file))
|
|
if not self.uiauto_package:
|
|
self.uiauto_package = os.path.splitext(os.path.basename(self.uiauto_file))[0]
|
|
|
|
def update_result(self, context):
|
|
super(Glb, self).update_result(context)
|
|
match_count = 0
|
|
with open(self.logcat_log) as fh:
|
|
for line in fh:
|
|
match = self.regex.search(line)
|
|
if match:
|
|
metric = match.group(1)
|
|
value, units = match.group(2).split()
|
|
value = value.replace('*', '')
|
|
if metric == 'metric':
|
|
metric = 'Frames'
|
|
units = 'frames'
|
|
metric = metric + '_' + str(match_count // 2)
|
|
context.result.add_metric(metric, value, units)
|
|
match_count += 1
|