def run_thread(self):

from time import sleep

temp_file = '/sys/devices/platform/hkdk_tmu/curr_temp'

while True:

with open(temp_file) as f:

d = f.read()

self.temperature = float(d)

sleep(1.0)

def __init__(self):

from threading import Thread

from functools import partial

self.thread = Thread(target=partial(TemperatureLogger.run_thread, self))

self.thread.daemon = True

def run_thread(self):

from time import sleep

temp_file = '/sys/devices/system/cpu/online'

while True:

with open(temp_file) as f:

d = f.read()

self.online_cpus = d

sleep(1.0)

def __init__(self):

from threading import Thread

from functools import partial

self.thread = Thread(target=partial(OnlineCPULogger.run_thread, self))

self.thread.daemon = True

def run_thread(self):

from StringIO import StringIO

from csv import reader as csvreader

with open(self.file) as open_file:

iterator = iter(open_file.readline,b'')

# Ignore rubbish in the beginning

i = 0

for line in iterator:

i += 1

if i > 50:

break

for line in iterator:

values = line.split(',')

values = map(float, values)

self.power = values[0] * values[1] * 10.0

self.voltage = values[0]

self.current = values[1] * 10.0

def __init__(self):

from threading import Thread

from functools import partial

self.file = "/dev/ttyUSB0"

self.power = 0.0

self.voltage = 0.0

self.current = 0.0

self.thread = Thread(target=partial(PowerSerialLogger.run_thread, self))

self.thread.daemon = True

self.thread.start()

def get_nowait(self):

'sched_olord_bi_directional',

'sched_olord_cpu_load_limit',

'sched_olord_cpu_period_lower_limit',

'sched_olord_cpu_period_upper_limit',

'sched_olord_ignore_IO',

'sched_olord_ignore_nice',

'sched_olord_lb_lower_limit',

'sched_olord_lb_multiplier',

'sched_olord_lb_upper_limit',

'sched_olord_period',

'sched_olord_rq_safety_margin'

'hotplug_in_load_limit',

'hotplug_in_sampling_period',

'hotplug_out_load_limit',

'hotplug_out_sampling_period',

'up_threshold'

try:

with open(file_name) as f:

return f.read()

except:

sys_kernel_olord_path = "/proc/sys/kernel/"

ret = {}

for name in proc_sys_kernel_olord_files:

ret[name] = read_maybe(sys_kernel_olord_path + name, maybe_str="0.0")

sys_ondemand_path = "/sys/devices/system/cpu/cpufreq/ondemand/"

ret = {}

for name in sys_ondemand_files:

ret[name] = read_maybe(sys_ondemand_path + name, maybe_str="0.0")

smt_file = '/sys/devices/system/cpu/sched_smt_power_savings'

mc_file = '/sys/devices/system/cpu/sched_mc_power_savings'

return 'smt: ' + read_maybe(smt_file, maybe_str="???").strip() + ", mc: " + \

smt_file = '/sys/devices/system/cpu/sched_smt_power_savings'

mc_file = '/sys/devices/system/cpu/sched_mc_power_savings'

try:

with open(smt_file) as f:

d = f.read().strip()

ret += str(d)

except:

ret += '???'

ret += ', mc: '

try:

with open(mc_file) as f:

d = f.read().strip()

ret += str(d)

except:

ret += '???'

from glob import glob

ret = ''

for file_name in glob('/sys/devices/system/cpu/cpu?/cpufreq/scaling_governor'):

with open(file_name) as f:

d = f.read().strip()

ret += d + " "

try:

with open(filename, "w") as f:

f.write(str(val))

except IOError as e:

config = parse_arguments()

from sqlalchemy import create_engine

from sqlalchemy import Column, Table, MetaData

from sqlalchemy import String, Integer, Float

from sqlalchemy.orm import sessionmaker, mapper

from sqlalchemy.ext.declarative import declarative_base

from time import sleep, time

from stat_reader import StatReader

from itertools import product as set_product

from os import getuid

engine = create_engine('sqlite:///auto_test_log.sqlite')

metadata = MetaData(bind=engine)

Session = sessionmaker(bind=engine)

session = Session()

Base = declarative_base()

if getuid() != 0:

print "Must be root!!"

return

experiment_info = Table('experiment_info', metadata,

Column('experiment_id', String(32), primary_key=True),

Column('start_time', String()),

Column('end_time', String()),

Column('total_time', Float()),

Column('scheduler', String()),

Column('uname_a', String()),

Column('cpufreq_governor', String()),

Column('mt_mc_state', String()),

Column('target_load_level', String()),

Column('num_of_process', String()))

