opreport.cpp

Go to the documentation of this file.

#include <iostream>
#include <iomanip>
#include <vector>
#include <algorithm>
#include <sstream>
#include <numeric>

#include "op_exception.h"
#include "stream_util.h"
#include "string_manip.h"
#include "file_manip.h"
#include "opreport_options.h"
#include "op_header.h"
#include "profile.h"
#include "populate.h"
#include "arrange_profiles.h"
#include "profile_container.h"
#include "callgraph_container.h"
#include "diff_container.h"
#include "symbol_sort.h"
#include "format_output.h"
#include "xml_utils.h"
#include "image_errors.h"

using namespace std;

namespace {

static size_t nr_classes;

struct summary {
    count_array_t counts;
    string lib_image;

    bool operator<(summary const & rhs) const {
        return options::reverse_sort
            ? counts[0] < rhs.counts[0] : rhs.counts[0] < counts[0];
    }

    count_type add_files(list<profile_sample_files> const & files,
                         size_t pclass);
};


count_type summary::
add_files(list<profile_sample_files> const & files, size_t pclass)
{
    count_type subtotal = 0;

    list<profile_sample_files>::const_iterator it = files.begin();
    list<profile_sample_files>::const_iterator const end = files.end();

    for (; it != end; ++it) {
        count_type count = profile_t::sample_count(it->sample_filename);
        counts[pclass] += count;
        subtotal += count;

        if (!it->cg_files.empty()) {
            throw op_runtime_error("opreport.cpp::add_files(): "
                   "unxpected non empty cg file set");
        }
    }

    return subtotal;
}


struct app_summary {
    count_array_t counts;
    string image;
    vector<summary> deps;

    count_type add_profile(profile_set const & profile, size_t pclass);

    bool operator<(app_summary const & rhs) const {
        return options::reverse_sort 
            ? counts[0] < rhs.counts[0] : rhs.counts[0] < counts[0];
    }

private:
    summary & find_summary(string const & image);
};


summary & app_summary::find_summary(string const & image)
{
    vector<summary>::iterator sit = deps.begin();
    vector<summary>::iterator const send = deps.end();
    for (; sit != send; ++sit) {
        if (sit->lib_image == image)
            return *sit;
    }

    summary summ;
    summ.lib_image = image;
    deps.push_back(summ);
    return deps.back();
}


count_type app_summary::add_profile(profile_set const & profile,
                                size_t pclass)
{
    count_type group_total = 0;

    // first the main image
    summary & summ = find_summary(profile.image);
    count_type app_count = summ.add_files(profile.files, pclass);
    counts[pclass] += app_count;
    group_total += app_count;

    // now all dependent images if any
    list<profile_dep_set>::const_iterator it = profile.deps.begin();
    list<profile_dep_set>::const_iterator const end = profile.deps.end();

    for (; it != end; ++it) {
        summary & summ = find_summary(it->lib_image);
        count_type lib_count = summ.add_files(it->files, pclass);
        counts[pclass] += lib_count;
        group_total += lib_count;
    }

    return group_total;
}


struct summary_container {
    summary_container(vector<profile_class> const & pclasses);

