# Copyright 2015 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

from telemetry.util import statistics
from telemetry.value import improvement_direction
from telemetry.value import scalar
from telemetry.web_perf.metrics import timeline_based_metric

import logging

class V8EventStat(object):

  def __init__(self, src_event_name, result_name, result_description):
    self.src_event_name = src_event_name
    self.result_name = result_name
    self.result_description = result_description
    self.thread_duration = 0.0
    self.thread_duration_inside_idle = 0.0
    self.idle_task_overrun_duration = 0.0
    self.max_thread_duration = 0.0
    self.count = 0

  @property
  def thread_duration_outside_idle(self):
    return self.thread_duration - self.thread_duration_inside_idle

  @property
  def percentage_thread_duration_during_idle(self):
    return statistics.DivideIfPossibleOrZero(
        100 * self.thread_duration_inside_idle, self.thread_duration)

class V8GCLatency(timeline_based_metric.TimelineBasedMetric):
  _RENDERER_MAIN_THREAD = 'CrRendererMain'
  _IDLE_TASK_PARENT = 'SingleThreadIdleTaskRunner::RunTask'

  def __init__(self):
    super(V8GCLatency, self).__init__()

  def AddResults(self, model, renderer_thread, interaction_records, results):
    self.VerifyNonOverlappedRecords(interaction_records)
    self._AddV8MetricsToResults(model, interaction_records, results)

  def _AddV8MetricsToResults(self, model,
                             interaction_records, results):
    self._AddV8EventStatsToResults(model, interaction_records, results)

  def _AddV8EventStatsToResults(self, model, interactions, results):
    v8_event_stats = [
        V8EventStat('V8.GCIncrementalMarking',
                    'v8_gc_incremental_marking',
                    'incremental marking steps'),
        V8EventStat('V8.GCScavenger',
                    'v8_gc_scavenger',
                    'scavenges'),
        V8EventStat('V8.GCCompactor',
                    'v8_gc_mark_compactor',
                    'mark-sweep-compactor'),
        V8EventStat('V8.GCFinalizeMC',
                    'v8_gc_finalize_incremental',
                    'finalization of incremental marking'),
        V8EventStat('V8.GCFinalizeMCReduceMemory',
                    'v8_gc_finalize_incremental_reduce_memory',
                    'finalization of incremental marking with memory reducer')]
    label = interactions[0].label
    name_to_v8_stat = {x.src_event_name : x for x in v8_event_stats}
    thread_time_not_available = False
    for event in model.IterAllSlices():
      if (not timeline_based_metric.IsEventInInteractions(event, interactions)
          or not event.name in name_to_v8_stat):
        continue
      event_stat = name_to_v8_stat[event.name]
      if event.thread_duration is None:
        thread_time_not_available = True
        event_duration = event.duration
      else:
        event_duration = event.thread_duration
      event_stat.thread_duration += event_duration
      event_stat.max_thread_duration = max(event_stat.max_thread_duration,
                                           event_duration)
      event_stat.count += 1

      parent_idle_task = self._ParentIdleTask(event)
      if parent_idle_task:
        allotted_idle_time = parent_idle_task.args['allotted_time_ms']
        idle_task_wall_overrun = 0
        if event.duration > allotted_idle_time:
          idle_task_wall_overrun = event.duration - allotted_idle_time
        # Don't count time over the deadline as being inside idle time.
        # Since the deadline should be relative to wall clock we compare
        # allotted_time_ms with wall duration instead of thread duration, and
        # then assume the thread duration was inside idle for the same
        # percentage of time.
        inside_idle = event_duration * statistics.DivideIfPossibleOrZero(
            event.duration - idle_task_wall_overrun, event.duration)
        event_stat.thread_duration_inside_idle += inside_idle
        event_stat.idle_task_overrun_duration += idle_task_wall_overrun

    if thread_time_not_available:
      logging.warning(
          'thread time is not available in trace data, switch to walltime')

    for v8_event_stat in v8_event_stats:
      results.AddValue(scalar.ScalarValue(
          results.current_page, v8_event_stat.result_name, 'ms',
          v8_event_stat.thread_duration,
          description=('Total thread duration spent in %s' %
                       v8_event_stat.result_description),
          tir_label=label,
          improvement_direction=improvement_direction.DOWN))
      results.AddValue(scalar.ScalarValue(
          results.current_page, '%s_max' % v8_event_stat.result_name, 'ms',
          v8_event_stat.max_thread_duration,
          description=('Max thread duration spent in %s' %
                       v8_event_stat.result_description),
          tir_label=label))
      results.AddValue(scalar.ScalarValue(
          results.current_page, '%s_count' % v8_event_stat.result_name, 'count',
          v8_event_stat.count,
          description=('Number of %s' %
                       v8_event_stat.result_description),
          tir_label=label,
          improvement_direction=improvement_direction.DOWN))
      average_thread_duration = statistics.DivideIfPossibleOrZero(
          v8_event_stat.thread_duration, v8_event_stat.count)
      results.AddValue(scalar.ScalarValue(
          results.current_page, '%s_average' % v8_event_stat.result_name, 'ms',
          average_thread_duration,
          description=('Average thread duration spent in %s' %
                       v8_event_stat.result_description),
          tir_label=label,
          improvement_direction=improvement_direction.DOWN))
      results.AddValue(scalar.ScalarValue(results.current_page,
          '%s_outside_idle' % v8_event_stat.result_name, 'ms',
          v8_event_stat.thread_duration_outside_idle,
          description=(
              'Total thread duration spent in %s outside of idle tasks' %
              v8_event_stat.result_description),
          tir_label=label))
      results.AddValue(scalar.ScalarValue(results.current_page,
          '%s_idle_deadline_overrun' % v8_event_stat.result_name, 'ms',
          v8_event_stat.idle_task_overrun_duration,
          description=('Total idle task deadline overrun for %s idle tasks'
                       % v8_event_stat.result_description),
          tir_label=label,
          improvement_direction=improvement_direction.DOWN))
      results.AddValue(scalar.ScalarValue(results.current_page,
          '%s_percentage_idle' % v8_event_stat.result_name, 'idle%',
          v8_event_stat.percentage_thread_duration_during_idle,
          description=('Percentage of %s spent in idle time' %
                       v8_event_stat.result_description),
          tir_label=label,
          improvement_direction=improvement_direction.UP))

    # Add total metrics.
    gc_total = sum(x.thread_duration for x in v8_event_stats)
    gc_total_outside_idle = sum(
        x.thread_duration_outside_idle for x in v8_event_stats)
    gc_total_idle_deadline_overrun = sum(
        x.idle_task_overrun_duration for x in v8_event_stats)
    gc_total_percentage_idle = statistics.DivideIfPossibleOrZero(
        100 * (gc_total - gc_total_outside_idle), gc_total)

    results.AddValue(scalar.ScalarValue(results.current_page,
        'v8_gc_total', 'ms', gc_total,
        description='Total thread duration of all garbage collection events',
          tir_label=label,
          improvement_direction=improvement_direction.DOWN))
    results.AddValue(scalar.ScalarValue(results.current_page,
        'v8_gc_total_outside_idle', 'ms', gc_total_outside_idle,
        description=(
            'Total thread duration of all garbage collection events outside of '
            'idle tasks'),
          tir_label=label,
          improvement_direction=improvement_direction.DOWN))
    results.AddValue(scalar.ScalarValue(results.current_page,
        'v8_gc_total_idle_deadline_overrun', 'ms',
        gc_total_idle_deadline_overrun,
        description=(
            'Total idle task deadline overrun for all idle tasks garbage '
            'collection events'),
          tir_label=label,
          improvement_direction=improvement_direction.DOWN))
    results.AddValue(scalar.ScalarValue(results.current_page,
        'v8_gc_total_percentage_idle', 'idle%', gc_total_percentage_idle,
        description=(
            'Percentage of the thread duration of all garbage collection '
            'events spent inside of idle tasks'),
          tir_label=label,
          improvement_direction=improvement_direction.UP))

  def _ParentIdleTask(self, event):
    parent = event.parent_slice
    while parent:
      if parent.name == self._IDLE_TASK_PARENT:
        return parent
      parent = parent.parent_slice
    return None