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, ) )