async def test_class_creation_speed(self) -> None:
"""Test the speed of creating topic classes on the fly."""
async with salobj.Domain() as domain:
t0 = time.monotonic()
salinfo = salobj.SalInfo(domain, "Test", index=self.index)
topic_names = (
["logevent_" + name for name in salinfo.event_names]
+ ["command_" + name for name in salinfo.command_names]
+ list(salinfo.telemetry_names)
)
for topic_name in topic_names:
revname = salinfo.revnames.get(topic_name)
ddsutil.make_dds_topic_class(
parsed_idl=salinfo.parsed_idl, revname=revname
)
dt = time.monotonic() - t0
ntopics = len(topic_names)
creation_speed = ntopics / dt
print(
f"Created {creation_speed:0.1f} topic classes/sec ({ntopics} topic classes); "
f"total duration {dt:0.2f} seconds."
)
self.insert_measurement(
verify.Measurement(
"salobj.CreateClasses", creation_speed * u.ct / u.second
)
)
def do_measurement(self, data_dict):
self._unique_id = 'Full Focal Plane'
src_ct = 0
for data_id in self.data_request:
data = data_dict[data_id]
src_ct += len(data['coord_ra'])
ct_meas = lsst_verify.Measurement(
'dummy_ct_metric.SrcCt2',
src_ct * astropy_units.dimensionless_unscaled)
ra = np.zeros(src_ct, dtype=float)
dec = np.zeros(src_ct, dtype=float)
flux = np.zeros(src_ct, dtype=float)
flux_sigma = np.zeros(src_ct, dtype=float)
i_start = 0
for data_id in self.data_request:
data = data_dict[data_id]
local_ra = data['coord_ra']
local_dec = data['coord_dec']
local_flux = data['base_PsfFlux_flux']
local_sigma = data['base_PsfFlux_fluxSigma']
ra[i_start:i_start + len(local_ra)] = local_ra
dec[i_start:i_start + len(local_dec)] = local_dec
flux[i_start:i_start + len(local_flux)] = local_flux
flux_sigma[i_start:i_start + len(local_flux)] = local_sigma
i_start += len(local_ra)
ct_meas.extras['ra_rad'] = lsst_verify.Datum(
ra,
label='ra_rad',
description='RA of sources in radians',
unit=astropy_units.radian)
ct_meas.extras['dec_rad'] = lsst_verify.Datum(
dec,
label='dec_rad',
description='Dec of sources in radians',
unit=astropy_units.radian)
ct_meas.extras['flux'] = lsst_verify.Datum(flux, label='flux', unit='')
ct_meas.extras['flux_sigma'] = lsst_verify.Datum(flux_sigma,
label='flux_sigma',
unit='')
print('measured fp source count %d' % src_ct)
job = lsst_verify.Job.load_metrics_package()
job.metrics.update(self._metric_set)
job.specs.update(self._specs_set)
job.measurements.insert(ct_meas)
self._job = job
async def test_write_speed(self) -> None:
async with salobj.Controller(
name="Test", index=self.index, do_callbacks=False
) as controller:
num_samples = 1000
t0 = time.monotonic()
for i in range(num_samples):
await controller.tel_arrays.write()
dt = time.monotonic() - t0
arrays_write_speed = num_samples / dt
print(
f"Wrote {arrays_write_speed:0.0f} arrays samples/second ({num_samples} samples)"
)
self.insert_measurement(
verify.Measurement(
"salobj.WriteTest_arrays", arrays_write_speed * u.ct / u.second
)
)
t0 = time.monotonic()
for _ in range(num_samples):
await controller.evt_logLevel.write()
await asyncio.sleep(0)
dt = time.monotonic() - t0
log_level_write_speed = num_samples / dt
print(
f"Wrote {log_level_write_speed:0.0f} logLevel samples/second ({num_samples} samples)"
)
self.insert_measurement(
verify.Measurement(
"salobj.WriteTest_logLevel",
log_level_write_speed * u.ct / u.second,
)
)
def do_measurement(self, data_dict):
data = data_dict[self.data_request[0]]
src_ct = len(data['coord_ra'])
ct_meas = lsst_verify.Measurement(
'dummy_ct_metric.SrcCt2',
src_ct * astropy_units.dimensionless_unscaled)
data_dict = json.loads(self.data_request[0][1])
i_ccd = data_dict['ccd']
self._unique_id = 'CCD: %d' % i_ccd
print('measured %d source count %d' % (i_ccd, src_ct))
job = lsst_verify.Job.load_metrics_package()
job.metrics.update(self._metric_set)
job.specs.update(self._specs_set)
job.measurements.insert(ct_meas)
self._job = job
async def test_command_speed(self) -> None:
async with self.make_remote_and_topic_writer() as remote:
await remote.evt_summaryState.next(flush=False, timeout=60)
t0 = time.monotonic()
num_commands = 1000
for i in range(num_commands):
await remote.cmd_fault.start(timeout=STD_TIMEOUT)
dt = time.monotonic() - t0
command_speed = num_commands / dt
print(
f"Issued {command_speed:0.0f} fault commands/second ({num_commands} commands)"
)
self.insert_measurement(
verify.Measurement(
"salobj.IssueCommands", command_speed * u.ct / u.second
)
)
async def test_read_speed(self) -> None:
async with self.make_remote_and_topic_writer() as remote:
await salobj.set_summary_state(
remote=remote,
state=salobj.State.ENABLED,
override="arrays",
timeout=STD_TIMEOUT,
)
num_samples = 1000
# Wait for the first sample so we know the writer is running
# and to get an initial sequence number.
data0 = await remote.tel_arrays.next(flush=False, timeout=STD_TIMEOUT)
t0 = time.monotonic()
for i in range(num_samples):
data = await remote.tel_arrays.next(flush=False, timeout=STD_TIMEOUT)
dt = time.monotonic() - t0
arrays_read_speed = num_samples / dt
nlost = data.private_seqNum - data0.private_seqNum - num_samples
print(
f"Read {arrays_read_speed:0.0f} arrays samples/second "
f"({num_samples} samples); "
f"lost {nlost} samples once started; "
f"lost {data0.int0[0]} samples during startup"
)
self.insert_measurement(
verify.Measurement(
"salobj.ReadTest_arrays",
arrays_read_speed * u.ct / u.second,
)
)
await salobj.set_summary_state(
remote=remote, state=salobj.State.STANDBY, timeout=STD_TIMEOUT
)
await salobj.set_summary_state(
remote=remote,
state=salobj.State.ENABLED,
override="logLevel",
timeout=STD_TIMEOUT,
)
# Wait for the first logLevel sample. This is automatically
# output by the Controller and probably has level=20
# (unless data has been lost).
await remote.evt_logLevel.next(flush=False, timeout=STD_TIMEOUT)
# Wait for the next logLevel sample, which is the first one
# output by the write loop (unless data has been lost).
data0 = await remote.evt_logLevel.next(flush=False, timeout=STD_TIMEOUT)
t0 = time.monotonic()
for i in range(num_samples):
data = await remote.evt_logLevel.next(flush=False, timeout=STD_TIMEOUT)
dt = time.monotonic() - t0
log_level_read_speed = num_samples / dt
nlost = data.private_seqNum - data0.private_seqNum - num_samples
print(
f"Read {log_level_read_speed:0.0f} logLevel samples/second "
f"({num_samples} samples); "
f"lost {nlost} samples once started; "
f"lost {data0.level} samples during startup"
)
self.insert_measurement(
verify.Measurement(
"salobj.ReadTest_logLevel",
log_level_read_speed * u.ct / u.second,
)
)