diff --git a/server/site_tests/android_Binder/android_Binder.py b/server/site_tests/android_Binder/android_Binder.py new file mode 100644 index 000000000..b233b586a --- /dev/null +++ b/server/site_tests/android_Binder/android_Binder.py @@ -0,0 +1,57 @@ +# Tests for android Binder +from __future__ import print_function + +import bench_config +import logging +import os +import re + +from autotest_lib.server import test + +class android_Binder(test.test): + version = 1 + + def run_once(self, host=None): + self.client = host + + out_dir = os.path.join(bench_config.android_home, + 'out/target/product/' + bench_config.product) + + # Set binary directories + lib_dir = os.path.join(out_dir, 'system/lib/libbinder.so') + lib_dir_DUT = '/system/lib/libbinder.so' + lib64_dir = os.path.join(out_dir, 'system/lib64/libbinder.so') + lib64_dir_DUT = '/system/lib64/libbinder.so' + bench_dir = os.path.join(out_dir, + 'symbols/data/nativetest64', + 'binderThroughputTest/binderThroughputTest') + bench_dir_DUT = os.path.join('/data/local/tmp', + 'binderThroughputTest') + + # Push binary to the device + print('Pushing binaries of Binder benchmark onto device!') + host.send_file(bench_dir, bench_dir_DUT, delete_dest=True) + host.send_file(lib_dir, lib_dir_DUT, delete_dest=True) + host.send_file(lib64_dir, lib64_dir_DUT, delete_dest=True) + + # Make sure the binary is executable + self.client.run('chmod u+x ' + bench_dir_DUT) + + print('Running tests on the device...') + # First run creates bench_result + self.client.run('taskset %s /data/local/tmp/' + 'binderThroughputTest > /data/local/tmp/bench_result' + % os.getenv('TEST_MODE')) + # Next 4 runs add to bench_result + for i in xrange(4): + self.client.run('taskset %s /data/local/tmp/' + 'binderThroughputTest >> ' + '/data/local/tmp/bench_result' + % os.getenv('TEST_MODE')) + + # Pull result from the device + out_dir = bench_config.bench_suite_dir + result_dir_DUT = '/data/local/tmp/bench_result' + + host.get_file(result_dir_DUT, out_dir, delete_dest=True) + print('Result has been pulled back to file bench_result!') diff --git a/server/site_tests/android_Binder/bench_config.py b/server/site_tests/android_Binder/bench_config.py new file mode 100644 index 000000000..20f685eb9 --- /dev/null +++ b/server/site_tests/android_Binder/bench_config.py @@ -0,0 +1,19 @@ +#!/bin/bash/python +import os + +home = os.environ["HOME"] + +android_home = os.getenv("ANDROID_HOME", + default=os.path.join(home, + 'android_source/master-googleplex/')) +bench_suite_dir = os.getenv('BENCH_SUITE_DIR', + default=os.path.join(android_home, + 'benchtoolchain')) + +synthmark_dir = 'framework/native/libs/binder' + +real_synthmark_dir = os.path.join(android_home, synthmark_dir) + +out_dir = os.path.join(android_home, 'out') + +product = os.getenv("PRODUCT", default="generic") diff --git a/server/site_tests/android_Binder/control b/server/site_tests/android_Binder/control new file mode 100644 index 000000000..d91854b11 --- /dev/null +++ b/server/site_tests/android_Binder/control @@ -0,0 +1,19 @@ +#Control + +NAME = "Binder" +AUTHOR = "Zhizhou Yang" +ATTRIBUTES = "suite:android_toolchain_benchmark" +TIME = "MEDIUM" +TEST_CATEGORY = "Functional" +TEST_CLASS = "application" +TEST_TYPE = "server" + +DOC = """ + +""" + +def run_binder_test(machine): + host = hosts.create_host(machine) + job.run_test("android_Binder", host=host) + +parallel_simple(run_binder_test, machines) diff --git a/server/site_tests/android_Dex2oat/android_Dex2oat.py b/server/site_tests/android_Dex2oat/android_Dex2oat.py new file mode 100644 index 000000000..dd6af0b53 --- /dev/null +++ b/server/site_tests/android_Dex2oat/android_Dex2oat.py @@ -0,0 +1,70 @@ +# Copyright (c) 2012 The Chromium OS Authors. All rights reserved. +# Use of this source code is governed by a BSD-style license that can be +# found in the LICENSE file. + +import bench_config +import time +import logging +import os +import re + +from autotest_lib.client.common_lib import error +from autotest_lib.server import test + +class android_Dex2oat(test.test): + version = 1 + + def run_once(self, host=None): + self.client = host + + out_dir = os.path.join(bench_config.android_home, + 'out/target/product/', + bench_config.product) + + # Set binary directories + bench_dir = os.path.join(out_dir, 'system/lib/libart-compiler.so') + bench_dir_DUT = '/system/lib/libart-compiler.so' + bench64_dir = os.path.join(out_dir, 'system/lib64/libart-compiler.so') + bench64_dir_DUT = '/system/lib64/libart-compiler.so' + + # Push libart-compiler.so to the device + print('Pushing binaries of newly generated library onto device!') + host.send_file(bench_dir, bench_dir_DUT, delete_dest=True) + host.send_file(bench64_dir, bench64_dir_DUT, delete_dest=True) + + # Set testcase directories + test_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), + 'dex2oat_input') + test_dir_DUT = '/data/local/tmp/' + + # Push testcases to the device + print('Pushing tests onto device!') + host.send_file(test_dir, test_dir_DUT, delete_dest=True) + + # Open file to write the result + with open(os.path.join(bench_config.bench_suite_dir, + 'bench_result'), 'w') as f: + + # There are two benchmarks, chrome and camera. + for i in xrange(2): + f.write('Test %d:\n' % i) + total_time = 0 + # Run benchmark for several times for accurancy + for j in xrange(3): + f.write('Iteration %d: ' % j) + result = self.client.run('time taskset %s dex2oat' + ' --dex-file=data/local/tmp/dex2oat_input/test%d.apk' + ' --oat-file=data/local/tmp/dex2oat_input/test%d.oat' + % (os.getenv('TEST_MODE'), i+1, i+1)) + # Find and record real time of the run + time_str = '' + for t in result.stdout.split() + result.stderr.split(): + if 'm' in t and 's' in t: + time_str = t.split('m') + break + time_sec = float(time_str[0]) * 60 + time_sec += float(time_str[1].split('s')[0]) + f.write('User Time: %.2f seconds\n' % time_sec) + total_time += time_sec + + f.write('Total elapsed time: %.2f seconds.\n\n' % total_time) diff --git a/server/site_tests/android_Dex2oat/bench_config.py b/server/site_tests/android_Dex2oat/bench_config.py new file mode 100644 index 000000000..d2855f22c --- /dev/null +++ b/server/site_tests/android_Dex2oat/bench_config.py @@ -0,0 +1,15 @@ +#!/bin/bash/python +import os + +home = os.environ["HOME"] + +android_home = os.getenv("ANDROID_HOME", + default=os.path.join(home, + 'android_source/master-googleplex/')) +bench_suite_dir = os.getenv('BENCH_SUITE_DIR', + default=os.path.join(android_home, + 'benchtoolchain')) + +out_dir = os.path.join(android_home, 'out') + +product = os.getenv("PRODUCT", default="generic") diff --git a/server/site_tests/android_Dex2oat/control b/server/site_tests/android_Dex2oat/control new file mode 100644 index 000000000..763864f3a --- /dev/null +++ b/server/site_tests/android_Dex2oat/control @@ -0,0 +1,21 @@ +# Copyright (c) 2012 The Chromium OS Authors. All rights reserved. +# Use of this source code is governed by a BSD-style license that can be +# found in the LICENSE file. + +NAME = "Dex2oat" +AUTHOR = "Zhizhou Yang" +ATTRIBUTES = "suite:android_toolchain_benchmark" +TIME = "SHORT" +TEST_CATEGORY = "Functional" +TEST_CLASS = "kernel" +TEST_TYPE = "server" + +DOC = """ + +""" + +def run_dex2oat(machine): + host = hosts.create_host(machine) + job.run_test("android_Dex2oat", host=host) + +parallel_simple(run_dex2oat, machines) diff --git a/server/site_tests/android_Hwui/android_Hwui.py b/server/site_tests/android_Hwui/android_Hwui.py new file mode 100644 index 000000000..21e77fd54 --- /dev/null +++ b/server/site_tests/android_Hwui/android_Hwui.py @@ -0,0 +1,67 @@ +# Tests for android Hwui +from __future__ import print_function + +import bench_config +import logging +import os +import re + +from autotest_lib.server import test + +class android_Hwui(test.test): + version = 1 + + def run_once(self, host=None): + self.client = host + + out_dir = os.path.join(bench_config.android_home, + 'out/target/product/' + bench_config.product) + + lib_dir = os.path.join(out_dir, 'system/lib/libhwui.so') + lib_dir_DUT = '/system/lib/libhwui.so' + lib64_dir = os.path.join(out_dir, 'system/lib64/libhwui.so') + lib64_dir_DUT = '/system/lib64/libhwui.so' + bench_dir = os.path.join(out_dir, + 'symbols/data/benchmarktest64/', + 'hwuimicro/hwuimicro') + bench_dir_DUT = '/data/local/tmp/hwuimicro' + + # Push binary to the device + print('Pushing Hwui benchmark onto device!') + host.send_file(bench_dir, bench_dir_DUT, delete_dest=True) + host.send_file(lib_dir, lib_dir_DUT, delete_dest=True) + host.send_file(lib64_dir, lib64_dir_DUT, delete_dest=True) + + # Make sure the binary is executable + self.client.run('chmod u+x ' + bench_dir_DUT) + + + print('Running tests on the device...') + self.client.run('taskset %s /data/local/tmp/hwuimicro' + ' > /data/local/tmp/bench_result' + % os.getenv('TEST_MODE')) + + # Pull result from the device + out_dir = bench_config.bench_suite_dir + result_dir_DUT = '/data/local/tmp/bench_result' + + host.get_file(result_dir_DUT, out_dir, delete_dest=True) + + # Update total time of the test + t = 0 + with open(os.path.join(out_dir, 'bench_result'), 'r') as fin: + + for lines in fin: + line = lines.split() + print(line) + + # Check if there is test result in this line + if len(line) == 8: + # Accumulate the Run time for the testcase + t += int(line[2]) + + # Append total time to the file + with open(os.path.join(out_dir, 'bench_result'), 'a') as fout: + fout.write('\nTotal elapsed time: %d ns.\n' % t) + + print('Result has been pulled back to file bench_result!') diff --git a/server/site_tests/android_Hwui/bench_config.py b/server/site_tests/android_Hwui/bench_config.py new file mode 100644 index 000000000..a98d259f9 --- /dev/null +++ b/server/site_tests/android_Hwui/bench_config.py @@ -0,0 +1,19 @@ +#!/bin/bash/python +import os + +home = os.environ["HOME"] + +android_home = os.getenv("ANDROID_HOME", + default=os.path.join(home, + 'android_source/master-googleplex/')) +bench_suite_dir = os.getenv('BENCH_SUITE_DIR', + default=os.path.join(android_home, + 'benchtoolchain')) + +hwui_dir = 'frameworks/base/libs/hwui/' + +real_hwui_dir = os.path.join(android_home, hwui_dir) + +out_dir = os.path.join(android_home, 'out') + +product = os.getenv("PRODUCT", default="generic") diff --git a/server/site_tests/android_Hwui/control b/server/site_tests/android_Hwui/control new file mode 100644 index 000000000..89c47da20 --- /dev/null +++ b/server/site_tests/android_Hwui/control @@ -0,0 +1,19 @@ +#Control + +NAME = "Hwui" +AUTHOR = "Zhizhou Yang" +ATTRIBUTES = "suite:android_toolchain_benchmark" +TIME = "MEDIUM" +TEST_CATEGORY = "Functional" +TEST_CLASS = "library" +TEST_TYPE = "server" + +DOC = """ + +""" + +def run_hwui_test(machine): + host = hosts.create_host(machine) + job.run_test("android_Hwui", host=host) + +parallel_simple(run_hwui_test, machines) diff --git a/server/site_tests/android_Panorama/android_Panorama.py b/server/site_tests/android_Panorama/android_Panorama.py new file mode 100644 index 000000000..89b2355e5 --- /dev/null +++ b/server/site_tests/android_Panorama/android_Panorama.py @@ -0,0 +1,53 @@ +# Tests for android Panorama +from __future__ import print_function + +import bench_config +import logging +import os +import re + +from autotest_lib.server import test + +class android_Panorama(test.test): + version = 1 + + def run_once(self, host=None): + self.client = host + + out_dir = os.path.join(bench_config.android_home, + 'out/target/product/' + bench_config.product) + + # Set binary directories + bench_dir = os.path.join(out_dir, + 'data/local/tmp/panorama_bench64') + bench_dir_DUT = '/data/local/tmp/panorama_bench64' + + # Set tests directories + tests_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), + 'panorama_input') + tests_dir_DUT = '/data/local/tmp/panorama_input/' + + # Push binary to the device + print('Pushing binaries of Panorama benchmark onto device!') + host.send_file(bench_dir, bench_dir_DUT, delete_dest=True) + + # Make sure the binary is executable + self.client.run('chmod u+x ' + bench_dir_DUT) + + # Push testcases to the device + print('Pushing tests onto device!') + host.send_file(tests_dir, tests_dir_DUT, delete_dest=True) + + print('Running tests on the device...') + self.client.run('taskset %s /data/local/tmp/panorama_bench64 ' + '/data/local/tmp/panorama_input/panorama_input/test ' + '/data/local/tmp/panorama.ppm' + ' > /data/local/tmp/bench_result' + % os.getenv('TEST_MODE')) + + # Pull result from the device + out_dir = bench_config.bench_suite_dir + result_dir_DUT = '/data/local/tmp/bench_result' + + host.get_file(result_dir_DUT, out_dir, delete_dest=True) + print('Result has been pulled back to file bench_result!') diff --git a/server/site_tests/android_Panorama/bench_config.py b/server/site_tests/android_Panorama/bench_config.py new file mode 100644 index 000000000..075beec76 --- /dev/null +++ b/server/site_tests/android_Panorama/bench_config.py @@ -0,0 +1,19 @@ +#!/bin/bash/python +import os + +home = os.environ["HOME"] + +android_home = os.getenv("ANDROID_HOME", + default=os.path.join(home, + 'android_source/master-googleplex/')) +bench_suite_dir = os.getenv('BENCH_SUITE_DIR', + default=os.path.join(android_home, + 'benchtoolchain')) + +panorama_dir = 'perftests/panorama/' + +real_panorama_dir = os.path.join(android_home, panorama_dir) + +out_dir = os.path.join(android_home, 'out') + +product = os.getenv("PRODUCT", default="generic") diff --git a/server/site_tests/android_Panorama/control b/server/site_tests/android_Panorama/control new file mode 100644 index 000000000..3cd589eed --- /dev/null +++ b/server/site_tests/android_Panorama/control @@ -0,0 +1,19 @@ +#Control + +NAME = "Panorama" +AUTHOR = "Zhizhou Yang" +ATTRIBUTES = "suite:android_toolchain_benchmark" +TIME = "MEDIUM" +TEST_CATEGORY = "Functional" +TEST_CLASS = "application" +TEST_TYPE = "server" + +DOC = """ + +""" + +def run_panorama_test(machine): + host = hosts.create_host(machine) + job.run_test("android_Panorama", host=host) + +parallel_simple(run_panorama_test, machines) diff --git a/server/site_tests/android_Pull/android_Pull.py b/server/site_tests/android_Pull/android_Pull.py new file mode 100644 index 000000000..cff373899 --- /dev/null +++ b/server/site_tests/android_Pull/android_Pull.py @@ -0,0 +1,30 @@ +# Pull profraw data from device +from __future__ import print_function + +import bench_config + +from autotest_lib.server import test + +class android_Pull(test.test): + version = 1 + + def run_once(self, host=None): + self.client = host + + # Tar all the files in profraw directory + tar_file= bench_config.location_DUT + '.tar' + raw_cmd = ('tar -cvf {tar_file} {location_DUT}'.format( + tar_file=tar_file, + location_DUT=bench_config.location_DUT)) + self.client.run(raw_cmd) + + # Pull tar of profraw data from the device + out_dir = bench_config.location + + host.get_file(tar_file, out_dir, delete_dest=True) + + # Remove the data on the device + self.client.run('rm %s' % tar_file) + self.client.run('rm -rf %s' % bench_config.location_DUT) + + print('Profraw data has been pulled from device to local.') diff --git a/server/site_tests/android_Pull/bench_config.py b/server/site_tests/android_Pull/bench_config.py new file mode 100644 index 000000000..37967c2f9 --- /dev/null +++ b/server/site_tests/android_Pull/bench_config.py @@ -0,0 +1,19 @@ +#!/bin/bash/python +import os + +home = os.environ["HOME"] + +android_home = os.getenv("ANDROID_HOME", + default=os.path.join(home, + 'android_source/master-googleplex/')) +bench_suite_dir = os.getenv('BENCH_SUITE_DIR', + default=os.path.join(android_home, + 'benchtoolchain')) + +bench = os.getenv('BENCH', default='Hwui') +location_DUT = os.getenv('LOCATION_DUT', + default=os.path.join('/data/local/tmp', + bench + '_profraw')) +location = os.getenv('LOCATION', default=bench_suite_dir) + +product = os.getenv("PRODUCT", default="generic") diff --git a/server/site_tests/android_Pull/control b/server/site_tests/android_Pull/control new file mode 100644 index 000000000..7b00df7cb --- /dev/null +++ b/server/site_tests/android_Pull/control @@ -0,0 +1,19 @@ +#Control + +NAME = "Pull" +AUTHOR = "Zhizhou Yang" +ATTRIBUTES = "suite:android_toolchain_benchmark" +TIME = "MEDIUM" +TEST_CATEGORY = "Functional" +TEST_CLASS = "library" +TEST_TYPE = "server" + +DOC = """ + +""" + +def run_pull_test(machine): + host = hosts.create_host(machine) + job.run_test("android_Pull", host=host) + +parallel_simple(run_pull_test, machines) diff --git a/server/site_tests/android_SetDevice/android_SetDevice.py b/server/site_tests/android_SetDevice/android_SetDevice.py new file mode 100644 index 000000000..7a7134d58 --- /dev/null +++ b/server/site_tests/android_SetDevice/android_SetDevice.py @@ -0,0 +1,77 @@ +# Set device modes such as cpu frequency +from __future__ import print_function + +import logging +import os +import re +import time + +from autotest_lib.server import test + +def _get_cat_value(result): + return result.stdout.split('\n')[0] + +class android_SetDevice(test.test): + version = 1 + + def run_once(self, host=None): + self.client = host + + # Disable GPU + self.client.run('setprop debug.rs.default-GPU-driver 1') + + # Freeze system + # Stop perfd, mpdecision and thermal-engine to ensure setting runs + # without unexpected errors. + self.client.run('stop thermal-engine') + self.client.run('stop mpdecision') + self.client.run('stop perfd') + + # Set airplane mode on the device + self.client.run('settings put global airplane_mode_on 1') + + print('Setting frequency on the device...') + frequency = os.getenv('FREQUENCY') + + # Get number of cores on device + result = self.client.run('ls /sys/devices/system/cpu/ ' + '| grep cpu[0-9].*') + cores = result.stdout.splitlines() + for core in cores: + if core.startswith('cpu'): + # First set all cores online + online = os.path.join('/sys/devices/system/cpu', core, 'online') + online_status = _get_cat_value(self.client.run('cat %s' % online)) + if online_status == '0': + self.client.run('echo %s > %s' % ('1', online)) + + freq_path = os.path.join('/sys/devices/system/cpu', core, + 'cpufreq') + + # Check if the frequency user entered is legal or not. + available_freq = self.client.run('cat %s/' + 'scaling_available_frequencies' + % (freq_path)) + available_freq_list = _get_cat_value(available_freq).split() + + if frequency not in available_freq_list: + raise ValueError('Wrong freqeuncy input, ' + 'please select from: \n%s' + % (' '.join(available_freq_list))) + + # Set frequency + self.client.run('echo %s > %s/scaling_min_freq' + % (frequency, freq_path)) + self.client.run('echo %s > %s/scaling_max_freq' + % (frequency, freq_path)) + + # Sleep for 2 seconds, let device update the frequency. + time.sleep(2) + + # Get current frequency + freq = self.client.run('cat %s/cpuinfo_cur_freq' % freq_path) + f = _get_cat_value(freq) + if f != frequency: + raise RuntimeError('Expected frequency for %s to be %s, ' + 'but is %s' % (core, frequency, f)) + print('CPU frequency has been set to %s' % (frequency)) diff --git a/server/site_tests/android_SetDevice/control b/server/site_tests/android_SetDevice/control new file mode 100644 index 000000000..85163706d --- /dev/null +++ b/server/site_tests/android_SetDevice/control @@ -0,0 +1,19 @@ +# Control + +NAME = "SetDevice" +AUTHOR = "Zhizhou Yang" +ATTRIBUTES = "suite:android_toolchain_benchmark" +TIME = "MEDIUM" +TEST_CATEGORY = "Functional" +TEST_CLASS = "application" +TEST_TYPE = "server" + +DOC = """ +Set the core frequency and which core online for devices. +""" + +def run_set_device_test(machine): + host = hosts.create_host(machine) + job.run_test("android_SetDevice", host=host) + +parallel_simple(run_set_device_test, machines) diff --git a/server/site_tests/android_Skia/android_Skia.py b/server/site_tests/android_Skia/android_Skia.py new file mode 100644 index 000000000..80b39a027 --- /dev/null +++ b/server/site_tests/android_Skia/android_Skia.py @@ -0,0 +1,59 @@ +# Tests for android Skia +from __future__ import print_function + +import bench_config +import logging +import os +import re + +from autotest_lib.server import test + +class android_Skia(test.test): + version = 1 + + def run_once(self, host=None): + self.client = host + + out_dir = os.path.join(bench_config.android_home, + 'out/target/product/' + bench_config.product) + + # Set binary directories + bench_dir = os.path.join(out_dir, + 'data/nativetest64/', + 'skia_nanobench/skia_nanobench') + bench_dir_DUT = '/data/local/tmp/skia_nanobench' + + # Push binary to the device + print('Pushing Skia benchmark onto device!') + host.send_file(bench_dir, bench_dir_DUT, delete_dest=True) + + # Make sure the binary is executable + self.client.run('chmod u+x ' + bench_dir_DUT) + + # Set resource directory + resource_dir = os.path.join(bench_config.real_skia_dir, 'resources') + resource_dir_DUT = '/data/local/tmp/skia_resources/' + + # Push binary to the device + print('Pushing Skia resources onto device!') + host.send_file(resource_dir, resource_dir_DUT, delete_dest=True) + + # Run tests + print('Running tests on the device...') + try: + self.client.run('taskset %s ./data/local/tmp/skia_nanobench' + ' --outResultsFile /data/local/tmp/bench_result' + ' --samples 25' + ' --config nonrendering' + % os.getenv('TEST_MODE')) + except: + # Ignore Abort caused failure + None + + # Pull result from the device + out_dir = bench_config.bench_suite_dir + result_dir_DUT = '/data/local/tmp/bench_result' + + host.get_file(result_dir_DUT, out_dir, delete_dest=True) + + print('Result has been pulled back to file bench_result!') diff --git a/server/site_tests/android_Skia/bench_config.py b/server/site_tests/android_Skia/bench_config.py new file mode 100644 index 000000000..5d38d452f --- /dev/null +++ b/server/site_tests/android_Skia/bench_config.py @@ -0,0 +1,19 @@ +#!/bin/bash/python +import os + +home = os.environ["HOME"] + +android_home = os.getenv("ANDROID_HOME", + default=os.path.join(home, + 'android_source/master-googleplex/')) +bench_suite_dir = os.getenv('BENCH_SUITE_DIR', + default=os.path.join(android_home, + 'benchtoolchain')) + +skia_dir = 'external/skia' + +real_skia_dir = os.path.join(android_home, skia_dir) + +out_dir = os.path.join(android_home, 'out') + +product = os.getenv("PRODUCT", default="generic") diff --git a/server/site_tests/android_Skia/control b/server/site_tests/android_Skia/control new file mode 100644 index 000000000..e38195a8c --- /dev/null +++ b/server/site_tests/android_Skia/control @@ -0,0 +1,19 @@ +#Control + +NAME = "Skia" +AUTHOR = "Zhizhou Yang" +ATTRIBUTES = "suite:android_toolchain_benchmark" +TIME = "MEDIUM" +TEST_CATEGORY = "Functional" +TEST_CLASS = "library" +TEST_TYPE = "server" + +DOC = """ + +""" + +def run_skia_test(machine): + host = hosts.create_host(machine) + job.run_test("android_Skia", host=host) + +parallel_simple(run_skia_test, machines) diff --git a/server/site_tests/android_Synthmark/android_Synthmark.py b/server/site_tests/android_Synthmark/android_Synthmark.py new file mode 100644 index 000000000..b317bd0f3 --- /dev/null +++ b/server/site_tests/android_Synthmark/android_Synthmark.py @@ -0,0 +1,48 @@ +# Tests for android Synthmark +from __future__ import print_function + +import bench_config +import logging +import os +import re + +from autotest_lib.server import test + +class android_Synthmark(test.test): + version = 1 + + def run_once(self, host=None): + self.client = host + + out_dir = os.path.join(bench_config.android_home, + 'out/target/product/' + bench_config.product) + + # Set binary directories + bench_dir = os.path.join(out_dir, + 'symbols/system/bin/synthmark') + bench_dir_DUT = '/data/local/tmp/synthmark' + + # Push binary to the device + print('Pushing binaries of Synthmark benchmark onto device!') + host.send_file(bench_dir, bench_dir_DUT, delete_dest=True) + + # Make sure the binary is executable + self.client.run('chmod u+x ' + bench_dir_DUT) + + print('Running tests on the device...') + # First run creates bench_result + self.client.run('taskset %s /data/local/tmp/synthmark' + ' > /data/local/tmp/bench_result' + % os.getenv('TEST_MODE')) + # Next 4 runs add to bench_result + for i in xrange(4): + self.client.run('taskset %s /data/local/tmp/synthmark' + ' >> /data/local/tmp/bench_result' + % os.getenv('TEST_MODE')) + + # Pull result from the device + out_dir = bench_config.bench_suite_dir + result_dir_DUT = '/data/local/tmp/bench_result' + + host.get_file(result_dir_DUT, out_dir, delete_dest=True) + print('Result has been pulled back to file bench_result!') diff --git a/server/site_tests/android_Synthmark/bench_config.py b/server/site_tests/android_Synthmark/bench_config.py new file mode 100644 index 000000000..7d7aacacd --- /dev/null +++ b/server/site_tests/android_Synthmark/bench_config.py @@ -0,0 +1,19 @@ +#!/bin/bash/python +import os + +home = os.environ["HOME"] + +android_home = os.getenv("ANDROID_HOME", + default=os.path.join(home, + 'android_source/master-googleplex/')) +bench_suite_dir = os.getenv('BENCH_SUITE_DIR', + default=os.path.join(android_home, + 'benchtoolchain')) + +synthmark_dir = 'synthmark' + +real_synthmark_dir = os.path.join(android_home, synthmark_dir) + +out_dir = os.path.join(android_home, 'out') + +product = os.getenv("PRODUCT", default="generic") diff --git a/server/site_tests/android_Synthmark/control b/server/site_tests/android_Synthmark/control new file mode 100644 index 000000000..144766351 --- /dev/null +++ b/server/site_tests/android_Synthmark/control @@ -0,0 +1,19 @@ +#Control + +NAME = "Synthmark" +AUTHOR = "Zhizhou Yang" +ATTRIBUTES = "suite:android_toolchain_benchmark" +TIME = "MEDIUM" +TEST_CATEGORY = "Functional" +TEST_CLASS = "application" +TEST_TYPE = "server" + +DOC = """ + +""" + +def run_synthmark_test(machine): + host = hosts.create_host(machine) + job.run_test("android_Synthmark", host=host) + +parallel_simple(run_synthmark_test, machines) diff --git a/site_utils/pull_device.py b/site_utils/pull_device.py new file mode 100755 index 000000000..959c4443d --- /dev/null +++ b/site_utils/pull_device.py @@ -0,0 +1,116 @@ +#!/usr/bin/python +# +# Script to pull data from android device +from __future__ import print_function + +import argparse +import common +import logging +import os +import sys + +# Turn the logging level to INFO before importing other autotest +# code, to avoid having failed import logging messages confuse the +# test_droid user. +logging.basicConfig(level=logging.INFO) + +# Unfortunately, autotest depends on external packages for assorted +# functionality regardless of whether or not it is needed in a particular +# context. +# Since we can't depend on people to import these utilities in any principled +# way, we dynamically download code before any autotest imports. +try: + import chromite.lib.terminal # pylint: disable=unused-import + import django.http # pylint: disable=unused-import +except ImportError: + # Ensure the chromite site-package is installed. + import subprocess + build_externals_path = os.path.join( + os.path.dirname(os.path.dirname(os.path.realpath(__file__))), + 'utils', 'build_externals.py') + subprocess.check_call([build_externals_path, '--names_to_check', + 'chromiterepo', 'django']) + # Restart the script so python now finds the autotest site-packages. + sys.exit(os.execv(__file__, sys.argv)) + +from autotest_lib.client.common_lib import utils +from autotest_lib.server.hosts import adb_host +from autotest_lib.site_utils import test_runner_utils +from autotest_lib.site_utils import tester_feedback + +def _parse_arguments_internal(argv): + """ + Parse command line arguments + + @param argv: argument list to parse + + @returns: tuple of parsed arguments and argv suitable for remote runs + + @raises SystemExit if arguments are malformed, or required arguments + are not present. + """ + + parser = argparse.ArgumentParser(description='Run remote tests.') + + parser.add_argument('-b', '--bench', metavar='BENCH', required=True, + help='Select the benchmark want to be run for ' + 'test.') + parser.add_argument('-s', '--serials', metavar='SERIALS', + help='Comma separate list of device serials under ' + 'test.') + parser.add_argument('-r', '--remote', metavar='REMOTE', + default='localhost', + help='hostname[:port] if the ADB device is connected ' + 'to a remote machine. Ensure this workstation ' + 'is configured for passwordless ssh access as ' + 'users "root" or "adb"') + + parser.add_argument('-d', '--pathDUT', + help='Specify the location to put the file on DUT.') + parser.add_argument('-p', '--path', + help='Specify the location to put the file locally.') + + return parser.parse_args(argv) + +def main(argv): + """ + Entry point for pull_device script. + + @param argv: arguments list + """ + arguments = _parse_arguments_internal(argv) + + serials = arguments.serials + if serials is None: + result = utils.run(['adb', 'devices']) + devices = adb_host.ADBHost.parse_device_serials(result.stdout) + if len(devices) != 1: + logging.error('Could not detect exactly one device; please select ' + 'one with -s: %s', devices) + return 1 + serials = devices[0] + + autotest_path = os.path.dirname(os.path.dirname( + os.path.realpath(__file__))) + site_utils_path = os.path.join(autotest_path, 'site_utils') + realpath = os.path.realpath(__file__) + site_utils_path = os.path.realpath(site_utils_path) + host_attributes = {'serials': serials, + 'os_type': 'android'} + results_directory = test_runner_utils.create_results_directory(None) + + os.environ['BENCH'] = arguments.bench + os.environ['LOCATION_DUT'] = arguments.pathDUT + os.environ['LOCATION'] = arguments.path + + tests = ['Pull'] + + if test_runner_utils.perform_run_from_autotest_root( + autotest_path, argv, tests, arguments.remote, + host_attributes=host_attributes, + results_directory=results_directory): + logging.error('Error while running on device.') + return 1 + +if __name__ == '__main__': + sys.exit(main(sys.argv[1:])) diff --git a/site_utils/set_device.py b/site_utils/set_device.py new file mode 100755 index 000000000..abb8a8dcc --- /dev/null +++ b/site_utils/set_device.py @@ -0,0 +1,110 @@ +#!/usr/bin/python +from __future__ import print_function + +import argparse +import common +import logging +import os +import sys + +# Turn the logging level to INFO before importing other autotest code, to avoid +# having failed import logging messages confuse the test_droid user. +logging.basicConfig(level=logging.INFO) + +# Unfortunately, autotest depends on external packages for assorted +# functionality regardless of whether or not it is needed in a particular +# context. Since we can't depend on people to import these utilities in any +# principled way, we dynamically download code before any autotest imports. +try: + import chromite.lib.terminal # pylint: disable=unused-import + import django.http # pylint: disable=unused-import +except ImportError: + # Ensure the chromite site-package is installed. + import subprocess + build_externals_path = os.path.join( + os.path.dirname(os.path.dirname(os.path.realpath(__file__))), + 'utils', 'build_externals.py') + subprocess.check_call([build_externals_path, '--names_to_check', + 'chromiterepo', 'django']) + # Restart the script so python now finds the autotest site-packages. + sys.exit(os.execv(__file__, sys.argv)) + +from autotest_lib.client.common_lib import utils +from autotest_lib.server.hosts import adb_host +from autotest_lib.site_utils import test_runner_utils +from autotest_lib.site_utils import tester_feedback + +def _parse_arguments_internal(argv): + """ + Parse command line arguments + + @param argv: argument list to parse + + @returns: tuple of parsed arguments and argv suitable for remote runs + + @raises SystemExit if arguments are malformed, or required arguments + are not present. + """ + + parser = argparse.ArgumentParser(description='Set device cpu cores and ' + 'frequency.') + + parser.add_argument('-s', '--serials', metavar='SERIALS', + help='Comma separate list of device serials under ' + 'test.') + parser.add_argument('-r', '--remote', metavar='REMOTE', + default='localhost', + help='hostname[:port] if the ADB device is connected ' + 'to a remote machine. Ensure this workstation ' + 'is configured for passwordless ssh access as ' + 'users "root" or "adb"') + parser.add_argument('-q', '--frequency', type=int, default=960000, + help='Specify the CPU frequency of the device, lower ' + 'frequency will slow down the performance but ' + 'reduce noise.') + + return parser.parse_args(argv) + +def main(argv): + """ + Entry point for set_device script. + + @param argv: arguments list + """ + arguments = _parse_arguments_internal(argv) + + serials = arguments.serials + if serials is None: + result = utils.run(['adb', 'devices']) + devices = adb_host.ADBHost.parse_device_serials(result.stdout) + if len(devices) != 1: + logging.error('Could not detect exactly one device; please select ' + 'one with -s: %s', devices) + return 1 + serials = devices[0] + + autotest_path = os.path.dirname(os.path.dirname( + os.path.realpath(__file__))) + site_utils_path = os.path.join(autotest_path, 'site_utils') + realpath = os.path.realpath(__file__) + site_utils_path = os.path.realpath(site_utils_path) + host_attributes = {'serials': serials, + 'os_type': 'android'} + results_directory = test_runner_utils.create_results_directory(None) + + logging.info('Start setting CPU frequency on the device...') + + os.environ['FREQUENCY'] = str(arguments.frequency) + + set_device = ['SetDevice'] + if test_runner_utils.perform_run_from_autotest_root( + autotest_path, argv, set_device, arguments.remote, + host_attributes=host_attributes, + results_directory=results_directory): + logging.error('Error while setting device!') + return 1 + + return 0 + +if __name__ == '__main__': + sys.exit(main(sys.argv[1:])) diff --git a/site_utils/test_bench.py b/site_utils/test_bench.py new file mode 100755 index 000000000..4d0773ad9 --- /dev/null +++ b/site_utils/test_bench.py @@ -0,0 +1,133 @@ +#!/usr/bin/python +from __future__ import print_function + +import argparse +import common +import logging +import os +import sys + +# Turn the logging level to INFO before importing other autotest +# code, to avoid having failed import logging messages confuse the +# test_droid user. +logging.basicConfig(level=logging.INFO) + +# Unfortunately, autotest depends on external packages for assorted +# functionality regardless of whether or not it is needed in a particular +# context. +# Since we can't depend on people to import these utilities in any principled +# way, we dynamically download code before any autotest imports. +try: + import chromite.lib.terminal # pylint: disable=unused-import + import django.http # pylint: disable=unused-import +except ImportError: + # Ensure the chromite site-package is installed. + import subprocess + build_externals_path = os.path.join( + os.path.dirname(os.path.dirname(os.path.realpath(__file__))), + 'utils', 'build_externals.py') + subprocess.check_call([build_externals_path, '--names_to_check', + 'chromiterepo', 'django']) + # Restart the script so python now finds the autotest site-packages. + sys.exit(os.execv(__file__, sys.argv)) + +from autotest_lib.client.common_lib import utils +from autotest_lib.server.hosts import adb_host +from autotest_lib.site_utils import test_runner_utils +from autotest_lib.site_utils import tester_feedback + +def _parse_arguments_internal(argv): + """ + Parse command line arguments + + @param argv: argument list to parse + + @returns: tuple of parsed arguments and argv suitable for remote runs + + @raises SystemExit if arguments are malformed, or required arguments + are not present. + """ + + parser = argparse.ArgumentParser(description='Run remote tests.') + + parser.add_argument('-b', '--bench', metavar='BENCH', required=True, + help='Select the benchmark want to be run for ' + 'test.') + parser.add_argument('-s', '--serials', metavar='SERIALS', + help='Comma separate list of device serials under ' + 'test.') + parser.add_argument('-r', '--remote', metavar='REMOTE', + default='localhost', + help='hostname[:port] if the ADB device is connected ' + 'to a remote machine. Ensure this workstation ' + 'is configured for passwordless ssh access as ' + 'users "root" or "adb"') + parser.add_argument('-m', '--mode', default='little', + help='Two modes can be chosen, little mode runs on a ' + 'single core of Cortex-A53, while big mode runs ' + 'on single core of Cortex-A57.') + + return parser.parse_args(argv) + +def main(argv): + """ + Entry point for test_bench script. + + @param argv: arguments list + """ + arguments = _parse_arguments_internal(argv) + + serials = arguments.serials + if serials is None: + result = utils.run(['adb', 'devices']) + devices = adb_host.ADBHost.parse_device_serials(result.stdout) + if len(devices) != 1: + logging.error('Could not detect exactly one device; please select ' + 'one with -s: %s', devices) + return 1 + serials = devices[0] + + autotest_path = os.path.dirname(os.path.dirname( + os.path.realpath(__file__))) + site_utils_path = os.path.join(autotest_path, 'site_utils') + realpath = os.path.realpath(__file__) + site_utils_path = os.path.realpath(site_utils_path) + host_attributes = {'serials': serials, + 'os_type': 'android'} + results_directory = test_runner_utils.create_results_directory(None) + + bench = arguments.bench + + benchlist = ['Panorama', 'Skia', 'Dex2oat', 'Hwui', "Synthmark", "Binder"] + + logging.info('Start testing benchmark on the device...') + + if bench not in benchlist: + logging.error('Please select one benchmark from the list below: \n%s', + '\n'.join(benchlist)) + return 1 + + # Use taskset command to run benchmarks with different CPU core settings. + # + # TEST_MODE variable is set to either 7 or 56 for coremask in taskset. + # + # While Nexus 6P has 8 cores and 5X has 6 cores. CPU number 0-3 in both + # devices belongs to Cortex 53, which are slow. CPU number 4-5 in 5X and 4-7 + # in 6P belongs to Cortex 57, which are fast. + # + # So we set 7(0x00000111) for little mode, that runs the benchmark on three + # slow cores; 56(0x00111000) for big mode, that runs the benchmark on two + # fast and one slow cores. + os.environ['TEST_MODE'] = '7' if arguments.mode == 'little' else '56' + + tests = [bench] + + if test_runner_utils.perform_run_from_autotest_root( + autotest_path, argv, tests, arguments.remote, + host_attributes=host_attributes, + results_directory=results_directory): + logging.error('Error while testing on device.') + return 1 + +if __name__ == '__main__': + sys.exit(main(sys.argv[1:]))