| #!/usr/bin/python2 |
| """Records stats on an event injected by a benchmark test.""" |
| |
| from __future__ import absolute_import |
| from __future__ import division |
| from __future__ import print_function |
| |
| import c_val_names |
| import tv_testcase_util |
| |
| |
| class EventRecorderOptions(object): |
| """Contains all of the parameters needed by EventRecorder.""" |
| |
| def __init__(self, test, event_name, event_type): |
| """Initializes the event recorder options. |
| |
| Args: |
| test: specific benchmark test being run |
| event_name: name of the event being recorded |
| event_type: type of event being recorded (tv_testcase_util.py) |
| """ |
| self.test = test |
| self.event_name = event_name |
| self.event_type = event_type |
| |
| self.record_animations = True |
| self.record_video = False |
| |
| |
| class EventRecorder(object): |
| """Records stats on an event injected by a benchmark test. |
| |
| Handles collecting event data over all of the instances of a specific event |
| injected by a benchmark test and records statistics on the data when the test |
| ends. The specific event types that can be injected are listed within |
| tv_testcase_util.py. |
| |
| Both rasterize animations and video start delay data can potentially be |
| recorded, depending on the |record_animations| and |record_video| option |
| flags. |
| """ |
| |
| def __init__(self, options): |
| """Initializes the event recorder. |
| |
| Handles setting up this event recorder, including creating all of its |
| recorders, based upon the passed in options. |
| |
| Args: |
| options: the settings to use in creating this event recorder |
| """ |
| self.test = options.test |
| self.event_name = options.event_name |
| self.event_type = options.event_type |
| |
| self.render_tree_failure_count = 0 |
| |
| # Each entry in the list contains a tuple with a key and value recorder. |
| self.value_dictionary_recorders = [] |
| |
| # Optional animations recorders |
| self.animations_recorder = None |
| self.animations_start_delay_recorder = None |
| self.animations_end_delay_recorder = None |
| |
| # Optional video recorders |
| self.video_delay_recorder = None |
| |
| # Count record strategies |
| count_record_strategies = [] |
| count_record_strategies.append(tv_testcase_util.RecordStrategyMean()) |
| count_record_strategies.append(tv_testcase_util.RecordStrategyMedian()) |
| count_record_strategies.append(tv_testcase_util.RecordStrategyMax()) |
| |
| # Duration record strategies |
| duration_record_strategies = [] |
| duration_record_strategies.append(tv_testcase_util.RecordStrategyMean()) |
| duration_record_strategies.append( |
| tv_testcase_util.RecordStrategyPercentile(25)) |
| duration_record_strategies.append( |
| tv_testcase_util.RecordStrategyPercentile(50)) |
| duration_record_strategies.append( |
| tv_testcase_util.RecordStrategyPercentile(75)) |
| duration_record_strategies.append( |
| tv_testcase_util.RecordStrategyPercentile(95)) |
| |
| # Video delay record strategies |
| video_delay_record_strategies = [] |
| video_delay_record_strategies.append(tv_testcase_util.RecordStrategyMean()) |
| video_delay_record_strategies.append(tv_testcase_util.RecordStrategyMin()) |
| video_delay_record_strategies.append( |
| tv_testcase_util.RecordStrategyPercentile(25)) |
| video_delay_record_strategies.append( |
| tv_testcase_util.RecordStrategyPercentile(50)) |
| video_delay_record_strategies.append( |
| tv_testcase_util.RecordStrategyPercentile(75)) |
| video_delay_record_strategies.append( |
| tv_testcase_util.RecordStrategyPercentile(95)) |
| video_delay_record_strategies.append(tv_testcase_util.RecordStrategyMax()) |
| video_delay_record_strategies.append( |
| tv_testcase_util.RecordStrategyStandardDeviation()) |
| |
| # Dictionary count recorders |
| self._add_value_dictionary_recorder("CntDomEventListeners", |
| count_record_strategies) |
| self._add_value_dictionary_recorder("CntDomNodes", count_record_strategies) |
| self._add_value_dictionary_recorder("CntDomHtmlElements", |
| count_record_strategies) |
| self._add_value_dictionary_recorder("CntDomDocumentHtmlElements", |
| count_record_strategies) |
| self._add_value_dictionary_recorder("CntDomHtmlElementsCreated", |
| count_record_strategies) |
| self._add_value_dictionary_recorder("CntDomUpdateMatchingRules", |
| count_record_strategies) |
| self._add_value_dictionary_recorder("CntDomUpdateComputedStyle", |
| count_record_strategies) |
| self._add_value_dictionary_recorder("CntDomGenerateHtmlComputedStyle", |
| count_record_strategies) |
| self._add_value_dictionary_recorder("CntDomGeneratePseudoComputedStyle", |
| count_record_strategies) |
| self._add_value_dictionary_recorder("CntLayoutBoxes", |
| count_record_strategies) |
| self._add_value_dictionary_recorder("CntLayoutBoxesCreated", |
| count_record_strategies) |
| self._add_value_dictionary_recorder("CntLayoutUpdateSize", |
| count_record_strategies) |
| self._add_value_dictionary_recorder("CntLayoutRenderAndAnimate", |
| count_record_strategies) |
| self._add_value_dictionary_recorder("CntLayoutUpdateCrossReferences", |
| count_record_strategies) |
| |
| # Dictionary duration recorders |
| self._add_value_dictionary_recorder("DurTotalUs", |
| duration_record_strategies) |
| self._add_value_dictionary_recorder("DurDomInjectEventUs", |
| duration_record_strategies) |
| self._add_value_dictionary_recorder("DurDomRunAnimationFrameCallbacksUs", |
| duration_record_strategies) |
| self._add_value_dictionary_recorder("DurDomUpdateComputedStyleUs", |
| duration_record_strategies) |
| self._add_value_dictionary_recorder("DurLayoutBoxTreeUs", |
| duration_record_strategies) |
| self._add_value_dictionary_recorder("DurLayoutBoxTreeBoxGenerationUs", |
| duration_record_strategies) |
| self._add_value_dictionary_recorder("DurLayoutBoxTreeUpdateUsedSizesUs", |
| duration_record_strategies) |
| self._add_value_dictionary_recorder("DurLayoutRenderAndAnimateUs", |
| duration_record_strategies) |
| |
| self.count_render_trees_recorder = tv_testcase_util.ResultsRecorder( |
| self.event_name + "CntRenderTrees", count_record_strategies) |
| self.count_requested_images_recorder = tv_testcase_util.ResultsRecorder( |
| self.event_name + "CntRequestedImages", count_record_strategies) |
| |
| # Optional animations recorder |
| if options.record_animations: |
| self.animations_recorder = tv_testcase_util.ResultsRecorder( |
| self.event_name + "DurRasterizeAnimationsUs", |
| duration_record_strategies) |
| self.animations_start_delay_recorder = tv_testcase_util.ResultsRecorder( |
| self.event_name + "DurAnimationsStartDelayUs", |
| duration_record_strategies) |
| self.animations_end_delay_recorder = tv_testcase_util.ResultsRecorder( |
| self.event_name + "DurAnimationsEndDelayUs", |
| duration_record_strategies) |
| |
| self.final_render_tree_delay_recorder = tv_testcase_util.ResultsRecorder( |
| self.event_name + "DurFinalRenderTreeDelayUs", |
| duration_record_strategies) |
| |
| # Optional video recorder |
| if options.record_video: |
| self.video_delay_recorder = tv_testcase_util.ResultsRecorder( |
| self.event_name + "DurVideoStartDelayUs", |
| video_delay_record_strategies) |
| |
| def _add_value_dictionary_recorder(self, key, record_strategies): |
| recorder = tv_testcase_util.ResultsRecorder(self.event_name + key, |
| record_strategies) |
| self.value_dictionary_recorders.append((key, recorder)) |
| |
| def on_start_event(self): |
| """Handles logic related to the start of the event instance.""" |
| self.count_render_trees_start = self.test.get_cval( |
| c_val_names.count_rasterize_new_render_tree()) |
| self.count_requested_images_start = self.test.get_cval( |
| c_val_names.count_image_cache_requested_resources()) |
| |
| def on_end_event(self): |
| """Handles logic related to the end of the event instance.""" |
| |
| value_dictionary = self.test.get_cval( |
| c_val_names.event_value_dictionary(self.event_type)) |
| |
| # If the event failed to produce a render tree, then its data is not |
| # collected. Log the failure and return. |
| if not value_dictionary or not value_dictionary.get("ProducedRenderTree"): |
| self.render_tree_failure_count += 1 |
| print("{} event failed to produce render tree! {} events failed.".format( |
| self.event_name, self.render_tree_failure_count)) |
| return |
| |
| event_start_time = value_dictionary.get("StartTime") |
| |
| # Record all of the values from the event. |
| for value_dictionary_recorder in self.value_dictionary_recorders: |
| value = value_dictionary.get(value_dictionary_recorder[0]) |
| if value is not None: |
| value_dictionary_recorder[1].collect_value(value) |
| |
| self.count_render_trees_end = self.test.get_cval( |
| c_val_names.count_rasterize_new_render_tree()) |
| self.count_render_trees_recorder.collect_value( |
| self.count_render_trees_end - self.count_render_trees_start) |
| |
| self.count_requested_images_end = self.test.get_cval( |
| c_val_names.count_image_cache_requested_resources()) |
| self.count_requested_images_recorder.collect_value( |
| self.count_requested_images_end - self.count_requested_images_start) |
| |
| if self.animations_recorder: |
| animation_entries = self.test.get_cval( |
| c_val_names.rasterize_animations_entry_list()) |
| for value in animation_entries: |
| self.animations_recorder.collect_value(value) |
| |
| animations_start_time = self.test.get_cval( |
| c_val_names.time_rasterize_animations_start()) |
| self.animations_start_delay_recorder.collect_value( |
| animations_start_time - event_start_time) |
| animations_end_time = self.test.get_cval( |
| c_val_names.time_rasterize_animations_end()) |
| self.animations_end_delay_recorder.collect_value(animations_end_time - |
| event_start_time) |
| |
| final_render_tree_time = self.test.get_cval( |
| c_val_names.time_rasterize_new_render_tree()) |
| self.final_render_tree_delay_recorder.collect_value(final_render_tree_time - |
| event_start_time) |
| |
| if self.video_delay_recorder: |
| self.video_delay_recorder.collect_value( |
| self.test.get_cval( |
| c_val_names.event_duration_dom_video_start_delay())) |
| |
| def on_end_test(self): |
| """Handles logic related to the end of the test.""" |
| |
| for value_dictionary_recorder in self.value_dictionary_recorders: |
| value_dictionary_recorder[1].on_end_test() |
| |
| self.count_render_trees_recorder.on_end_test() |
| self.count_requested_images_recorder.on_end_test() |
| |
| if self.animations_recorder: |
| self.animations_recorder.on_end_test() |
| self.animations_start_delay_recorder.on_end_test() |
| self.animations_end_delay_recorder.on_end_test() |
| |
| self.final_render_tree_delay_recorder.on_end_test() |
| |
| if self.video_delay_recorder: |
| self.video_delay_recorder.on_end_test() |
