path: root/obbenchlib/htmlgen.py

# Copyright 2015  Lars Wirzenius
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
#
# =*= License: GPL-3+ =*=


import glob
import os

import jinja2
import markdown
import yaml

import obbenchlib


class HtmlGenerator(object):

    def __init__(self):
        self.statedir = None
        self.resultdir = None
        self.spec = None

    def generate_html(self):
        env = jinja2.Environment(
            loader=jinja2.PackageLoader('obbenchlib'),
            autoescape=lambda foo: True,
            extensions=['jinja2.ext.autoescape'])

        self.create_html_dir()
        page_classes = [
            FrontPage,
            BenchmarkPage,
            ProfileData,
            LogFile,
            CssFile,
        ]
        pages = [page_class() for page_class in page_classes]
        for page in pages:
            page.env = env
            page.spec = self.spec

        for result in self.load_results():
            for page in pages:
                for filename, data in page.collect(result):
                    self.write_file(filename, data)

        for page in pages:
            for filename, data in page.generate():
                self.write_file(filename, data)

    @property
    def htmldir(self):
        return os.path.join(self.statedir, 'html')

    def create_html_dir(self):
        if not os.path.exists(self.htmldir):
            os.mkdir(self.htmldir)

    def load_results(self):
        filenames = list(glob.glob(os.path.join(self.resultdir, '*.yaml')))
        for i, filename in enumerate(filenames):
            print 'Loading', filename, i+1, 'of', len(filenames)
            with open(filename) as f:
                yield yaml.load(f, Loader=yaml.CSafeLoader)

    def write_file(self, relative_path, text):
        filename = os.path.join(self.htmldir, relative_path)
        with open(filename, 'w') as f:
            f.write(text)


class HtmlPage(object):

    def __init__(self):
        self.env = None
        self.results = []
        self.spec = None

    def collect(self, result):
        raise NotImplementedError()

    def format_markdown(self, text):
        return markdown.markdown(text)

    def get_step_names(self, benchmark):
        return [step['obnam'] for step in benchmark['steps']]

    def generate(self):
        raise NotImplementedError()

    def render(self, template_name, variables):
        template = self.env.get_template(template_name)
        return template.render(**variables)

    def deep_copy(self, item, copy):
        if isinstance(item, dict):
            return {
                key: self.deep_copy(value, copy)
                for key, value in item.items()
            }
        elif isinstance(item, list):
            return [
                self.deep_copy(value, copy)
                for value in item
            ]
        else:
            return copy(item)

    def copy(self, thing):
        if isinstance(thing, str) and len(thing) >= 1024:
            return None
        if hasattr(thing, 'copy'):
            return thing.copy()
        return thing


class FrontPage(HtmlPage):

    def collect(self, result):
        self.results.append(self.deep_copy(result, self.copy))
        return []

    def generate(self):
        variables = {
            'description': self.format_markdown(self.spec['description']),
            'benchmark_names': [
                benchmark['name']
                for benchmark in sorted(self.spec['benchmarks'])
            ],
            'results_table': self.results_table(),
            'spec': yaml.safe_dump(
                self.spec, indent=4, default_flow_style=False)
        }
        yield 'index.html', self.render('index.j2', variables)

    def results_table(self):
        table = {}
        for result in self.results:
            key = '{commit_timestamp} {commit_id} {run_timestamp}'.format(
                **result)
            if key not in table:
                table[key] = {
                    'commit_id': result['commit_id'],
                    'commit_date': result['commit_date'],
                }
            table[key][result['benchmark_name']] = self.duration(result)

        return [table[key] for key in sorted(table.keys())]

    def duration(self, result):
        total = 0
        for step in result['steps']:
            for key in step:
                if key != 'live':
                    total += step[key].get('duration', 0)
        return total


class BenchmarkPage(HtmlPage):

    def collect(self, result):
        self.results.append(self.deep_copy(result, self.copy))
        return []

    def generate(self):
        benchmark_names = [
            benchmark['name']
            for benchmark in self.spec['benchmarks']
        ]

        for benchmark_name in benchmark_names:
            yield self.generate_benchmark_page(benchmark_name)

    def generate_benchmark_page(self, benchmark_name):
        benchmark = self.find_benchmark(benchmark_name)
        table_rows = self.table_rows(benchmark)

        variables = {
            'benchmark_name': benchmark_name,
            'description': self.format_markdown(
                benchmark.get('description', '')),
            'table_rows': table_rows,
            'step_names': self.get_step_names(benchmark),
            'spec': yaml.safe_dump(
                benchmark, indent=4, default_flow_style=False)
        }

        return (
            '{}.html'.format(benchmark_name),
            self.render('benchmark.j2', variables)
        )

    def find_benchmark(self, benchmark_name):
        for benchmark in self.spec['benchmarks']:
            if benchmark['name'] == benchmark_name:
                return benchmark
        return {}

    def table_rows(self, benchmark):
        results = self.get_results_for_benchmark(benchmark)
        step_names = self.get_step_names(benchmark)
        rows = []
        for result in results:
            rows.append(self.table_row(result, step_names))
        return sorted(rows, key=lambda row: row['commit_timestamp'])

    def get_results_for_benchmark(self, benchmark):
        return [
            result
            for result in self.results
            if result['benchmark_name'] == benchmark['name']
        ]

    def table_row(self, result, step_names):
        row = {
            'result_id': result['result_id'],
            'commit_timestamp': result['commit_timestamp'],
            'commit_date': result['commit_date'],
            'commit_id': result['commit_id'],
            'total': 0,
            'vmrss_max': 0,
            'steps': [],
        }
        for i, step in enumerate(result['steps']):
            for step_name in step_names:
                if step_name in step:
                    vmrss = step[step_name].get('vmrss', 0) / 1024 / 1024
                    row['steps'].append({
                        'filename_txt': '{}_{}.txt'.format(
                            result['result_id'], i),
                        'filename_prof': '{}_{}.prof'.format(
                            result['result_id'], i),
                        'filename_log': '{}_{}.log'.format(
                            result['result_id'], i),
                        'duration': step[step_name]['duration'],
                        'vmrss': vmrss,
                    })
                    row['total'] += row['steps'][-1]['duration']
                    row['vmrss_max'] = max(row['vmrss_max'], vmrss)
                    break
        return row


class ProfileData(HtmlPage):

    def collect(self, result):
        for i, step in enumerate(result['steps']):
            for operation in step:
                if 'profile' in step[operation]:
                    yield self.generate_profile_data(
                        result, step, i, operation)
                    yield self.generate_profile_text(
                        result, step, i, operation)

    def generate_profile_data(self, result, step, i, operation):
        filename = '{}_{}.prof'.format(result['result_id'], i)
        return filename, step[operation]['profile']

    def generate_profile_text(self, result, step, i, operation):
        filename = '{}_{}.txt'.format(result['result_id'], i)
        return filename, step[operation]['profile-text']

    def generate(self):
        return []


class LogFile(HtmlPage):

    def collect(self, result):
        for i, step in enumerate(result['steps']):
            for operation in step:
                if 'log' in step[operation]:
                    yield self.generate_log_file(
                        result, step, i, operation)

    def generate_log_file(self, result, step, i, operation):
        filename = '{}_{}.log'.format(result['result_id'], i)
        return filename, step[operation]['log']

    def generate(self):
        return []


class CssFile(object):

    def collect(self, result):
        return []

    def generate(self):
        filename = os.path.join(
            os.path.dirname(obbenchlib.__file__), 'obbench.css')
        with open(filename) as f:
            data = f.read()
        yield 'obbench.css', data