def _perform_action(target, action, delay_s=1.0):
# Delay before performing action
target.execute('sleep {}'.format(delay_s))
if action == 'vswipe':
# Action: A fast Swipe Up/Scroll Down
System.vswipe(target, 20, 80, 50)
if action == 'tap':
# Action: Tap in the centre of the screen
System.tap(target, 50, 50)
def run(self, out_dir, duration_s, brightness, filepath, collect=''):
"""
Run single display image workload.
:param out_dir: Path to experiment directory where to store results.
:type out_dir: str
:param duration_s: Duration of test
:type duration_s: int
:param brightness: Brightness of the screen 0-100
:type brightness: int
:param out_dir: Path to the image to display
:type out_dir: str
:param collect: Specifies what to collect. Possible values:
- 'energy'
- 'time_in_state'
- 'systrace'
- 'ftrace'
- any combination of the above, except energy and display-energy
cannot be collected simultaneously.
:type collect: list(str)
"""
# Keep track of mandatory parameters
self.out_dir = out_dir
self.collect = collect
# Set brightness
Screen.set_brightness(self._target, auto=False, percent=brightness)
# Set timeout to be sufficiently longer than the duration of the test
Screen.set_timeout(self._target, seconds=(duration_s+60))
# Turn on airplane mode
System.set_airplane_mode(self._target, on=True)
# Unlock device screen (assume no password required)
Screen.unlock(self._target)
# Push the image to the device
device_filepath = '/data/local/tmp/image'
self._target.push(filepath, device_filepath)
sleep(1)
# Put image on the screen
System.start_action(self._target, self.action,
'-t image/* -d file://{}'.format(device_filepath))
sleep(1)
# Dimiss the navigation bar by tapping the center of the screen
System.tap(self._target, 50, 50)
self.tracingStart(screen_always_on=False)
self._log.info('Waiting for duration {}'.format(duration_s))
sleep(duration_s)
self.tracingStop(screen_always_on=False)
# Close app and dismiss image
System.force_stop(self._target, self.package, clear=True)
# Remove image
self._target.execute('rm /data/local/tmp/image')
Screen.set_defaults(self._target)
System.set_airplane_mode(self._target, on=False)
Screen.set_screen(self._target, on=False)
def run(self, out_dir, test_name, collect=''):
"""
Run single Vellamo workload. Returns a collection of results.
:param out_dir: Path to experiment directory where to store results.
:type out_dir: str
:param test_name: Name of the test to run
:type test_name: str
:param collect: Specifies what to collect. Possible values:
- 'energy'
- 'systrace'
- 'ftrace'
- any combination of the above
:type collect: list(str)
"""
self.out_dir = out_dir
self.collect = collect
# Check if the density of the target device screen is different from
# the one used to get the values below
density = Screen.get_screen_density(self._target)
if DEFAULT_DENSITY not in density:
msg = 'Screen density of target device differs from {}.\n'\
'Please set it to {}'
raise RuntimeError(msg.format(DEFAULT_DENSITY, DEFAULT_DENSITY))
if test_name.upper() not in VELLAMO_TESTS:
raise ValueError('Vellamo workload [%s] not supported', test_name)
# Set parameter depending on test
self._log.debug('Start Vellamo Benchmark [%s]', test_name)
test_x, test_y = (0, 0)
sleep_time = 0
if test_name.upper() == 'BROWSER':
test_x, test_y = (91, 33)
sleep_time = 3.5
elif test_name.upper() == 'METAL':
test_x, test_y = (91, 59)
sleep_time = 1
elif test_name.upper() == 'MULTI':
test_x, test_y = (91, 71)
sleep_time = 3.5
# Unlock device screen (assume no password required)
Screen.unlock(self._target)
System.force_stop(self._target, self.package, clear=True)
# Set min brightness
Screen.set_brightness(self._target, auto=False, percent=0)
# Clear logcat
os.system(self._adb('logcat -c'))
# Regexps for benchmark synchronization
start_logline = r'ActivityManager: Start.*'\
':com.quicinc.vellamo:benchmarking'
VELLAMO_BENCHMARK_START_RE = re.compile(start_logline)
self._log.debug("START string [%s]", start_logline)
# End of benchmark is marked by displaying results
end_logline = r'ActivityManager: START.*'\
'act=com.quicinc.vellamo.*_RESULTS'
VELLAMO_BENCHMARK_END_RE = re.compile(end_logline)
self._log.debug("END string [%s]", end_logline)
# Parse logcat output lines
logcat_cmd = self._adb(
'logcat ActivityManager:* System.out:I *:S BENCH:*'\
.format(self._target.adb_name))
self._log.info("%s", logcat_cmd)
# Start the activity
System.start_activity(self._target, self.package, self.activity)
logcat = Popen(logcat_cmd, shell=True, stdout=PIPE)
sleep(2)
# Accept EULA
System.tap(self._target, 80, 86)
sleep(1)
# Click Let's Roll
System.tap(self._target, 50, 67)
sleep(1)
# Skip Arrow
System.tap(self._target, 46, 78)
# Run Workload
System.tap(self._target, test_x, test_y)
# Skip instructions
System.hswipe(self._target, 10, 80, duration=100, swipe_right=False)
System.hswipe(self._target, 10, 80, duration=100, swipe_right=False)
System.hswipe(self._target, 10, 80, duration=100, swipe_right=False)
self._log.info("Vellamo - {} started!".format(test_name.upper()))
while True:
# read next logcat line (up to max 1024 chars)
message = logcat.stdout.readline(1024)
# Benchmark start trigger
if VELLAMO_BENCHMARK_START_RE.search(message):
# Start tracing
self.tracingStart()
self._log.debug("Benchmark started!")
elif VELLAMO_BENCHMARK_END_RE.search(message):
# Stop tracing
self.tracingStop()
break
else:
continue
# Gather scores file from the device
db_file = os.path.join(out_dir, VELLAMO_SCORE_NAME)
self._target.pull('{}/{}'.format(VELLAMO_DB_PATH, VELLAMO_SCORE_NAME),
db_file)
System.force_stop(self._target, self.package, clear=True)
# Go back to home screen
System.home(self._target)
# Set brightness back to auto
Screen.set_brightness(self._target, auto=True)
def run(self, out_dir, test_name, collect=''):
"""
Run single Geekbench workload.
:param out_dir: Path on host to experiment directory where
to store results.
:type out_dir: str
:param test_name: Name of the test to run
:type test_name: str
:param collect: Specifies what to collect. Possible values:
- 'energy'
- 'systrace'
- 'ftrace'
- any combination of the above in a space-separated string.
:type collect: list(str)
"""
# Initialize energy meter results
self.out_dir = out_dir
self.collect = collect
# Clear the stored data for the application, so we always start with
# an EULA to clear
System.force_stop(self._target, self.package, clear=True)
# Clear logcat from any previous runs
# do this on the target as then we don't need to build a string
self._target.clear_logcat()
# Unlock device screen (assume no password required)
System.menu(self._target)
# Press Back button to be sure we run the benchmark from the start
System.back(self._target)
# Force screen in PORTRAIT mode
Screen.set_orientation(self._target, portrait=True)
# Set min brightness
Screen.set_brightness(self._target, auto=False, percent=0)
# Start app on the target device
System.start_activity(self._target, self.package, self.activity)
# Allow the activity to start
sleep(2)
# Parse logcat output lines to find beginning and end
logcat_cmd = self._adb(
'logcat ActivityManager:* System.out:I *:S GEEKBENCH_RESULT:*'\
.format(self._target.adb_name))
self._log.info("%s", logcat_cmd)
logcat = Popen(logcat_cmd, shell=True, stdout=PIPE)
# Click to accept the EULA
System.tap(self._target, 73, 55)
sleep(1)
# The main window opened will have the CPU benchmark
# Swipe to get the COMPUTE one
if test_name.upper() == 'COMPUTE':
System.hswipe(self._target, 10, 80, duration=100, swipe_right=False)
# Press the 'RUN <test_name> BENCHMARK' button
System.tap(self._target, 73, 72)
while True:
# read next logcat line (up to max 1024 chars)
message = logcat.stdout.readline(1024)
# Benchmark start trigger
match = GEEKBENCH_BENCHMARK_START_RE.search(message)
if match:
# Start tracing
self.tracingStart()
self._log.debug("Benchmark started!")
# Benchmark end trigger
match = GEEKBENCH_BENCHMARK_END_RE.search(message)
if match:
# Stop tracing
self.tracingStop()
remote_result_file = match.group('results_file')
self._log.debug("Benchmark finished! Results are in {}".format(remote_result_file))
break
# Get Geekbench Results file
target_result_file = self._target.path.basename(remote_result_file)
result_file = os.path.join(self.out_dir, target_result_file)
self._log.debug("result_file={}".format(result_file))
self._target.pull(remote_result_file, result_file)
# Close the app
System.force_stop(self._target, self.package, clear=False)
# Go back to home screen
System.home(self._target)
# Switch back to screen auto rotation
Screen.set_orientation(self._target, auto=True)
# Set brightness back to auto
Screen.set_brightness(self._target, auto=True)
def run(self, out_dir, test_name, collect=''):
"""
Run single Vellamo workload. Returns a collection of results.
:param out_dir: Path to experiment directory where to store results.
:type out_dir: str
:param test_name: Name of the test to run
:type test_name: str
:param collect: Specifies what to collect. Possible values:
- 'energy'
- 'systrace'
- 'ftrace'
- any combination of the above
:type collect: list(str)
"""
self.out_dir = out_dir
self.collect = collect
# Check if the density of the target device screen is different from
# the one used to get the values below
density = Screen.get_screen_density(self._target)
if DEFAULT_DENSITY not in density:
msg = 'Screen density of target device differs from {}.\n'\
'Please set it to {}'
raise RuntimeError(msg.format(DEFAULT_DENSITY, DEFAULT_DENSITY))
if test_name.upper() not in VELLAMO_TESTS:
raise ValueError('Vellamo workload [%s] not supported', test_name)
# Set parameter depending on test
self._log.debug('Start Vellamo Benchmark [%s]', test_name)
test_x, test_y = (0, 0)
sleep_time = 0
if test_name.upper() == 'BROWSER':
test_x, test_y = (91, 33)
sleep_time = 3.5
elif test_name.upper() == 'METAL':
test_x, test_y = (91, 59)
sleep_time = 1
elif test_name.upper() == 'MULTI':
test_x, test_y = (91, 71)
sleep_time = 3.5
# Unlock device screen (assume no password required)
Screen.unlock(self._target)
System.force_stop(self._target, self.package, clear=True)
# Set min brightness
Screen.set_brightness(self._target, auto=False, percent=0)
# Clear logcat
os.system(self._adb('logcat -c'));
# Regexps for benchmark synchronization
start_logline = r'ActivityManager: Start.*'\
':com.quicinc.vellamo:benchmarking'
VELLAMO_BENCHMARK_START_RE = re.compile(start_logline)
self._log.debug("START string [%s]", start_logline)
# End of benchmark is marked by displaying results
end_logline = r'ActivityManager: START.*'\
'act=com.quicinc.vellamo.*_RESULTS'
VELLAMO_BENCHMARK_END_RE = re.compile(end_logline)
self._log.debug("END string [%s]", end_logline)
# Parse logcat output lines
logcat_cmd = self._adb(
'logcat ActivityManager:* System.out:I *:S BENCH:*'\
.format(self._target.adb_name))
self._log.info("%s", logcat_cmd)
# Start the activity
System.start_activity(self._target, self.package, self.activity)
logcat = Popen(logcat_cmd, shell=True, stdout=PIPE)
sleep(2)
# Accept EULA
System.tap(self._target, 80, 86)
sleep(1)
# Click Let's Roll
System.tap(self._target, 50, 67)
sleep(1)
# Skip Arrow
System.tap(self._target, 46, 78)
# Run Workload
System.tap(self._target, test_x, test_y)
# Skip instructions
System.hswipe(self._target, 10, 80, duration=100, swipe_right=False)
System.hswipe(self._target, 10, 80, duration=100, swipe_right=False)
System.hswipe(self._target, 10, 80, duration=100, swipe_right=False)
self._log.info("Vellamo - {} started!".format(test_name.upper()))
while True:
# read next logcat line (up to max 1024 chars)
message = logcat.stdout.readline(1024)
# Benchmark start trigger
if VELLAMO_BENCHMARK_START_RE.search(message):
# Start tracing
self.tracingStart()
self._log.debug("Benchmark started!")
elif VELLAMO_BENCHMARK_END_RE.search(message):
# Stop tracing
self.tracingStop()
break
else:
continue
# Gather scores file from the device
db_file = os.path.join(out_dir, VELLAMO_SCORE_NAME)
self._target.pull('{}/{}'.format(VELLAMO_DB_PATH, VELLAMO_SCORE_NAME),
db_file)
System.force_stop(self._target, self.package, clear=True)
# Go back to home screen
System.home(self._target)
# Set brightness back to auto
Screen.set_brightness(self._target, auto=True)
def run(self, out_dir, test_name, collect=''):
"""
Run single Geekbench workload.
:param out_dir: Path on host to experiment directory where
to store results.
:type out_dir: str
:param test_name: Name of the test to run
:type test_name: str
:param collect: Specifies what to collect. Possible values:
- 'energy'
- 'systrace'
- 'ftrace'
- any combination of the above in a space-separated string.
:type collect: list(str)
"""
# Initialize energy meter results
self.out_dir = out_dir
self.collect = collect
# Clear the stored data for the application, so we always start with
# an EULA to clear
System.force_stop(self._target, self.package, clear=True)
# Clear logcat from any previous runs
# do this on the target as then we don't need to build a string
self._target.clear_logcat()
# Unlock device screen (assume no password required)
System.menu(self._target)
# Press Back button to be sure we run the benchmark from the start
System.back(self._target)
# Force screen in PORTRAIT mode
Screen.set_orientation(self._target, portrait=True)
# Set min brightness
Screen.set_brightness(self._target, auto=False, percent=0)
# Start app on the target device
System.start_activity(self._target, self.package, self.activity)
# Allow the activity to start
sleep(2)
# Parse logcat output lines to find beginning and end
logcat_cmd = self._adb(
'logcat ActivityManager:* System.out:I *:S GEEKBENCH_RESULT:*'\
.format(self._target.adb_name))
self._log.info("%s", logcat_cmd)
logcat = Popen(logcat_cmd, shell=True, stdout=PIPE)
# Click to accept the EULA
System.tap(self._target, 73, 55)
sleep(1)
# The main window opened will have the CPU benchmark
# Swipe to get the COMPUTE one
if test_name.upper() == 'COMPUTE':
System.hswipe(self._target,
10,
80,
duration=100,
swipe_right=False)
# Press the 'RUN <test_name> BENCHMARK' button
System.tap(self._target, 73, 72)
while True:
# read next logcat line (up to max 1024 chars)
message = logcat.stdout.readline(1024)
# Benchmark start trigger
match = GEEKBENCH_BENCHMARK_START_RE.search(message)
if match:
# Start tracing
self.tracingStart()
self._log.debug("Benchmark started!")
# Benchmark end trigger
match = GEEKBENCH_BENCHMARK_END_RE.search(message)
if match:
# Stop tracing
self.tracingStop()
remote_result_file = match.group('results_file')
self._log.debug("Benchmark finished! Results are in {}".format(
remote_result_file))
break
# Get Geekbench Results file
target_result_file = self._target.path.basename(remote_result_file)
result_file = os.path.join(self.out_dir, target_result_file)
self._log.debug("result_file={}".format(result_file))
self._target.pull(remote_result_file, result_file)
# Close the app
System.force_stop(self._target, self.package, clear=False)
# Go back to home screen
System.home(self._target)
# Switch back to screen auto rotation
Screen.set_orientation(self._target, auto=True)
# Set brightness back to auto
Screen.set_brightness(self._target, auto=True)
