devlib/derived/fps.py

from __future__ import division
import csv
import os
import re

try:
    import pandas as pd
except ImportError:
    pd = None

from devlib import DerivedMeasurements, DerivedMetric, MeasurementsCsv, InstrumentChannel
from devlib.exception import HostError
from devlib.utils.rendering import gfxinfo_get_last_dump, VSYNC_INTERVAL
from devlib.utils.types import numeric


class DerivedFpsStats(DerivedMeasurements):

    def __init__(self, drop_threshold=5, suffix=None, filename=None, outdir=None):
        self.drop_threshold = drop_threshold
        self.suffix = suffix
        self.filename = filename
        self.outdir = outdir
        if (filename is None) and (suffix is None):
            self.suffix = '-fps'
        elif (filename is not None) and (suffix is not None):
            raise ValueError('suffix and filename cannot be specified at the same time.')
        if filename is not None and os.sep in filename:
            raise ValueError('filename cannot be a path (cannot countain "{}"'.format(os.sep))

    def process(self, measurements_csv):
        if isinstance(measurements_csv, basestring):
            measurements_csv = MeasurementsCsv(measurements_csv)
        if pd is not None:
            return self._process_with_pandas(measurements_csv)
        return self._process_without_pandas(measurements_csv)

    def _get_csv_file_name(self, frames_file):
        outdir = self.outdir or os.path.dirname(frames_file)
        if self.filename:
            return os.path.join(outdir, self.filename)

        frames_basename = os.path.basename(frames_file)
        rest, ext = os.path.splitext(frames_basename)
        csv_basename = rest + self.suffix + ext
        return os.path.join(outdir, csv_basename)


class DerivedGfxInfoStats(DerivedFpsStats):

    @staticmethod
    def process_raw(filepath, *args):
        metrics = []
        dump = gfxinfo_get_last_dump(filepath)
        seen_stats = False
        for line in dump.split('\n'):
            if seen_stats and not line.strip():
                break
            elif line.startswith('Janky frames:'):
                text = line.split(': ')[-1]
                val_text, pc_text = text.split('(')
                metrics.append(DerivedMetric('janks', numeric(val_text.strip()), 'count'))
                metrics.append(DerivedMetric('janks_pc', numeric(pc_text[:-3]), 'percent'))
            elif ' percentile: ' in line:
                ptile, val_text = line.split(' percentile: ')
                name = 'render_time_{}_ptile'.format(ptile)
                value = numeric(val_text.strip()[:-2])
                metrics.append(DerivedMetric(name, value, 'time_ms'))
            elif line.startswith('Number '):
                name_text, val_text = line.strip().split(': ')
                name = name_text[7:].lower().replace(' ', '_')
                value = numeric(val_text)
                metrics.append(DerivedMetric(name, value, 'count'))
            else:
                continue
            seen_stats = True
        return metrics

    def _process_without_pandas(self, measurements_csv):
        per_frame_fps = []
        start_vsync, end_vsync = None, None
        frame_count = 0

        for frame_data in measurements_csv.iter_values():
            if frame_data.Flags_flags != 0:
                continue
            frame_count += 1

            if start_vsync is None:
                start_vsync = frame_data.Vsync_time_us
            end_vsync = frame_data.Vsync_time_us

            frame_time = frame_data.FrameCompleted_time_us - frame_data.IntendedVsync_time_us
            pff = 1e9 / frame_time
            if pff > self.drop_threshold:
                per_frame_fps.append([pff])

        if frame_count:
            duration = end_vsync - start_vsync
            fps = (1e9 * frame_count) / float(duration)
        else:
            duration = 0
            fps = 0

        csv_file = self._get_csv_file_name(measurements_csv.path)
        with open(csv_file, 'wb') as wfh:
            writer = csv.writer(wfh)
            writer.writerow(['fps'])
            writer.writerows(per_frame_fps)

        return [DerivedMetric('fps', fps, 'fps'),
                DerivedMetric('total_frames', frame_count, 'frames'),
                MeasurementsCsv(csv_file)]

    def _process_with_pandas(self, measurements_csv):
        data = pd.read_csv(measurements_csv.path)
        data = data[data.Flags_flags == 0]
        frame_time = data.FrameCompleted_time_us - data.IntendedVsync_time_us
        per_frame_fps = (1e9 / frame_time)
        keep_filter = per_frame_fps > self.drop_threshold
        per_frame_fps = per_frame_fps[keep_filter]
        per_frame_fps.name = 'fps'

        frame_count = data.index.size
        if frame_count > 1:
            duration = data.Vsync_time_us.iloc[-1] - data.Vsync_time_us.iloc[0]
            fps = (1e9 * frame_count) / float(duration)
        else:
            duration = 0
            fps = 0

        csv_file = self._get_csv_file_name(measurements_csv.path)
        per_frame_fps.to_csv(csv_file, index=False, header=True)

        return [DerivedMetric('fps', fps, 'fps'),
                DerivedMetric('total_frames', frame_count, 'frames'),
                MeasurementsCsv(csv_file)]