    vector<app_summary> apps;
    count_array_t total_counts;
};


summary_container::
summary_container(vector<profile_class> const & pclasses)
{
    typedef map<string, app_summary> app_map_t;
    app_map_t app_map;

    for (size_t i = 0; i < pclasses.size(); ++i) {
        list<profile_set>::const_iterator it
            = pclasses[i].profiles.begin();
        list<profile_set>::const_iterator const end
            = pclasses[i].profiles.end();

        for (; it != end; ++it) {
            app_map_t::iterator ait = app_map.find(it->image);
            if (ait == app_map.end()) {
                app_summary app;
                app.image = it->image;
                total_counts[i] += app.add_profile(*it, i);
                app_map[app.image] = app;
            } else {
                total_counts[i]
                    += ait->second.add_profile(*it, i);
            }
        }
    }

    app_map_t::const_iterator it = app_map.begin();
    app_map_t::const_iterator const end = app_map.end();

    for (; it != end; ++it)
        apps.push_back(it->second);

    // sort by count
    stable_sort(apps.begin(), apps.end());
    vector<app_summary>::iterator ait = apps.begin();
    vector<app_summary>::iterator const aend = apps.end();
    for (; ait != aend; ++ait)
        stable_sort(ait->deps.begin(), ait->deps.end());
}


void output_header()
{
    if (!options::show_header)
        return;

    cout << classes.cpuinfo << endl;
    if (!classes.event.empty())
        cout << classes.event << endl;

    for (vector<profile_class>::size_type i = 0;
         i < classes.v.size(); ++i) {
        cout << classes.v[i].longname << endl;
    }
}


string get_filename(string const & filename)
{
    return options::long_filenames ? filename : op_basename(filename);
}


void output_count(count_type total_count, count_type count)
{
    cout << setw(9) << count << ' ';
    double ratio = op_ratio(count, total_count);
    cout << format_percent(ratio * 100, percent_int_width,
                  percent_fract_width) << ' ';
}


void output_col_headers(bool indent)
{
    if (!options::show_header)
        return;

    if (indent)
        cout << '\t';

    size_t colwidth = 9 + 1 + percent_width;

    for (size_t i = 0; i < classes.v.size(); ++i) {
        string name = classes.v[i].name;
        if (name.length() > colwidth)
            name = name.substr(0, colwidth - 3)
                + "...";
        io_state state(cout);
        // gcc 2.95 doesn't know right io manipulator
        cout.setf(ios::right, ios::adjustfield);
        // gcc 2.95 doesn't honor setw() for std::string
        cout << setw(colwidth) << name.c_str();
        cout << '|';
    }
    cout << '\n';

    if (indent)
        cout << '\t';

    for (size_t i = 0; i < classes.v.size(); ++i) {
        cout << "  samples| ";
        io_state state(cout);
        // gcc 2.95 doesn't know right io manipulator
        cout.setf(ios::right, ios::adjustfield);
        cout << setw(percent_width) << "%|";
    }

    cout << '\n';

    if (indent)
        cout << '\t';

    for (size_t i = 0; i < classes.v.size(); ++i) {
        cout << "-----------";
        string str(percent_width, '-');
        cout << str;
    }

    cout << '\n';
}


void
output_deps(summary_container const & summaries,
        app_summary const & app)
{
    // the app summary itself is *always* present
    // (perhaps with zero counts) so this test
    // is correct
    if (app.deps.size() == 1)
        return;

    output_col_headers(true);

    for (size_t j = 0 ; j < app.deps.size(); ++j) {
        summary const & summ = app.deps[j];

        if (summ.counts.zero())
            continue;

        cout << '\t';

        for (size_t i = 0; i < nr_classes; ++i) {
            count_type tot_count = options::global_percent
                ? summaries.total_counts[i] : app.counts[i];

            output_count(tot_count, summ.counts[i]);
        }

        cout << get_filename(summ.lib_image);
        cout << '\n';
    }
}


void output_summaries(summary_container const & summaries)
{
    output_col_headers(false);

    for (size_t i = 0; i < summaries.apps.size(); ++i) {
        app_summary const & app = summaries.apps[i];

        if ((app.counts[0] * 100.0) / summaries.total_counts[0]
            < options::threshold) {
            continue;
        }

        for (size_t j = 0; j < nr_classes; ++j)
            output_count(summaries.total_counts[j], app.counts[j]);

        cout << get_filename(app.image) << '\n';

        output_deps(summaries, app);
    }
}


format_flags get_format_flags(column_flags const & cf)
{
    format_flags flags(ff_none);
    flags = format_flags(flags | ff_nr_samples);
    flags = format_flags(flags | ff_percent | ff_symb_name);

    if (options::show_address)
        flags = format_flags(flags | ff_vma);

    if (options::debug_info)
        flags = format_flags(flags | ff_linenr_info);

    if (options::accumulated) {
        flags = format_flags(flags | ff_nr_samples_cumulated);
        flags = format_flags(flags | ff_percent_cumulated);
    }

    if (classes2.v.size())
        flags = format_flags(flags | ff_diff);

    if (cf & cf_image_name)
        flags = format_flags(flags | ff_image_name);

    return flags;
}


void output_symbols(profile_container const & pc, bool multiple_apps)
{
    profile_container::symbol_choice choice;
    choice.threshold = options::threshold;
    symbol_collection symbols = pc.select_symbols(choice);
    options::sort_by.sort(symbols, options::reverse_sort,
                          options::long_filenames);
    format_output::formatter * out;
    format_output::xml_formatter * xml_out = 0;
    format_output::opreport_formatter * text_out = 0;

    if (options::xml) {
        xml_out = new format_output::xml_formatter(&pc, symbols,
            pc.extra_found_images, options::symbol_filter);
        xml_out->show_details(options::details);
        out = xml_out;
        // for XML always output long filenames
        out->show_long_filenames(true);
    } else {
        text_out = new format_output::opreport_formatter(pc);
        text_out->show_details(options::details);
        out = text_out;
        out->show_long_filenames(options::long_filenames);
    }

    out->set_nr_classes(nr_classes);
    out->show_header(options::show_header);
    out->vma_format_64bit(choice.hints & cf_64bit_vma);
    out->show_global_percent(options::global_percent);

    format_flags flags = get_format_flags(choice.hints);
    if (multiple_apps)
        flags = format_flags(flags | ff_app_name);

    out->add_format(flags);

    if (options::xml) {
        xml_support = new xml_utils(xml_out, symbols, nr_classes,
            pc.extra_found_images);
        xml_out->output(cout);
    } else {
        text_out->output(cout, symbols);
    }
}


void output_diff_symbols(profile_container const & pc1,
                         profile_container const & pc2, bool multiple_apps)
{
    diff_container dc(pc1, pc2);

    profile_container::symbol_choice choice;
    choice.threshold = options::threshold;

    diff_collection symbols = dc.get_symbols(choice);

    format_flags flags = get_format_flags(choice.hints);
    if (multiple_apps)
        flags = format_flags(flags | ff_app_name);

    // With diff profile we output only filename coming from the first
    // profile session, internally we use only name derived from the sample
    // filename so image name can match.
    format_output::diff_formatter out(dc, pc1.extra_found_images);

    out.set_nr_classes(nr_classes);
    out.show_long_filenames(options::long_filenames);
    out.show_header(options::show_header);
    out.show_global_percent(options::global_percent);
    out.vma_format_64bit(choice.hints & cf_64bit_vma);
    out.add_format(flags);

    options::sort_by.sort(symbols, options::reverse_sort,
                          options::long_filenames);

    out.output(cout, symbols);
}


void output_cg_symbols(callgraph_container const & cg, bool multiple_apps)
{
    column_flags output_hints = cg.output_hint();

    symbol_collection symbols = cg.get_symbols();

    options::sort_by.sort(symbols, options::reverse_sort,
                          options::long_filenames);

    format_output::formatter * out;
    format_output::xml_cg_formatter * xml_out = 0;
    format_output::cg_formatter * text_out = 0;

    if (options::xml) {
        xml_out = new format_output::xml_cg_formatter(cg, symbols,
            options::symbol_filter);
        xml_out->show_details(options::details);
        out = xml_out;
        // for XML always output long filenames
        out->show_long_filenames(true);
    } else {
        text_out = new format_output::cg_formatter(cg);
        out = text_out;
        out->show_long_filenames(options::long_filenames);
    }

    out->set_nr_classes(nr_classes);
    out->show_header(options::show_header);
    out->vma_format_64bit(output_hints & cf_64bit_vma);
    out->show_global_percent(options::global_percent);

    format_flags flags = get_format_flags(output_hints);
    if (multiple_apps)
        flags = format_flags(flags | ff_app_name);

    out->add_format(flags);

    if (options::xml) {
        xml_support = new xml_utils(xml_out, symbols, nr_classes,
            cg.extra_found_images);
        xml_out->output(cout);
    } else {
        text_out->output(cout, symbols);
    }

}


int opreport(options::spec const & spec)
{
    want_xml = options::xml;

    handle_options(spec);

    nr_classes = classes.v.size();

    if (!options::symbols && !options::xml) {
        summary_container summaries(classes.v);
        output_header();
        output_summaries(summaries);
        return 0;
    }

    bool multiple_apps = false;

    for (size_t i = 0; i < classes.v.size(); ++i) {
        if (classes.v[i].profiles.size() > 1)
            multiple_apps = true;
    }

    list<inverted_profile> iprofiles = invert_profiles(classes);

    report_image_errors(iprofiles, classes.extra_found_images);

    if (options::xml) {
        xml_utils::output_xml_header(options::command_options,
                                     classes.cpuinfo, classes.event);
    } else {
        output_header();
    }

    if (classes2.v.size()) {
        for (size_t i = 0; i < classes2.v.size(); ++i) {
            if (classes2.v[i].profiles.size() > 1)
                multiple_apps |= true;
        }

        profile_container pc1(options::debug_info, options::details,
                      classes.extra_found_images);

        list<inverted_profile>::iterator it = iprofiles.begin();
        list<inverted_profile>::iterator const end = iprofiles.end();

        for (; it != end; ++it)
            populate_for_image(pc1, *it,
                       options::symbol_filter, 0);

        list<inverted_profile> iprofiles2 = invert_profiles(classes2);

        report_image_errors(iprofiles2, classes2.extra_found_images);

        profile_container pc2(options::debug_info, options::details,
                      classes2.extra_found_images);

        list<inverted_profile>::iterator it2 = iprofiles2.begin();
        list<inverted_profile>::iterator const end2 = iprofiles2.end();

        for (; it2 != end2; ++it2)
            populate_for_image(pc2, *it2,
                       options::symbol_filter, 0);

        output_diff_symbols(pc1, pc2, multiple_apps);
    } else if (options::callgraph) {
        callgraph_container cg_container;
        cg_container.populate(iprofiles, classes.extra_found_images,
            options::debug_info, options::threshold,
            options::merge_by.lib, options::symbol_filter);

        output_cg_symbols(cg_container, multiple_apps);
    } else {
        profile_container samples(options::debug_info,
            options::details, classes.extra_found_images);

        list<inverted_profile>::iterator it = iprofiles.begin();
        list<inverted_profile>::iterator const end = iprofiles.end();

        for (; it != end; ++it)
            populate_for_image(samples, *it,
                       options::symbol_filter, 0);

        output_symbols(samples, multiple_apps);
    }

    return 0;
}

}  // anonymous namespace


int main(int argc, char const * argv[])
{
    cout.tie(0);
    return run_pp_tool(argc, argv, opreport);
}