process.h

/*
 * Copyright 2021 Max Planck Institute for Software Systems, and
 * National University of Singapore
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

#pragma once

#include <map>
#include <set>
#include <string>
#include <boost/iostreams/filtering_streambuf.hpp>

#include "trace/events.h"

class sym_map {
  protected:
    bool filter_en;
    bool insmap_en;
    std::set<std::string> filter;

  public:
    std::map<uint64_t, std::string> map;
    std::map<uint64_t, std::string> map_ins;

    sym_map();

    void add_filter(const std::string &sym);
    void load_file(const char *path, uint64_t offset = 0);

    inline const std::string *lookup(uint64_t addr)
    {
        auto it = map.find(addr);
        if (it == map.end())
            return nullptr;

        return &it->second;
    }
};

class log_parser {
  protected:
    std::istream *inf;

    std::ifstream *gz_file;
    boost::iostreams::filtering_streambuf<boost::iostreams::input> *gz_in;

    static const size_t block_size = 16 * 1024 * 1024;
    char *buf;
    size_t buf_len;
    size_t buf_pos;

    bool next_block();
    size_t try_line();
    virtual void process_line(char *line, size_t len) = 0;

  public:
    const char *label;
    event *cur_event;

    log_parser();
    virtual ~log_parser();
    void open(const char *path);
    void open_gz(const char *path);

    bool next_event();
};

class gem5_parser : public log_parser {
  protected:
    sym_map &syms;

    virtual void process_line(char *line, size_t len);
    void process_msg(uint64_t ts, char *comp_name, size_t comp_name_len,
            char *msg, size_t msg_len);

  public:
    gem5_parser(sym_map &syms_);
    virtual ~gem5_parser();
};

class nicbm_parser : public log_parser {
  protected:
    virtual void process_line(char *line, size_t len);

  public:
    virtual ~nicbm_parser();
};