async def on_message(
self, context: Context, message: MonitoredMessage[_MT]
) -> Union[RabbitMQMessage, MonitoredMessage[_MT]]:
if not isinstance(message, MonitoredMessage):
return message
self._merge_dict[type(message.source)] = message
if all(self._merge_dict.values()):
routing_key = BaseBenchmark.of(context).group_name
data = self._merge_dict[PerfMonitor].data
data['wall_cycle'] = self._merge_dict[RDTSCMonitor].data
for key in self._merge_dict[ResCtrlMonitor].data[0].keys():
data[key] = sum(
map(lambda x: x[key],
self._merge_dict[ResCtrlMonitor].data))
ret = RabbitMQMessage(data, self, routing_key)
for key in self._merge_dict.keys():
self._merge_dict[key] = None
return ret
else:
return message
async def on_message(
self, context: Context,
message: PerBenchMessage[_MT]) -> Optional[PerBenchMessage[_MT]]:
if not isinstance(message, PerBenchMessage) or not isinstance(
message.source, ResCtrlMonitor):
return message
if self._aio_blocks is tuple():
benchmark = BaseBenchmark.of(context)
privilege_cfg = PrivilegeConfig.of(context).result
self._aio_blocks = tuple(
self._create_aio_blocks(privilege_cfg, benchmark.identifier,
message.data))
self._event_order = tuple(message.data[0].keys())
for block in self._aio_blocks:
block.buffer = (','.join(self._event_order) + '\n').encode()
await aio_context().submit(*self._aio_blocks)
for block in self._aio_blocks:
block.offset += len(block.buffer)
for idx, block in enumerate(self._aio_blocks):
block.buffer = (','.join(
map(str, self._generate_value_stream(message.data, idx))) +
'\n').encode()
await aio_context().submit(*self._aio_blocks)
for block in self._aio_blocks:
block.offset += len(block.buffer)
return message
async def on_init(self, context: Context) -> None:
benchmark = BaseBenchmark.of(context)
self._workspace = benchmark.bench_config.workspace / 'monitored' / 'resctrl'
privilege_cfg = PrivilegeConfig.of(context).result
with drop_privilege(privilege_cfg.user, privilege_cfg.group):
self._workspace.mkdir(parents=True, exist_ok=True)
async def on_init(self, context: Context) -> None:
benchmark = BaseBenchmark.of(context)
workspace: Path = benchmark.bench_config.workspace / 'monitored'
self._result_path = workspace / 'runtime.json'
privilege_cfg = PrivilegeConfig.of(context).result
with drop_privilege(privilege_cfg.user, privilege_cfg.group):
if self._result_path.is_file():
self._result_path.unlink()
elif self._result_path.is_dir():
self._result_path.rmdir()
self._result_path.parent.mkdir(exist_ok=True, parents=True)
self._result_path.write_text('{}')
async def on_init(self, context: Context) -> None:
benchmark = BaseBenchmark.of(context)
workspace = benchmark.bench_config.workspace / 'monitored' / 'perf'
privilege_cfg = PrivilegeConfig.of(context).result
with drop_privilege(privilege_cfg.user, privilege_cfg.group):
workspace.mkdir(parents=True, exist_ok=True)
# TODO: compare between open and aiofile_linux.
# (maybe open() is better when writing small amount of contents to a file at a time)
self._dest_file = (workspace / f'{benchmark.identifier}.csv').open(mode='w')
# FIXME: None check
perf_monitor = PerfMonitor.of(context)
self._event_order = tuple(perf_monitor.config.event_names)
self._dest_file.write(','.join(self._event_order) + '\n')
async def on_start(self, context: Context) -> None:
connection: aio_pika.Connection = await aio_pika.connect_robust(
host=self._host)
async with connection:
channel: aio_pika.Channel = await connection.channel()
await channel.declare_queue(self._creation_q_name)
benchmark = BaseBenchmark.of(context)
bench_config = benchmark.bench_config
await channel.default_exchange.publish(aio_pika.Message(
f'{benchmark.identifier},{bench_config.type},{benchmark.pid}'.
encode()),
routing_key=self.
_creation_q_name)
async def on_message(
self, context: Context,
message: PerBenchMessage[_MT]) -> Optional[PerBenchMessage[_MT]]:
if not isinstance(message, PerBenchMessage) or not isinstance(
message.source, RuntimeMonitor):
return message
privilege_cfg = PrivilegeConfig.of(context).result
with drop_privilege(privilege_cfg.user, privilege_cfg.group):
with self._result_path.open(mode='r+') as fp:
content: Dict[str, float] = json.load(fp)
content[BaseBenchmark.of(context).identifier] = message.data
fp.seek(0)
fp.truncate()
fp.write(json.dumps(content))
return message