class DerivedSurfaceFlingerStats(DerivedFpsStats):

    def _process_with_pandas(self, measurements_csv):
        data = pd.read_csv(measurements_csv.path)

        # fiter out bogus frames.
        bogus_frames_filter = data.actual_present_time_us != 0x7fffffffffffffff
        actual_present_times = data.actual_present_time_us[bogus_frames_filter]
        actual_present_time_deltas = actual_present_times.diff().dropna()

        vsyncs_to_compose = actual_present_time_deltas.div(VSYNC_INTERVAL)
        vsyncs_to_compose.apply(lambda x: int(round(x, 0)))

        # drop values lower than drop_threshold FPS as real in-game frame
        # rate is unlikely to drop below that (except on loading screens
        # etc, which should not be factored in frame rate calculation).
        per_frame_fps = (1.0 / (vsyncs_to_compose.multiply(VSYNC_INTERVAL / 1e9)))
        keep_filter = per_frame_fps > self.drop_threshold
        filtered_vsyncs_to_compose = vsyncs_to_compose[keep_filter]
        per_frame_fps.name = 'fps'

        csv_file = self._get_csv_file_name(measurements_csv.path)
        per_frame_fps.to_csv(csv_file, index=False, header=True)

        if not filtered_vsyncs_to_compose.empty:
            fps = 0
            total_vsyncs = filtered_vsyncs_to_compose.sum()
            frame_count = filtered_vsyncs_to_compose.size

            if total_vsyncs:
                fps = 1e9 * frame_count / (VSYNC_INTERVAL * total_vsyncs)

            janks = self._calc_janks(filtered_vsyncs_to_compose)
            not_at_vsync = self._calc_not_at_vsync(vsyncs_to_compose)
        else:
            fps = 0
            frame_count = 0
            janks = 0
            not_at_vsync = 0

        return [DerivedMetric('fps', fps, 'fps'),
                DerivedMetric('total_frames', frame_count, 'frames'),
                MeasurementsCsv(csv_file),
                DerivedMetric('janks', janks, 'count'),
                DerivedMetric('janks_pc', janks * 100 / frame_count, 'percent'),
                DerivedMetric('missed_vsync', not_at_vsync, 'count')]

    def _process_without_pandas(self, measurements_csv):
        # Given that SurfaceFlinger has been deprecated in favor of GfxInfo,
        # it does not seem worth it implementing this.
        raise HostError('Please install "pandas" Python package to process SurfaceFlinger frames')

    @staticmethod
    def _calc_janks(filtered_vsyncs_to_compose):
        """
        Internal method for calculating jank frames.
        """
        pause_latency = 20
        vtc_deltas = filtered_vsyncs_to_compose.diff().dropna()
        vtc_deltas = vtc_deltas.abs()
        janks = vtc_deltas.apply(lambda x: (pause_latency > x > 1.5) and 1 or 0).sum()

        return janks

    @staticmethod
    def _calc_not_at_vsync(vsyncs_to_compose):
        """
        Internal method for calculating the number of frames that did not
        render in a single vsync cycle.
        """
        epsilon = 0.0001
        func = lambda x: (abs(x - 1.0) > epsilon) and 1 or 0
        not_at_vsync = vsyncs_to_compose.apply(func).sum()

        return not_at_vsync