def test_metrics_is_ok_when_cpu_freq_returns_none(self): # Some psutil functions, such as cpu_freq(), can return None depending on # the environment; make sure we don't crash when that occurs. with mock.patch.object(resources.psutil, 'cpu_freq', return_value=None): with resources.ResourceMonitor() as monitor: self.assertEqual(monitor.metrics().cpu_frequency_mhz, 0)
def test_metrics_is_ok_when_cpu_freq_throws(self): # psutil.cpu_freq() can throw NotImplementedError in certain environments; # make sure we don't crash when that occurs. with mock.patch.object( resources.psutil, 'cpu_freq', side_effect=NotImplementedError): with resources.ResourceMonitor() as monitor: self.assertEqual(monitor.metrics().cpu_frequency_mhz, 0)
def test_metrics_is_ok_if_rusage_fails(self): # Some psutil functions, such as cpu_freq(), can return None depending on # the environment; make sure we don't crash when that occurs. with mock.patch.object( resources.resource, 'getrusage', side_effect=resource.error): with resources.ResourceMonitor() as monitor: self.assertEqual(monitor.metrics().cpu_user_time_seconds, 0) self.assertEqual(monitor.metrics().cpu_system_time_seconds, 0) self.assertEqual(monitor.metrics().memory_peak_rss_mb, 0)
def make_examples_runner(options): """Runs examples creation stage of deepvariant.""" resource_monitor = resources.ResourceMonitor().start() logging.info('Preparing inputs') regions = processing_regions_from_options(options) # Create a processor to create candidates and examples for each region. region_processor = RegionProcessor(options) logging.info('Writing examples to %s', options.examples_filename) if options.candidates_filename: logging.info('Writing candidates to %s', options.candidates_filename) if options.gvcf_filename: logging.info('Writing gvcf records to %s', options.gvcf_filename) n_regions, n_candidates, n_examples = 0, 0, 0 with OutputsWriter(options) as writer: for region in regions: candidates, examples, gvcfs = region_processor.process(region) n_candidates += len(candidates) n_examples += len(examples) n_regions += 1 writer.write_candidates(*candidates) # If we have any gvcf records, write them out. This if also serves to # protect us from trying to write to the gvcfs output of writer when gvcf # generation is turned off. In that case, gvcfs will always be empty and # we'll never execute the write. if gvcfs: writer.write_gvcfs(*gvcfs) writer.write_examples(*examples) # Construct and then write out our MakeExamplesRunInfo proto. if options.run_info_filename: run_info = deepvariant_pb2.MakeExamplesRunInfo( options=options, resource_metrics=resource_monitor.metrics()) if in_training_mode(options): if region_processor.labeler.metrics is not None: run_info.labeling_metrics.CopyFrom( region_processor.labeler.metrics) else: logging.warning( 'Labeling metrics requested but the selected labeling ' 'algorithm %s does not collect metrics; skipping.', options.labeler_algorithm) logging.info('Writing MakeExamplesRunInfo to %s', options.run_info_filename) write_make_examples_run_info(run_info, path=options.run_info_filename) logging.info('Found %s candidate variants', n_candidates) logging.info('Created %s examples', n_examples)
def test_monitor_gets_expected_metric_values(self): patchers = [ mock.patch.object(resources, '_get_host_name', return_value='hostname'), mock.patch.object(resources, '_get_cpu_count', return_value=3), mock.patch.object(resources, '_get_cpu_frequency', return_value=2312.4), mock.patch.object(resources, '_get_total_memory', return_value=1234), mock.patch.object( resources.resource, 'getrusage', return_value=mock.Mock( ru_utime=1.0, ru_stime=2.0, ru_maxrss=3 * 1024 # 3 Megabytes )), ] process_mock = mock.Mock() process_mock.io_counters.return_value = mock.Mock(read_bytes=12, write_bytes=34) patchers.append( mock.patch.object(resources.psutil, 'Process', return_value=process_mock)) with contextlib.nested(*patchers): with resources.ResourceMonitor() as monitor: metrics = monitor.metrics() # Environment metrics; all mocked out. self.assertEqual(metrics.host_name, 'hostname') self.assertEqual(metrics.physical_core_count, 3) self.assertEqual(metrics.cpu_frequency_mhz, 2312.4) self.assertEqual(metrics.total_memory_mb, 1234) # Runtime metrics; they are all mocked out. self.assertEqual(metrics.cpu_user_time_seconds, 1.0) self.assertEqual(metrics.cpu_system_time_seconds, 2.0) self.assertEqual(metrics.memory_peak_rss_mb, 3) self.assertEqual(metrics.read_bytes, 12) self.assertEqual(metrics.write_bytes, 34)
def test_monitor_real_function_calls(self): # We want to actually make all of the real function calls under test, but # we of course don't know their values and can only do sanity checks. with resources.ResourceMonitor() as monitor: metrics = monitor.metrics() self.assertGreater(len(metrics.host_name), 0) self.assertGreater(metrics.physical_core_count, 0) self.assertGreater(metrics.total_memory_mb, 0) self.assertGreater(metrics.cpu_user_time_seconds, 0) self.assertGreater(metrics.cpu_system_time_seconds, 0) self.assertGreater(metrics.memory_peak_rss_mb, 0) # We unfortunately cannot make sure that read_bytes and write_bytes is # greater than zero, so these tests are commented out. # self.assertGreater(metrics.read_bytes, 0) # self.assertGreater(metrics.write_bytes, 0) # CPU frequency may not be available on all systems, so the value is # either a real frequency (> 0) or the magic value of 0.0 indicating that # the value could not be determined. self.assertGreaterEqual(metrics.cpu_frequency_mhz, 0.0)
def test_metrics_without_start_raises_exception(self): monitor = resources.ResourceMonitor() with self.assertRaises(RuntimeError): monitor.metrics()
def test_start_returns_self(self): monitor = resources.ResourceMonitor() self.assertIs(monitor.start(), monitor)