flavor.android.AndroidFlavor Class Reference

Inheritance diagram for flavor.android.AndroidFlavor:

Public Member Functions
def	__init__ (self, m, app_name)
def	install (self)
def	cleanup_steps (self)
def	step (self, name, cmd)
def	copy_file_to_device (self, host, device)
def	copy_directory_contents_to_device (self, host, device)
def	copy_directory_contents_to_host (self, device, host)
def	read_file_on_device (self, path, **kwargs)
def	remove_file_on_device (self, path)
def	create_clean_device_dir (self, path)
Public Member Functions inherited from flavor.default.DefaultFlavor
def	__init__ (self, module, app_name)
def	device_path_join (self, *args)
def	copy_directory_contents_to_device (self, host_dir, device_dir)
def	copy_directory_contents_to_host (self, device_dir, host_dir)
def	copy_file_to_device (self, host_path, device_path)
def	create_clean_device_dir (self, path)
def	create_clean_host_dir (self, path)
def	read_file_on_device (self, path, **kwargs)
def	remove_file_on_device (self, path)
def	install (self)
def	cleanup_steps (self)
def	step (self, name, cmd, **unused_kwargs)

Public Attributes
	ADB_BINARY
	ADB_PUB_KEY
	device_dirs
	cant_root
	cpus_to_scale
	disable_for_nanobench
	gpu_scaling
	app_name
Public Attributes inherited from flavor.default.DefaultFlavor
	app_name
	module
	m
	device_dirs
	host_dirs

Detailed Description

Definition at line 16 of file android.py.

Constructor & Destructor Documentation

__init__()

def flavor.android.AndroidFlavor.__init__	(		self,
			m,
			app_name
	)

Reimplemented from flavor.default.DefaultFlavor.

Definition at line 17 of file android.py.

  def __init__(self, m, app_name):
    super(AndroidFlavor, self).__init__(m, app_name)
    self._ever_ran_adb = False
    self.ADB_BINARY = '/usr/bin/adb.1.0.35'
    self.ADB_PUB_KEY = '/home/chrome-bot/.android/adbkey'
    if 'skia' not in self.m.vars.swarming_bot_id:
      self.ADB_BINARY = '/opt/infra-android/tools/adb'
      self.ADB_PUB_KEY = ('/home/chrome-bot/.android/'
                          'chrome_infrastructure_adbkey')
 
    # Data should go in android_data_dir, which may be preserved across runs.
    android_data_dir = '/sdcard/revenge_of_the_skiabot/'
    self.device_dirs = default.DeviceDirs(
        bin_dir        = '/data/local/tmp/',
        dm_dir         = android_data_dir + 'dm_out',
        perf_data_dir  = android_data_dir + 'perf',
        resource_dir   = android_data_dir + 'resources',
        fonts_dir      = 'NOT_SUPPORTED',
        images_dir     = android_data_dir + 'images',
        lotties_dir    = android_data_dir + 'lotties',
        skp_dir        = android_data_dir + 'skps',
        svg_dir        = android_data_dir + 'svgs',
        tmp_dir        = android_data_dir,
        texttraces_dir = android_data_dir + 'text_blob_traces')
 
    # A list of devices we can't root.  If rooting fails and a device is not
    # on the list, we fail the task to avoid perf inconsistencies.
    self.cant_root = ['GalaxyS7_G930FD', 'GalaxyS9',
                      'GalaxyS20', 'MotoG4', 'NVIDIA_Shield',
                      'P30', 'Pixel4','Pixel4XL', 'Pixel5', 'TecnoSpark3Pro', 'JioNext']
 
    # Maps device type -> CPU ids that should be scaled for nanobench.
    # Many devices have two (or more) different CPUs (e.g. big.LITTLE
    # on Nexus5x). The CPUs listed are the biggest cpus on the device.
    # The CPUs are grouped together, so we only need to scale one of them
    # (the one listed) in order to scale them all.
    # E.g. Nexus5x has cpu0-3 as one chip and cpu4-5 as the other. Thus,
    # if one wants to run a single-threaded application (e.g. nanobench), one
    # can disable cpu0-3 and scale cpu 4 to have only cpu4 and 5 at the same
    # frequency.  See also disable_for_nanobench.
    self.cpus_to_scale = {
      'Nexus5x': [4],
      'Pixel': [2],
      'Pixel2XL': [4]
    }
 
    # Maps device type -> CPU ids that should be turned off when running
    # single-threaded applications like nanobench. The devices listed have
    # multiple, differnt CPUs. We notice a lot of noise that seems to be
    # caused by nanobench running on the slow CPU, then the big CPU. By
    # disabling this, we see less of that noise by forcing the same CPU
    # to be used for the performance testing every time.
    self.disable_for_nanobench = {
      'Nexus5x': range(0, 4),
      'Pixel': range(0, 2),
      'Pixel2XL': range(0, 4),
      'Pixel6': range(4,8), # Only use the 4 small cores.
      'Pixel7': range(4,8),
    }
 
    self.gpu_scaling = {
      "Nexus5":  450000000,
      "Nexus5x": 600000000,
    }
 