for c_name in proc_sys_kernel_olord_files:

experiment_info.append_column(Column(c_name, Float))

for c_name in sys_ondemand_files:

experiment_info.append_column(Column(c_name, Float))

experiment_data = Table('experiment_data', metadata,

Column('data_id', String(48), primary_key=True),

Column('experiment_id', String(32)),

Column('time', Float()),

Column('voltage', Float),

Column('current', Float),

Column('power', Float),

Column('temperature', Float),

Column('cpus_online', String(10)))

metadata.create_all()

class ExperimentInfo(Base):

__table__ = experiment_info

class ExperimentData(Base):

__table__ = experiment_data

eii = experiment_info.insert()

eid = experiment_data.insert()

psl = PowerSerialLogger()

tl = TemperatureLogger()

ocl = OnlineCPULogger()

def perform_experiment_a(experiment_config):

from md5 import new as new_md5

from pickle import dumps as pickle_dump

from platform import uname

from datetime import datetime

from threading import Thread

from pprint import PrettyPrinter

from simple_run import run_test

pp = PrettyPrinter(indent = 4)

print "Running experiment with config:"

pp.pprint(experiment_config)

current_experiment_id = new_md5(pickle_dump(experiment_config) + str(datetime.now())).hexdigest()

info_dict = {'experiment_id': current_experiment_id,

'start_time': str(datetime.now()),

'scheduler': experiment_config['scheduler'],

'uname_a': ' '.join(uname()),

'cpufreq_governor': get_governor_string(),

'mt_mc_state': get_smt_mc_power_savings(),

'target_load_level': experiment_config['target_load_level'],

'num_of_process': experiment_config['num_of_process'],

'num_of_ops': experiment_config['num_of_ops']}

info_dict.update(get_kernel_olord_settings())

info_dict.update(get_ondemand_settings())

eii.execute(info_dict)

test_args = {'n': experiment_config['num_of_process'],

'a': 'dont_set',

'l': experiment_config['target_load_level'],

'o': experiment_config['num_of_ops']}

class TestThread(Thread):

def __init__(self, args):

self.args = args

Thread.__init__(self)

def run(self):

self.total_time = run_test(self.args)

tt = TestThread(test_args)

tt.start()

start_time = time()

data_counter = 0

while tt.is_alive():

t = time() - start_time

data_dict = {'data_id': current_experiment_id + str(data_counter).zfill(16),

'experiment_id': current_experiment_id,

'time': t,

'voltage': psl.voltage,

'current': psl.current,

'power': psl.power,

'temperature': tl.temperature,

'cpus_online': ocl.online_cpus}

eid.execute(data_dict)

sleep_time = 1.0 - time() + (t + start_time)

sleep_time = 0.0 if (sleep_time < 0) else sleep_time

#print sleep_time

sleep(sleep_time)

data_counter += 1

r = session.query(ExperimentInfo).filter_by(experiment_id = current_experiment_id).first()

r.end_time = str(datetime.now())

r.total_time = float(tt.total_time)

session.commit()

iter_set = set_product([80],

[10],

[10],

[30],

[80],

range(90,9,-5),

range(10))

iter_set = list(iter_set)

test_size = len(iter_set)

start_time = time()

counter = 0

for i in iter_set:

sleep(10.0)

if psl.power < 0.1:

print "Power ridiculously small, check connection to power source."

return

set_config_file('/sys/devices/system/cpu/cpufreq/ondemand/hotplug_in_load_limit', i[0])

set_config_file('/sys/devices/system/cpu/cpufreq/ondemand/hotplug_out_load_limit', i[1])

set_config_file('/sys/devices/system/cpu/cpufreq/ondemand/hotplug_in_sampling_period', i[2])

set_config_file('/sys/devices/system/cpu/cpufreq/ondemand/hotplug_out_sampling_period', i[2])

set_config_file('/sys/devices/system/cpu/cpufreq/ondemand/up_threshold', i[3])

set_config_file('/proc/sys/kernel/sched_olord_lb_upper_limit', i[4])

counter += 1

print "Starting test #%i of ~%i" % (counter, test_size)

t = time() - start_time

r = float(counter) / float(test_size)

eta = t/r - t

print "Estimated time left:", eta, "s"

perform_experiment_a({'scheduler': 'CFS',

'target_load_level': i[5]/100.0,

'num_of_process': 4,