blob: 93fbc91a69a119a1813111e98dc034f9be102419 [file] [log] [blame]
import os, logging
from autotest_lib.client.bin import utils
from autotest_lib.client.common_lib import error, autotemp
from autotest_lib.client.cros import storage as storage_mod
from autotest_lib.client.cros.power import power_status
class hardware_MultiReaderPowerConsumption(storage_mod.StorageTester):
version = 1
_files_to_delete = []
_ramdisk_path = None
_storage = None
def initialize(self):
super(hardware_MultiReaderPowerConsumption, self).initialize()
# Make sure we're not on AC power
self.status = power_status.get_status()
if self.status.on_ac():
raise error.TestNAError(
'This test needs to be run with the AC power offline')
def cleanup(self):
# Remove intermediate files
for path in self._files_to_delete:
utils.system('rm -f %s' % path)
if self._storage and os.path.ismount(self._storage['mountpoint']):
if self._ramdisk_path and os.path.ismount(
super(hardware_MultiReaderPowerConsumption, self).cleanup()
def readwrite_test(self, path, size, delete_file=False):
"""Heavy-duty random read/write test. Run `dd` & `tail -f` in parallel
The random write is done by writing a file from /dev/urandom into the
given location, while the random read is done by concurrently reading
that file.
@param path: The directory that will create the test file.
@param size: Size of the test file, in MiB.
@param delete_file: Flag the file to be deleted on test exit.
Otherwise file deletion won't be performed.
# Calculate the parameters for dd
size = 1024*1024*size
blocksize = 8192
# Calculate the filename and full path, flag to delete if needed
filename = 'tempfile.%d.delete-me' % size
pathfile = os.path.join(path, filename)
if delete_file:
pid = os.fork() # We need to run two processes in parallel
if pid:
# parent
utils.BgJob('tail -f %s --pid=%s > /dev/null'
% (pathfile, pid))
# Reap the dd child so that tail does not wait for the zombie
os.waitpid(pid, 0)
# child
utils.system('dd if=/dev/urandom of=%s bs=%d count=%s'
% (pathfile, blocksize, (size//blocksize)))
# A forked child is exiting here, so we really do want os._exit:
def run_once(self, ramdisk_size=513, file_size=512, drain_limit=1.05,
volume_filter={'bus': 'usb'}):
"""Test card reader CPU power consumption to be within acceptable
range while performing random r/w
The random r/w is performed in the readwrite_test() method, by
concurrently running `dd if=/dev/urandom` and `tail -f`. It is run once
on a ramdisk with the SD card mounted, then on the SD card with the
ramdisk unmounted, and then on the SD card with the ramdisk unmounted.
The measured values are then reported.
@param ramdisk_size: Size of ramdisk (in MiB).
@param file_size: Size of test file (in MiB).
@param volume_filter: Where to find the card reader.
@param drain_limit: maximum ratio between the card reader
energy consumption and each of the two
ramdisk read/write test energy consumption
values. 1.00 means the card reader test may
not consume more energy than either ramdisk
test, 0.9 means it may consume no more than
90% of the ramdisk value, and so forth.
# Switch to VT2 so the screen turns itself off automatically instead of
# dimming, in order to reduce the battery consuption caused by other
# variables.
utils.system('chvt 2')
logging.debug('STEP 1: ensure SD card is inserted and mounted')
self._storage = self.wait_for_device(volume_filter, cycles=1,
logging.debug('STEP 2: mount the ramdisk')
self._ramdisk_path = autotemp.tempdir(unique_id='ramdisk',
mount_ramdisk(, ramdisk_size)
# Read current charge, as well as maximum charge.
max_charge = self.status.battery.charge_full_design
initial_charge = self.status.battery.charge_now
logging.debug('STEP 3: perform heavy-duty read-write test on ramdisk')
self.readwrite_test(, file_size)
# Read current charge (reading A)
charge_A = self.status.battery.charge_now
logging.debug('STEP 4: unmount ramdisk')
logging.debug('STEP 5: perform identical read write test on SD card')
self.readwrite_test(self._storage['mountpoint'], file_size,
# Read current charge (reading B)
charge_B = self.status.battery.charge_now
logging.debug('STEP 6: unmount card')
self.scanner.umount_volume(storage_dict=self._storage, args='-f -l')
logging.debug('STEP 7: perform ramdisk test again')
mount_ramdisk(, ramdisk_size)
self.readwrite_test(, file_size)
# Read current charge (reading C)
charge_C = self.status.battery.charge_now
# Compute the results
ramdisk_plus = initial_charge - charge_A
sd_card_solo = charge_A - charge_B
ramdisk_solo = charge_B - charge_C
sd_card_drain_ratio_a = (sd_card_solo / ramdisk_plus)
sd_card_drain_ratio_b = (sd_card_solo / ramdisk_solo)
msg = None
if sd_card_drain_ratio_a > drain_limit:
msg = ('Card reader drain exceeds mounted baseline by > %f (%f)'
% (drain_limit, sd_card_drain_ratio_a))
elif sd_card_drain_ratio_b > drain_limit:
msg = ('Card reader drain exceeds unmounted baseline by > %f (%f)'
% (drain_limit, sd_card_drain_ratio_b))
if msg:
raise error.TestError(msg)
fmt = 'Card reader drain ratio Ok: mounted %f; unmounted %f' % (sd_card_drain_ratio_a, sd_card_drain_ratio_b))
def mount_ramdisk(path, size):
utils.system('mount -t tmpfs none %s -o size=%sm' % (path, size))
def umount_ramdisk(path):
"""Umount ramdisk mounted at |path|
@param path: the mountpoint for the mountd RAM disk
utils.system('rm -rf %s/*' % path)
utils.system('umount -f -l %s' % path)