Member Function Documentation

cleanup_steps()

def flavor.android.AndroidFlavor.cleanup_steps

(

self

)

Run any device-specific cleanup steps.

Reimplemented from flavor.default.DefaultFlavor.

Definition at line 289 of file android.py.

  def cleanup_steps(self):
    self.m.run(self.m.step,
                'adb reboot device',
                cmd=[self.ADB_BINARY, 'reboot'],
                infra_step=True, timeout=30, abort_on_failure=False,
                fail_build_on_failure=False)
    self.m.run(self.m.step,
                'wait for device after rebooting',
                cmd=[
                    self.ADB_BINARY, 'wait-for-device', 'shell',
                    # Wait until the boot is actually complete.
                    # https://android.stackexchange.com/a/164050
                    'while [[ -z $(getprop sys.boot_completed) ]]; do sleep 1; done',
                ],
                timeout=180, abort_on_failure=False,
                fail_build_on_failure=False)
 
    if 'ASAN' in self.m.vars.extra_tokens:
      self._ever_ran_adb = True
      # Remove ASAN.
      self.m.run(self.m.step,
                 'wait for device before uninstalling ASAN',
                 cmd=[self.ADB_BINARY, 'wait-for-device', 'shell',
                 # Wait until the boot is actually complete.
                 # https://android.stackexchange.com/a/164050
                 'while [[ -z $(getprop sys.boot_completed) ]]; do sleep 1; done',
                 ], infra_step=True,
                 timeout=180, abort_on_failure=False,
                 fail_build_on_failure=False)
      self.m.run(self.m.step, 'uninstall ASAN',
                 cmd=[self._asan_setup_path(), '--revert'],
                 infra_step=True, timeout=300,
                 abort_on_failure=False, fail_build_on_failure=False)
 
    if self._ever_ran_adb:
      script = self.module.resource('dump_adb_log.py')
      self.m.run(self.m.step, 'dump log',
          cmd=['python3', script, self.host_dirs.bin_dir, self.ADB_BINARY],
          infra_step=True,
          timeout=300,
          abort_on_failure=False)
 
    # Only quarantine the bot if the first failed step
    # is an infra step. If, instead, we did this for any infra failures, we
    # would do this too much. For example, if a Nexus 10 died during dm
    # and the following pull step would also fail "device not found" - causing
    # us to run the shutdown command when the device was probably not in a
    # broken state; it was just rebooting.
    if (self.m.run.failed_steps and
        isinstance(self.m.run.failed_steps[0], recipe_api.InfraFailure)):
      bot_id = self.m.vars.swarming_bot_id
      self.m.file.write_text('Quarantining Bot',
                             '/home/chrome-bot/%s.force_quarantine' % bot_id,
                             ' ')
 
    # if self._ever_ran_adb:
    #   self._adb('kill adb server', 'kill-server')
 

copy_directory_contents_to_device()

def flavor.android.AndroidFlavor.copy_directory_contents_to_device	(		self,
			host_dir,
			device_dir
	)

Like shutil.copytree(), but for copying to a connected device.

Reimplemented from flavor.default.DefaultFlavor.

Definition at line 365 of file android.py.

  def copy_directory_contents_to_device(self, host, device):
    contents = self.m.file.glob_paths('ls %s/*' % host,
                                      host, '*',
                                      test_data=['foo.png', 'bar.jpg'])
    args = contents + [device]
    self._adb('push %s/* %s' % (host, device), 'push', *args)
 

copy_directory_contents_to_host()

def flavor.android.AndroidFlavor.copy_directory_contents_to_host	(		self,
			device_dir,
			host_dir
	)

Like shutil.copytree(), but for copying from a connected device.

Reimplemented from flavor.default.DefaultFlavor.

Definition at line 372 of file android.py.

  def copy_directory_contents_to_host(self, device, host):
    # TODO(borenet): When all of our devices are on Android 6.0 and up, we can
    # switch to using tar to zip up the results before pulling.
    with self.m.step.nest('adb pull'):
      tmp = self.m.path.mkdtemp('adb_pull')
      self._adb('pull %s' % device, 'pull', device, tmp)
      paths = self.m.file.glob_paths(
          'list pulled files',
          tmp,
          self.m.path.basename(device) + self.m.path.sep + '*',
          test_data=['%d.png' % i for i in (1, 2)])
      for p in paths:
        self.m.file.copy('copy %s' % self.m.path.basename(p), p, host)
 

copy_file_to_device()

def flavor.android.AndroidFlavor.copy_file_to_device	(		self,
			host_path,
			device_path
	)

Like shutil.copyfile, but for copying to a connected device.

Reimplemented from flavor.default.DefaultFlavor.

Definition at line 362 of file android.py.

  def copy_file_to_device(self, host, device):
    self._adb('push %s %s' % (host, device), 'push', host, device)
 

create_clean_device_dir()

def flavor.android.AndroidFlavor.create_clean_device_dir	(		self,
			path
	)

Like shutil.rmtree() + os.makedirs(), but on a connected device.

Reimplemented from flavor.default.DefaultFlavor.

