def run(self, out_dir, location_search, swipe_count=5, collect=''):
"""
Run single Gmaps workload.
:param out_dir: Path to experiment directory where to store results.
:type out_dir: str
:param location_search: Search string to be used in GMaps
:type location_search: str
:param swipe_count: Number of sets of (left, right, up, down) swipes to do
:type swipe_count: int
:param collect: Specifies what to collect. Possible values:
- 'energy'
- 'systrace'
- 'ftrace'
- any combination of the above
:type collect: list(str)
"""
# Keep track of mandatory parameters
self.out_dir = out_dir
self.collect = collect
# Set min brightness
Screen.set_brightness(self._target, auto=False, percent=0)
# Unlock device screen (assume no password required)
Screen.unlock(self._target)
# Use the monkey tool to start GMaps
# This allows to subsequently set the screen orientation to LANDSCAPE
# and to reset the frame statistics.
System.monkey(self._target, self.package)
# Force screen in PORTRAIT mode
Screen.set_orientation(self._target, portrait=True)
System.gfxinfo_reset(self._target, self.package)
sleep(1)
# Start GMaps on the target device
loc_url = 'geo:0,0?q='
loc_url += '+'.join(location_search.split())
System.start_action(self._target, self.action, loc_url)
# Allow the activity to start
sleep(1)
script = TargetScript(self._te, "gmaps_swiper.sh")
self._log.debug('Accumulating commands')
for i in range(swipe_count):
System.hswipe(script, 20, 80, 100, True)
script.append('sleep 1')
System.hswipe(script, 20, 80, 100, False)
script.append('sleep 1')
System.vswipe(script, 40, 60, 100, True)
script.append('sleep 1')
System.vswipe(script, 40, 60, 100, False)
script.append('sleep 1')
self._log.debug('Accumulation done')
# Push script to the target
script.push()
self._log.info('Opening GMaps to [%s]', loc_url)
# Let GMaps zoom in on the location
sleep(2)
self.tracingStart()
self._log.info('Launching target script')
script.run()
self._log.info('Target script ended')
self.tracingStop()
# Get frame stats
self.db_file = os.path.join(out_dir, "framestats.txt")
System.gfxinfo_get(self._target, self.package, self.db_file)
# Close the app without clearing the local data to
# avoid the dialog to select the account at next start
System.force_stop(self._target, self.package, clear=False)
# Go back to home screen
System.home(self._target)
# Set brightness back to auto
Screen.set_brightness(self._target, auto=True)
# Switch back to screen auto rotation
Screen.set_orientation(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)
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, location_search, swipe_count=5, collect=''):
"""
Run single Gmaps workload.
:param out_dir: Path to experiment directory where to store results.
:type out_dir: str
:param location_search: Search string to be used in GMaps
:type location_search: str
:param swipe_count: Number of sets of (left, right, up, down) swipes to do
:type swipe_count: int
:param collect: Specifies what to collect. Possible values:
- 'energy'
- 'systrace'
- 'ftrace'
- any combination of the above
:type collect: list(str)
"""
# Keep track of mandatory parameters
self.out_dir = out_dir
self.collect = collect
# Set min brightness
Screen.set_brightness(self._target, auto=False, percent=0)
# Unlock device screen (assume no password required)
Screen.unlock(self._target)
# Use the monkey tool to start GMaps
# This allows to subsequently set the screen orientation to LANDSCAPE
# and to reset the frame statistics.
System.monkey(self._target, self.package)
# Force screen in PORTRAIT mode
Screen.set_orientation(self._target, portrait=True)
System.gfxinfo_reset(self._target, self.package)
sleep(1)
# Start GMaps on the target device
loc_url = 'geo:0,0?q='
loc_url += '+'.join(location_search.split())
System.start_action(self._target, self.action, loc_url)
# Allow the activity to start
sleep(1)
script = TargetScript(self._te, "gmaps_swiper.sh")
self._log.debug('Accumulating commands')
for i in range(swipe_count):
System.hswipe(script, 20, 80, 100, True)
script.append('sleep 1')
System.hswipe(script, 20, 80, 100, False)
script.append('sleep 1')
System.vswipe(script, 40, 60, 100, True)
script.append('sleep 1')
System.vswipe(script, 40, 60, 100, False)
script.append('sleep 1')
self._log.debug('Accumulation done')
# Push script to the target
script.push()
self._log.info('Opening GMaps to [%s]', loc_url)
# Let GMaps zoom in on the location
sleep(2)
self.tracingStart()
self._log.info('Launching target script')
script.run()
self._log.info('Target script ended')
self.tracingStop()
# Get frame stats
self.db_file = os.path.join(out_dir, "framestats.txt")
System.gfxinfo_get(self._target, self.package, self.db_file)
# Close the app without clearing the local data to
# avoid the dialog to select the account at next start
System.force_stop(self._target, self.package, clear=False)
# Go back to home screen
System.home(self._target)
# Set brightness back to auto
Screen.set_brightness(self._target, auto=True)
# Switch back to screen auto rotation
Screen.set_orientation(self._target, auto=True)
