def launch_simple_architecture(config, supervisor):
# Pusher
pusher_generator = PusherGenerator()
pusher_info = pusher_generator.generate(config)
pusher_cls, pusher_start_message = pusher_info['test_pusher']
pusher = supervisor.launch(pusher_cls, pusher_start_message)
# Dispatcher
route_table = RouteTable()
route_table.dispatch_rule(
HWPCReport,
HWPCDispatchRule(getattr(HWPCDepthLevel, 'SOCKET'), primary=True))
dispatcher_start_message = DispatcherStartMessage(
'system', 'dispatcher', DummyFormulaActor,
DummyFormulaValues({'test_pusher': pusher}, 0), route_table, 'cpu')
dispatcher = supervisor.launch(DispatcherActor, dispatcher_start_message)
# Puller
report_filter = Filter()
report_filter.filter(filter_rule, dispatcher)
puller_generator = PullerGenerator(report_filter, [])
puller_info = puller_generator.generate(config)
puller_cls, puller_start_message = puller_info['test_puller']
puller = supervisor.launch(puller_cls, puller_start_message)
def run_selfwatts(args) -> None:
"""
Run PowerAPI with the SelfWatts formula.
:param args: CLI arguments namespace
"""
fconf = args['formula']['selfwatts']
logging.info('SelfWatts version %s using PowerAPI version %s', selfwatts_version, powerapi_version)
if fconf['disable-cpu-formula'] and fconf['disable-dram-formula']:
logging.error('You need to enable at least one formula')
return
route_table = RouteTable()
route_table.dispatch_rule(HWPCReport, HWPCDispatchRule(HWPCDepthLevel.SOCKET, primary=True))
cpu_topology = CPUTopology(fconf['cpu-tdp'], fconf['cpu-base-clock'], fconf['cpu-ratio-min'],
fconf['cpu-ratio-base'], fconf['cpu-ratio-max'],
fconf['cpu-num-fixed-counters'], fconf['cpu-num-general-counters'])
report_filter = Filter()
pullers = PullerGenerator(report_filter).generate(args)
pushers = PusherGenerator().generate(args)
dispatchers = {}
logging.info('CPU formula is %s' % ('DISABLED' if fconf['disable-cpu-formula'] else 'ENABLED'))
if not fconf['disable-cpu-formula']:
logging.info('CPU formula parameters: RAPL_REF=%s ERROR_THRESHOLD=%sW' % (fconf['cpu-rapl-ref-event'], fconf['cpu-error-threshold']))
dispatchers['cpu'] = setup_cpu_formula_actor(fconf, route_table, report_filter, cpu_topology, pushers)
logging.info('DRAM formula is %s' % ('DISABLED' if fconf['disable-dram-formula'] else 'ENABLED'))
if not fconf['disable-dram-formula']:
logging.info('DRAM formula parameters: RAPL_REF=%s ERROR_THRESHOLD=%sW' % (fconf['dram-rapl-ref-event'], fconf['dram-error-threshold']))
dispatchers['dram'] = setup_dram_formula_actor(fconf, route_table, report_filter, cpu_topology, pushers)
actors = OrderedDict(**pushers, **dispatchers, **pullers)
def term_handler(_, __):
for _, actor in actors.items():
actor.soft_kill()
exit(0)
signal.signal(signal.SIGTERM, term_handler)
signal.signal(signal.SIGINT, term_handler)
supervisor = BackendSupervisor(config['stream'])
try:
logging.info('Starting SelfWatts actors...')
for _, actor in actors.items():
supervisor.launch_actor(actor)
except ActorInitError as exn:
logging.error('Actor initialization error: ' + exn.message)
supervisor.kill_actors()
logging.info('SelfWatts is now running...')
supervisor.join()
logging.info('SelfWatts is shutting down...')
def route_table_no_hwpc():
"""
return a RouteTable with :
- a FakeGBR as primary rule
"""
route_table = RouteTable()
route_table.dispatch_rule(FakeReport, FakeGBR(primary=True))
return route_table
def run(self):
# Setup signal handler
def term_handler(_, __):
puller.send_kill()
dispatcher.send_kill()
pusher.send_kill()
exit(0)
signal.signal(signal.SIGTERM, term_handler)
signal.signal(signal.SIGINT, term_handler)
stream_mode = True
supervisor = BackendSupervisor(stream_mode)
# Pusher
output_mongodb = MongoDB(DB_URI, 'MongoDB1', 'test_result',
HWPCModel())
pusher = PusherActor("pusher_mongodb",
PowerReport,
output_mongodb,
level_logger=LOG_LEVEL)
# Formula
formula_factory = (lambda name, verbose: RAPLFormulaActor(
name, pusher, level_logger=verbose))
# Dispatcher
route_table = RouteTable()
route_table.dispatch_rule(
HWPCReport,
HWPCDispatchRule(getattr(HWPCDepthLevel, 'ROOT'), primary=True))
dispatcher = DispatcherActor('dispatcher',
formula_factory,
route_table,
level_logger=LOG_LEVEL)
# Puller
input_mongodb = MongoDB(DB_URI,
'MongoDB1',
'test_hwrep',
HWPCModel(),
stream_mode=stream_mode)
report_filter = Filter()
report_filter.filter(lambda msg: True, dispatcher)
puller = PullerActor("puller_mongodb",
input_mongodb,
report_filter,
level_logger=LOG_LEVEL)
supervisor.launch_actor(pusher)
supervisor.launch_actor(dispatcher)
supervisor.launch_actor(puller)
time.sleep(1)
os.kill(dispatcher.pid, signal.SIGKILL)
supervisor.join()
def actor(self, dispatch_rules, formula_queue):
route_table = RouteTable()
for report_type, gbr in dispatch_rules:
route_table.dispatch_rule(report_type, gbr)
return DispatcherActor('dispatcher_test',
lambda name, verbose: FakeActor(
name, [], verbose, queue=formula_queue),
route_table,
level_logger=logging.DEBUG)
def route_table_with_primary_rule():
"""
return a RouteTable with :
- a HWPCGrouptBy rule as primary rule
"""
route_table = RouteTable()
route_table.dispatch_rule(
HWPCReport, HWPCDispatchRule(HWPCDepthLevel.ROOT, primary=True))
return route_table
def run(self):
config = {
'verbose': True,
'stream': True,
'output': {
'test_pusher': {
'type': 'mongodb',
'model': 'PowerReport',
'uri': MONGO_URI,
'db': MONGO_DATABASE_NAME,
'collection': MONGO_OUTPUT_COLLECTION_NAME
}
},
'input': {
'test_puller': {
'type': 'mongodb',
'model': 'HWPCReport',
'uri': MONGO_URI,
'db': MONGO_DATABASE_NAME,
'collection': MONGO_INPUT_COLLECTION_NAME
}
}
}
supervisor = Supervisor(config['verbose'])
def term_handler(_, __):
supervisor.shutdown()
exit(0)
signal.signal(signal.SIGTERM, term_handler)
signal.signal(signal.SIGINT, term_handler)
# Pusher
pusher_generator = PusherGenerator()
pusher_info = pusher_generator.generate(config)
pusher_cls, pusher_start_message = pusher_info['test_pusher']
pusher = supervisor.launch(pusher_cls, pusher_start_message)
# Dispatcher
route_table = RouteTable()
route_table.dispatch_rule(
HWPCReport,
HWPCDispatchRule(getattr(HWPCDepthLevel, 'SOCKET'), primary=True))
dispatcher_start_message = DispatcherStartMessage(
'system', 'dispatcher', DummyFormulaActor,
DummyFormulaValues({'test_pusher': pusher}, 0), route_table, 'cpu')
dispatcher = supervisor.launch(DispatcherActor,
dispatcher_start_message)
# Puller
report_filter = Filter()
report_filter.filter(filter_rule, dispatcher)
puller_generator = PullerGenerator(report_filter, [])
puller_info = puller_generator.generate(config)
puller_cls, puller_start_message = puller_info['test_puller']
puller = supervisor.launch(puller_cls, puller_start_message)
supervisor.monitor()
def initialized_dispatcher_actor():
""" return an uninitialized actor """
route_table = RouteTable()
gbr = DispatchRule1A(primary=True)
route_table.dispatch_rule(Report1, gbr)
dispatcher = DispatcherActor(ACTOR_NAME, Mock(), route_table)
dispatcher.state.socket_interface = Mock()
dispatcher.setup()
return dispatcher
def test_dispatcher_that_start_formula_crashing_at_initialization_musnt_forward_report_to_this_formula(self, system, dispatch_rules, actor, logger, dummy_pipe_out):
route_table = RouteTable()
for report_type, gbr in dispatch_rules:
route_table.dispatch_rule(report_type, gbr)
values = FormulaValues({'fake_pusher': LOGGER_NAME})
start_message = DispatcherStartMessage('system', 'dispatcher', CrashInitFormulaActor, values, route_table, 'test_device')
system.ask(actor, start_message)
system.tell(actor, REPORT_1)
assert recv_from_pipe(dummy_pipe_out, 0.5) == (None,None)
def pytest_generate_tests(metafunc):
"""
Function called by pytest when collecting a test_XXX function
define the route_table fixtures in test environement with collected the
value _route_table if it exist or with an empty RouteTable
define the formula_factory fixtures in test environement with collected the
value _formula_factory if it exist or with an formula factory that create FakeFormula
:param metafunc: the test context given by pytest
"""
if 'route_table' in metafunc.fixturenames:
route_table = getattr(metafunc.function, '_route_table', None)
if isinstance(route_table, RouteTable):
metafunc.parametrize('route_table', [route_table])
elif route_table == 'all':
metafunc.parametrize('route_table', [
route_table_no_hwpc(),
route_table_hwpc_not_primary(),
route_table_with_primary_rule()
])
else:
metafunc.parametrize('route_table', [RouteTable()])
if 'formula_factory' in metafunc.fixturenames:
formula_factory = getattr(metafunc.function, '_formula_factory', None)
if formula_factory is None:
def formula_factory(name, log):
return FakeFormulaActor(name,
FORMULA_SOCKET_ADDR,
level_logger=log)
metafunc.parametrize('formula_factory', [formula_factory])
def pytest_generate_tests(metafunc):
"""
Function called by pytest when collecting a test_XXX function
define the route_table fixtures in test environement with collected the
value _route_table if it exist or with an empty RouteTable
:param metafunc: the test context given by pytest
"""
if 'route_table' in metafunc.fixturenames:
route_table = getattr(metafunc.function, '_route_table', None)
if isinstance(route_table, RouteTable):
metafunc.parametrize('route_table', [route_table])
elif route_table == 'all':
metafunc.parametrize('route_table', [
route_table_no_hwpc(),
route_table_hwpc_not_primary(),
route_table_with_primary_rule()
])
else:
metafunc.parametrize('route_table', [RouteTable()])
if 'formula_init_msg' in metafunc.fixturenames:
formula_init_msg = getattr(metafunc.function, '_formula_init_msg',
None)
if isinstance(formula_init_msg, Report):
metafunc.parametrize('formula_init_msg', [[formula_init_msg]])
elif formula_init_msg == 'all':
metafunc.parametrize('formula_init_msg', [[], [gen_good_report()]])
else:
metafunc.parametrize('formula_init_msg', [[]])
def test_run_with_delay_between_message(unused_tcp_port, database, supervisor):
"""
run the same test but set a delay of 1s after sendig the 5th first messages
"""
# Pusher
output_mongodb = MongoDB(DB_URI, 'MongoDB1', 'test_result')
pusher = PusherActor("pusher_mongodb",
PowerModel(),
output_mongodb,
level_logger=LOG_LEVEL,
max_size=0)
# Formula
formula_factory = (lambda name, verbose: DummyFormulaActor(
name, {'my_pusher': pusher}, level_logger=verbose))
# Dispatcher
route_table = RouteTable()
route_table.dispatch_rule(
HWPCReport,
HWPCDispatchRule(getattr(HWPCDepthLevel, 'SOCKET'), primary=True))
dispatcher = DispatcherActor('dispatcher',
formula_factory,
route_table,
level_logger=LOG_LEVEL)
# Puller
input_socket = SocketDB(unused_tcp_port)
report_filter = Filter()
report_filter.filter(lambda msg: True, dispatcher)
puller = PullerActor("puller_socket",
input_socket,
report_filter,
HWPCModel(),
level_logger=LOG_LEVEL,
stream_mode=True)
supervisor.launch_actor(pusher)
supervisor.launch_actor(dispatcher)
supervisor.launch_actor(puller)
time.sleep(1)
json_reports = extract_json_report(10)
client = ClientThreadDelay(json_reports, unused_tcp_port)
client.start()
time.sleep(2)
check_db()
def test_run(database, supervisor):
# Pusher
output_mongodb = MongoDB(DB_URI, 'MongoDB1', 'test_result')
pusher = PusherActor("pusher_mongodb",
PowerModel(),
output_mongodb,
level_logger=LOG_LEVEL)
# Formula
formula_factory = (lambda name, verbose: CrashFormulaActor(
name, {'my_pusher': pusher}, 6, CrashException, level_logger=verbose))
# Dispatcher
route_table = RouteTable()
route_table.dispatch_rule(
HWPCReport,
HWPCDispatchRule(getattr(HWPCDepthLevel, 'SOCKET'), primary=True))
dispatcher = DispatcherActor('dispatcher',
formula_factory,
route_table,
level_logger=LOG_LEVEL)
# Puller
input_mongodb = MongoDB(DB_URI, 'MongoDB1', 'test_hwrep')
report_filter = Filter()
report_filter.filter(lambda msg: True, dispatcher)
puller = PullerActor("puller_mongodb",
input_mongodb,
report_filter,
HWPCModel(),
level_logger=LOG_LEVEL)
supervisor.launch_actor(pusher)
supervisor.launch_actor(dispatcher)
supervisor.launch_actor(puller)
supervisor.join()
check_db()
def test_run(database, supervisor):
# Pusher
output_mongodb = MongoDB(DB_URI, 'MongoDB1', 'test_result')
pusher = PusherActor("pusher_mongodb", PowerModel(), output_mongodb, level_logger=LOG_LEVEL)
# Formula
formula_factory = (lambda name, verbose:
DummyFormulaActor(name, {'my_pusher': pusher}, level_logger=verbose))
# Dispatcher
route_table = RouteTable()
route_table.dispatch_rule(HWPCReport, HWPCDispatchRule(getattr(HWPCDepthLevel, 'SOCKET'), primary=True))
dispatcher = DispatcherActor('dispatcher', formula_factory, route_table, level_logger=LOG_LEVEL)
# Puller
input_mongodb = MongoDB(DB_URI, 'MongoDB1', 'test_hwrep')
report_filter = Filter()
report_filter.filter(lambda msg: True, dispatcher)
puller = PullerActor("puller_mongodb", input_mongodb, report_filter, HWPCModel(), level_logger=LOG_LEVEL)
supervisor.launch_actor(pusher)
supervisor.launch_actor(dispatcher)
supervisor.launch_actor(puller)
t = time.time()
number_of_output_reports = 0
for i in range(3):
time.sleep(0.2)
current = get_number_of_output_reports()
assert current > number_of_output_reports
number_of_output_reports = current
time.sleep(0.1)
supervisor.join()
def route_table_hwpc_not_primary():
"""
return a RouteTable with :
- a FakeGBR as primary rule
- a HWPCGrouptBy rule
"""
route_table = RouteTable()
route_table.dispatch_rule(FakeReport, FakeGBR(primary=True))
route_table.dispatch_rule(HWPCReport,
HWPCDispatchRule(HWPCDepthLevel.ROOT))
return route_table
def run_smartwatts(args, logger):
"""
Run PowerAPI with the SmartWatts formula.
:param args: CLI arguments namespace
:param logger: Log level to use for the actors
"""
# Print configuration
logger.info('SmartWatts version %s using PowerAPI version %s', smartwatts_version, powerapi_version)
logger.info('CPU formula parameters: RAPL_REF=%s ERROR_THRESHOLD=%sW' % (args.cpu_rapl_ref_event, args.cpu_error_threshold))
logger.info('DRAM formula parameters: RAPL_REF=%s ERROR_THRESHOLD=%sW' % (args.dram_rapl_ref_event, args.dram_error_threshold))
# Reports pusher
power_output_mongodb = MongoDB(args.mongodb_uri, args.mongodb_database, args.mongodb_powermeter_collection, None)
power_report_pusher = PusherActor('power_report_pusher', PowerReport, power_output_mongodb)
formula_output_mongodb = MongoDB(args.mongodb_uri, args.mongodb_database, args.mongodb_formula_collection, None)
formula_report_pusher = PusherActor('formula_report_pusher', FormulaReport, formula_output_mongodb)
# Sensor reports route table
route_table = RouteTable()
route_table.dispatch_rule(HWPCReport, HWPCDispatchRule(HWPCDepthLevel.SOCKET, primary=True))
# Shared parameters
pushers = {'power': power_report_pusher, 'formula': formula_report_pusher}
cpu_topology = CPUTopology(args.cpu_base_clock, args.cpu_ratio_min, args.cpu_ratio_base, args.cpu_ratio_max)
# CPU formula dispatcher
def cpu_formula_factory(name: str, _):
scope = SmartWattsFormulaScope.CPU
config = SmartWattsFormulaConfig(scope, args.cpu_rapl_ref_event, args.cpu_error_threshold, cpu_topology)
return SmartWattsFormulaActor(name, pushers, config)
cpu_dispatcher = DispatcherActor('cpu_dispatcher', cpu_formula_factory, route_table)
# DRAM formula dispatcher
def dram_formula_factory(name: str, _):
scope = SmartWattsFormulaScope.DRAM
config = SmartWattsFormulaConfig(scope, args.cpu_rapl_ref_event, args.cpu_error_threshold, cpu_topology)
return SmartWattsFormulaActor(name, pushers, config)
dram_dispatcher = DispatcherActor('dram_dispatcher', dram_formula_factory, route_table)
# Sensor reports puller
input_mongodb = MongoDB(args.mongodb_uri, args.mongodb_database, args.mongodb_sensor_collection, HWPCModel(), stream_mode=True)
report_filter = Filter()
report_filter.filter(lambda msg: True, cpu_dispatcher)
report_filter.filter(lambda msg: True, dram_dispatcher)
puller = PullerActor('hwpc_report_puller', input_mongodb, report_filter)
def term_handler(_, __):
puller.join()
cpu_dispatcher.join()
dram_dispatcher.join()
power_report_pusher.join()
formula_report_pusher.join()
exit(0)
# TERM/INT signals handler
signal.signal(signal.SIGTERM, term_handler)
signal.signal(signal.SIGINT, term_handler)
# Actors supervision
supervisor = Supervisor()
try:
supervisor.launch_actor(power_report_pusher)
supervisor.launch_actor(formula_report_pusher)
supervisor.launch_actor(cpu_dispatcher)
supervisor.launch_actor(dram_dispatcher)
supervisor.launch_actor(puller)
logger.info('Actors initialized, SmartWatts is now running...')
except zmq.error.ZMQError as exn:
logger.error('Communication error, ZMQError code : ' + str(exn.errno) + ' reason : ' + exn.strerror)
supervisor.kill_actors()
except ActorInitError as exn:
logger.error('Actor initialisation error, reason : ' + exn.message)
supervisor.kill_actors()
supervisor.join()
def test_with_slow_formula(database2, supervisor):
"""Test the architecture when it has to deal with a lot of data, with a formula
that is very slow. Input database contain a lot of data, but formula can't
handle them. The puller will end before formula end to handle data and
supervisor will begin to send poisonpill message to all actors. Formula and
pusher must continue to handle report.
Architecture :
- 1 puller (connected to MongoDB1 [collection test_hwrep], stream mode off)
- 1 dispatcher (HWPC dispatch rule (dispatch by SOCKET)
- 1 Dummy Formula with will wait 0.2 ms when it receive a message
- 1 pusher (connected to MongoDB1 [collection test_result]
MongoDB1 content :
- 30 HWPC repport with two socket and one RAPL_EVENT
Scenario:
- Launch the full architecture
Test if:
- after powerapi handle all the reports, test if all the reports was handeled
by the formula and pushed to the mongo database and if no report were lost
"""
# Pusher
output_mongodb = MongoDB(DB_URI, 'MongoDB1', 'test_result')
pusher = PusherActor("pusher_mongodb",
PowerModel(),
output_mongodb,
level_logger=LOG_LEVEL)
# Formula
formula_factory = (lambda name, verbose: DummyFormulaActor(
name, {'my_pusher': pusher}, level_logger=verbose, sleep_time=0.1))
# DummyFormulaActor(name, {'my_pusher': pusher}, level_logger=verbose))
# Dispatcher
route_table = RouteTable()
route_table.dispatch_rule(
HWPCReport,
HWPCDispatchRule(getattr(HWPCDepthLevel, 'SOCKET'), primary=True))
dispatcher = DispatcherActor('dispatcher',
formula_factory,
route_table,
level_logger=LOG_LEVEL)
# Puller
input_mongodb = MongoDB(DB_URI, 'MongoDB1', 'test_hwrep')
report_filter = Filter()
report_filter.filter(lambda msg: True, dispatcher)
puller = PullerActor("puller_mongodb",
input_mongodb,
report_filter,
HWPCModel(),
level_logger=LOG_LEVEL)
supervisor.launch_actor(pusher)
supervisor.launch_actor(dispatcher)
supervisor.launch_actor(puller)
supervisor.join()
assert get_number_of_output_reports() == 30 * 2
def empty_route_table():
"""
return a RouteTable with no rule
"""
return RouteTable()
def launch_powerapi(config, logger):
##########################################################################
# Actor Creation
# Pusher
pushers = generate_pushers(config)
# Formula
formula_factory = (lambda name, verbose: RAPLFormulaActor(
name, pushers, level_logger=verbose))
# Dispatcher
route_table = RouteTable()
route_table.dispatch_rule(
HWPCReport,
HWPCDispatchRule(getattr(HWPCDepthLevel, 'ROOT'), primary=True))
dispatcher = DispatcherActor('dispatcher',
formula_factory,
route_table,
level_logger=config['verbose'])
# Puller
report_filter = Filter()
report_filter.filter(lambda msg: True, dispatcher)
pullers = generate_pullers(config, report_filter)
##########################################################################
# Actor start step
# Setup signal handler
def term_handler(_, __):
for _, puller in pullers.items():
puller.send_kill()
dispatcher.send_kill()
for _, pusher in pushers.items():
pusher.send_kill()
exit(0)
signal.signal(signal.SIGTERM, term_handler)
signal.signal(signal.SIGINT, term_handler)
supervisor = BackendSupervisor(config['stream'])
try:
for _, pusher in pushers.items():
supervisor.launch_actor(pusher)
supervisor.launch_actor(dispatcher)
for _, puller in pullers.items():
supervisor.launch_actor(puller)
except zmq.error.ZMQError as exn:
logger.error('Communication error, ZMQError code : ' + str(exn.errno) +
' reason : ' + exn.strerror)
supervisor.kill_actors()
except ActorInitError as exn:
logger.error('Actor initialisation error, reason : ' + exn.message)
supervisor.kill_actors()
##########################################################################
# Actor run step
# wait
supervisor.join()
def test_run(database, supervisor):
"""
Test the architecture when it has to deal with a lot of data, pulled with a
hight frequency. Input database contain a lot of data, that will overflow the
backend. Backend have to handle all of this data and continue to compute data
and writing them in real time.
Architecture :
- 1 puller (connected to MongoDB1 [collection test_hwrep], stream mode off)
- 1 dispatcher (HWPC dispatch rule (dispatch by SOCKET)
- 1 Dummy Formula
- 1 pusher (connected to MongoDB1 [collection test_result]
MongoDB1 content :
- 3000 HWPC repport with two socket and one RAPL_EVENT
Scenario:
- Launch the full architecture
Test if:
- each 50 ms, reports are writen in the output database
"""
# Pusher
output_mongodb = MongoDB(DB_URI, 'MongoDB1', 'test_result')
pusher = PusherActor("pusher_mongodb",
PowerModel(),
output_mongodb,
level_logger=LOG_LEVEL)
# Formula
formula_factory = (lambda name, verbose: DummyFormulaActor(
name, {'my_pusher': pusher}, level_logger=verbose))
# Dispatcher
route_table = RouteTable()
route_table.dispatch_rule(
HWPCReport,
HWPCDispatchRule(getattr(HWPCDepthLevel, 'SOCKET'), primary=True))
dispatcher = DispatcherActor('dispatcher',
formula_factory,
route_table,
level_logger=LOG_LEVEL)
# Puller
input_mongodb = MongoDB(DB_URI, 'MongoDB1', 'test_hwrep')
report_filter = Filter()
report_filter.filter(lambda msg: True, dispatcher)
puller = PullerActor("puller_mongodb",
input_mongodb,
report_filter,
HWPCModel(),
level_logger=LOG_LEVEL)
supervisor.launch_actor(pusher)
supervisor.launch_actor(dispatcher)
supervisor.launch_actor(puller)
t = time.time()
number_of_output_reports = 0
for i in range(3):
time.sleep(0.2)
current = get_number_of_output_reports()
assert current >= number_of_output_reports
number_of_output_reports = current
time.sleep(0.1)
supervisor.join()
def route_table(logger):
route_table = RouteTable()
route_table.dispatch_rule(
HWPCReport,
HWPCDispatchRule(getattr(HWPCDepthLevel, 'ROOT'), primary=True))
return route_table
def actor_start_message(self, dispatch_rules, logger, formula_class):
route_table = RouteTable()
for report_type, gbr in dispatch_rules:
route_table.dispatch_rule(report_type, gbr)
values = FormulaValues({'fake_pusher': LOGGER_NAME})
return DispatcherStartMessage('system', 'dispatcher', formula_class, values, route_table, 'test_device')
def run_rapl(args) -> None:
"""
Run PowerAPI with the SmartWatts formula.
:param args: CLI arguments namespace
:param logger: Logger to use for the actors
"""
fconf = args
logging.info('RAPL-Formula version %s using PowerAPI version %s', rapl_formula_version, powerapi_version)
if not fconf['enable-cpu-formula'] and not fconf['enable-dram-formula']:
logging.error('You need to enable at least one formula')
return
route_table = RouteTable()
route_table.dispatch_rule(HWPCReport, HWPCDispatchRule(HWPCDepthLevel.SOCKET, primary=True))
report_filter = Filter()
report_modifier_list = ReportModifierGenerator().generate(fconf)
supervisor = Supervisor(args['verbose'])
def term_handler(_, __):
supervisor.shutdown()
sys.exit(0)
signal.signal(signal.SIGTERM, term_handler)
signal.signal(signal.SIGINT, term_handler)
try:
logging.info('Starting RAPL-formula actors...')
power_pushers = {}
pushers_info = PusherGenerator().generate(args)
for pusher_name in pushers_info:
pusher_cls, pusher_start_message = pushers_info[pusher_name]
power_pushers[pusher_name] = supervisor.launch(
pusher_cls, pusher_start_message
)
logging.info('CPU formula is %s' % ('DISABLED' if not fconf['enable-cpu-formula'] else 'ENABLED'))
if fconf['enable-cpu-formula']:
logging.info('CPU formula parameters: RAPL_REF=%s' % (fconf['cpu-rapl-ref-event']))
setup_cpu_formula_actor(supervisor, fconf, route_table, report_filter, power_pushers)
logging.info('DRAM formula is %s' % ('DISABLED' if not fconf['enable-dram-formula'] else 'ENABLED'))
if fconf['enable-dram-formula']:
logging.info('DRAM formula parameters: RAPL_REF=%s' % (fconf['dram-rapl-ref-event']))
setup_dram_formula_actor(supervisor, fconf, route_table, report_filter, power_pushers)
pullers_info = PullerGenerator(report_filter, report_modifier_list).generate(args)
for puller_name in pullers_info:
puller_cls, puller_start_message = pullers_info[puller_name]
supervisor.launch(puller_cls, puller_start_message)
except InitializationException as exn:
logging.error('Actor initialization error: ' + exn.msg)
supervisor.shutdown()
sys.exit(-1)
logging.info('RAPL-formula is now running...')
supervisor.monitor()
logging.info('RAPL-formula is shutting down...')
def route_table_hwpc_not_primary():
route_table = RouteTable()
route_table.dispatch_rule(FakeReport, FakeGBR(primary=True))
route_table.dispatch_rule(
HWPCReport, HWPCDispatchRule(HWPCDepthLevel.ROOT, primary=False))
return route_table
def test_run(files, supervisor):
config = {
'verbose': LOG_LEVEL,
'stream': False,
'input': {
'csv': {
'puller': {
'files': FILES,
'model': 'HWPCReport',
'name': 'puller',
}
}
},
'output': {
'csv': {
'pusher': {
'model': 'PowerReport',
'name': 'pusher',
'directory': ROOT_PATH
}
}
}
}
# Pusher
pusher_generator = PusherGenerator()
pushers = pusher_generator.generate(config)
# Formula
formula_factory = (lambda name, verbose: DummyFormulaActor(
name, pushers, level_logger=config['verbose']))
# Dispatcher
route_table = RouteTable()
route_table.dispatch_rule(
HWPCReport,
HWPCDispatchRule(getattr(HWPCDepthLevel, 'SOCKET'), primary=True))
dispatcher = DispatcherActor('dispatcher',
formula_factory,
route_table,
level_logger=LOG_LEVEL)
# Puller
report_filter = Filter()
report_filter.filter(lambda msg: True, dispatcher)
puller_generator = PullerGenerator(report_filter)
pullers = puller_generator.generate(config)
for _, pusher in pushers.items():
supervisor.launch_actor(pusher)
supervisor.launch_actor(dispatcher)
for _, puller in pullers.items():
supervisor.launch_actor(puller)
supervisor.join()
check_output_file()
def dispatcher_actor():
""" return an uninitialized actor """
dispatcher = DispatcherActor(ACTOR_NAME, Mock(), RouteTable())
dispatcher.state.socket_interface = Mock()
return dispatcher
def init_state():
""" return a fresh dispatcher state """
return DispatcherState(Mock(), lambda formula_id: Mock(), RouteTable())