Definition at line 408 of file android.py.

  def create_clean_device_dir(self, path):
    self.remove_file_on_device(path)
    self._adb('mkdir %s' % path, 'shell', 'mkdir', '-p', path)

install()

def flavor.android.AndroidFlavor.install

(

self

)

Run device-specific installation steps.

Reimplemented from flavor.default.DefaultFlavor.

Definition at line 260 of file android.py.

  def install(self):
    self._adb('mkdir ' + self.device_dirs.resource_dir,
              'shell', 'mkdir', '-p', self.device_dirs.resource_dir)
    if self.m.vars.builder_cfg.get('model') in ['GalaxyS20', 'GalaxyS9']:
      # See skia:10184, should be moot once upgraded to Android 11?
      self._adb('cp libGLES_mali.so to ' + self.device_dirs.bin_dir,
                 'shell', 'cp',
                '/vendor/lib64/egl/libGLES_mali.so',
                self.device_dirs.bin_dir + 'libvulkan.so')
    if 'ASAN' in self.m.vars.extra_tokens:
      self._ever_ran_adb = True
      script = self.module.resource('setup_device_for_asan.py')
      self.m.run(
          self.m.step, 'Setting up device to run ASAN',
          cmd=['python3', script, self.ADB_BINARY, self._asan_setup_path()],
          infra_step=True,
          timeout=300,
          abort_on_failure=True)
    if self.app_name:
      if (self.app_name == 'nanobench'):
        self._scale_for_nanobench()
      else:
        self._scale_for_dm()
      app_path = self.host_dirs.bin_dir.join(self.app_name)
      self._adb('push %s' % self.app_name,
                'push', app_path, self.device_dirs.bin_dir)
 
 
 

read_file_on_device()

def flavor.android.AndroidFlavor.read_file_on_device	(		self,
			path,
		**	kwargs
	)

Reads the specified file.

Reimplemented from flavor.default.DefaultFlavor.

Definition at line 386 of file android.py.

  def read_file_on_device(self, path, **kwargs):
    testKwargs = {
      'attempts': 1,
      'abort_on_failure': False,
      'fail_build_on_failure': False,
    }
    rv = self._adb('check if %s exists' % path,
                   'shell', 'test', '-f', path, **testKwargs)
    if not rv: # pragma: nocover
      return None
 
    rv = self._adb('read %s' % path,
                   'shell', 'cat', path, stdout=self.m.raw_io.output(),
                   **kwargs)
    return rv.stdout.decode('utf-8').rstrip() if rv and rv.stdout else None
 

remove_file_on_device()

def flavor.android.AndroidFlavor.remove_file_on_device	(		self,
			path
	)

Removes the specified file.

Reimplemented from flavor.default.DefaultFlavor.

Definition at line 402 of file android.py.

  def remove_file_on_device(self, path):
    script = self.module.resource('remove_file_on_device.py')
    self.m.run.with_retry(self.m.step, 'rm %s' % path, 3,
        cmd=['python3', script, self.ADB_BINARY, path],
        infra_step=True)
 

step()

def flavor.android.AndroidFlavor.step	(		self,
			name,
			cmd
	)

Reimplemented from flavor.default.DefaultFlavor.

Definition at line 347 of file android.py.

  def step(self, name, cmd):
    sh = '%s.sh' % cmd[0]
    self.m.run.writefile(self.m.vars.tmp_dir.join(sh),
        'set -x; LD_LIBRARY_PATH=%s %s%s; echo $? >%src' % (
            self.device_dirs.bin_dir,
            self.device_dirs.bin_dir, subprocess.list2cmdline(map(str, cmd)),
            self.device_dirs.bin_dir))
    self._adb('push %s' % sh,
              'push', self.m.vars.tmp_dir.join(sh), self.device_dirs.bin_dir)
 
    self._adb('clear log', 'logcat', '-c')
    script = self.module.resource('run_sh.py')
    self.m.step('%s' % cmd[0],
        cmd=['python3', script, self.device_dirs.bin_dir, sh, self.ADB_BINARY])
 

Member Data Documentation

ADB_BINARY

flavor.android.AndroidFlavor.ADB_BINARY

Definition at line 20 of file android.py.

ADB_PUB_KEY

flavor.android.AndroidFlavor.ADB_PUB_KEY

Definition at line 21 of file android.py.

app_name

flavor.android.AndroidFlavor.app_name

Definition at line 279 of file android.py.

cant_root

flavor.android.AndroidFlavor.cant_root

Definition at line 44 of file android.py.

cpus_to_scale

flavor.android.AndroidFlavor.cpus_to_scale

Definition at line 57 of file android.py.

device_dirs

flavor.android.AndroidFlavor.device_dirs

Definition at line 29 of file android.py.

disable_for_nanobench

flavor.android.AndroidFlavor.disable_for_nanobench

Definition at line 69 of file android.py.

gpu_scaling

flavor.android.AndroidFlavor.gpu_scaling

Definition at line 77 of file android.py.

---

The documentation for this class was generated from the following file:

• third_party/skia/infra/bots/recipe_modules/flavor/android.py