artis/src/artis/utils/Trace.hpp

/**
 * @file utils/Trace.hpp
 * @author See the AUTHORS file
 */

/*
 * Copyright (C) 2012-2017 ULCO http://www.univ-littoral.fr
 *
 * 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/>.
 */

#ifndef ARTIS_UTILS_TRACE
#define ARTIS_UTILS_TRACE

#include <algorithm>
#include <iterator>
#include <memory>
#include <mutex>
#include <sstream>
#include <string>
#include <vector>

#include <artis/utils/DateTime.hpp>
#include <artis/kernel/Any.hpp>

namespace artis { namespace utils {

enum TraceType { NONE = 0, CHECK, CONSTRUCT, SUBMODEL_ADD, INTERNAL_DECL,
                 EXTERNAL_DECL, INTERNAL_LINK, INIT, START, BEFORE_COMPUTE,
                 COMPUTE, PUT, AFTER_COMPUTE, DESTRUCT, KERNEL};

struct KernelInfo
{
    std::string         _var;
    bool                _internal_var;
    std::string         _value;
    std::string         _tgt_model;
    std::string         _tgt_internal_var;

    KernelInfo(const std::string& var, bool internal_var,
               const std::string& value) :
        _var(var), _internal_var(internal_var), _value(value),
        _tgt_model(""), _tgt_internal_var("")
    { }

    KernelInfo(const std::string& var, const std::string& tgt_model,
               const std::string& tgt_internal_var) :
        _var(var), _internal_var(true), _value(""),
        _tgt_model(tgt_model), _tgt_internal_var(tgt_internal_var)
    { }

    KernelInfo(const std::string& var, bool internal_var) :
        _var(var), _internal_var(internal_var), _value(""),
        _tgt_model(""), _tgt_internal_var("")
    { }

    KernelInfo(const std::string& tgt_model) :
        _var(""), _internal_var(false), _value(""),
        _tgt_model(tgt_model), _tgt_internal_var("")
    { }

    const std::string& to_string() const {
        std::ostringstream ss;
        if( not _var.empty() ){
            ss << ":";
            if (not _internal_var)
                ss << "*";
            ss << _var;
        }

        if( not _value.empty()) {
            ss << "=" << _value;
        }
        if(not _tgt_model.empty()) {
            ss << " " << _tgt_model;
            if(not _tgt_internal_var.empty()) {
                ss << ":" << _tgt_internal_var;
            }
        }

        return ss.str();
    }
};

template < class Time >
class TraceElement
{
public:
    TraceElement() : _time(Time::null), _type(NONE)
    { }

    TraceElement(const std::string& model_name, typename Time::type time,
                 TraceType type) :
        _model_name(model_name), _time(time), _type(type)
    { }

    virtual ~TraceElement()
    { }

    const std::string& get_comment() const
    { return _comment; }

    const std::string& get_model_name() const
    { return _model_name; }

    typename Time::type get_time() const
    { return _time; }

    TraceType get_type() const
    { return _type; }

    const std::vector< KernelInfo >& get_kernel_info() const
    { return _kernel_info; }

    void set_comment(const std::string& comment)
    { _comment = comment; }

    void add_kernel_info(const KernelInfo& info)
    { _kernel_info.push_back(info); }

private:
    std::string         _model_name;
    typename Time::type _time;
    TraceType           _type;
    std::string         _comment;
    std::vector< KernelInfo > _kernel_info;
};

template < class Time >
class TraceElements : public std::vector < TraceElement < Time > >
{
public:
    TraceElements()
    { }
    virtual ~TraceElements()
    { }

    TraceElements filter_model_name(
            const std::string& model_name) const
    {
        TraceElements < Time > result;

        std::copy_if(TraceElements < Time >::begin(),
                     TraceElements < Time >::end(), std::back_inserter(result),
                     [model_name](TraceElement < Time > const & x)
        { return x.get_model_name() == model_name; });
        return result;
    }

    TraceElements filter_time(typename Time::type time) const
    {
        TraceElements result;

        std::copy_if(TraceElements < Time >::begin(),
                     TraceElements < Time >::end(), std::back_inserter(result),
                     [time](TraceElement < Time > const & x)
        { return x.get_time() == time; });
        return result;
    }

    TraceElements filter_type(TraceType type) const
    {
        TraceElements result;

        std::copy_if(TraceElements < Time >::begin(),
                     TraceElements < Time >::end(), std::back_inserter(result),
                     [type](TraceElement < Time > const & x)
        { return x.get_type() == type; });
        return result;
    }

    std::string to_string(artis::utils::DateFormat date_format = artis::utils::DATE_FORMAT_EXTENDED) const
    {
        std::ostringstream ss;

        for (typename TraceElements < Time >::const_iterator it =
             TraceElements < Time >::begin();
             it != TraceElements < Time >::end(); ++it) {
            ss << "TRACE: ";
            std::string time = "";
            if(it->get_time() != Time::null) {
                std::string date = utils::DateTime::toJulianDayFmt(it->get_time(), date_format);
                time = "(" + date + ")";
            }
            ss << time;
            std::string type = "none";
            switch (it->get_type())
            {
            case NONE: type = "none"; break;
            case CONSTRUCT: type = "construct"; break;
            case DESTRUCT: type = "destruct"; break;
            case CHECK: type = "check"; break;
            case COMPUTE:  type = "compute"; break;
            case INIT: type = "init"; break;
            case KERNEL: type = "kernel"; break;
            case PUT: type = "put"; break;
            };
            type = "<" + type + ">";
            ss << type;
            std::string model_name = it->get_model_name();
            ss << " " << model_name;

            if (not it->get_comment().empty()) {
                ss << " => " << it->get_comment();
            }

            for (std::vector < KernelInfo >::const_iterator itk = it->get_kernel_info().begin(); itk != it->get_kernel_info().end(); ++itk) {
                ss << std::endl;
                ss << "TRACE: ";
                ss << time << type << " " << model_name;
                ss << itk->to_string();
            }
            ss << std::endl;
        }
        return ss.str();
    }
};

template < class Time >
class Trace
{
public:
    virtual ~Trace()
    { }

    static Trace& trace()
    {
        std::call_once(_flag, [] ()
        { _instance.reset(new Trace()); std::cout << "Trace singleton done" << std::endl;}
        );
        return *_instance;
    }

    void clear()
    { _trace.clear(); }

    const TraceElements < Time >& elements() const
    { return _trace; }

    void flush()
    {
        if (_sstream) {
            _element.set_comment(_sstream->str());
            delete _sstream;
            _sstream = 0;
        }
        _trace.push_back(_element);
    }

    std::mutex& mutex()
    { return _mutex; }

    void set_element(const TraceElement < Time >& element)
    { _element = element; }

    void add_kernel_info(const KernelInfo& info)
    { _element.add_kernel_info(info); }

    std::ostringstream& sstream()
    {
        if (_sstream == 0) {
            _sstream = new std::ostringstream();
        }
        return *_sstream;
    }

private:
    Trace()
    { _sstream = 0; }

    static std::shared_ptr < Trace < Time > > _instance;
    static std::once_flag                     _flag;

    TraceElements < Time > _trace;
    TraceElement < Time >  _element;
    std::ostringstream*    _sstream;
    std::mutex             _mutex;
};

} }

template < class Time >
artis::utils::Trace < Time >& operator<<(
        artis::utils::Trace < Time >& trace,
        const artis::utils::TraceElement < Time >& e)
{
    std::lock_guard < std::mutex > lock(trace.mutex());

    trace.set_element(e);
    return trace;
}

template < class Time >
artis::utils::Trace < Time >& operator<<(
        artis::utils::Trace < Time >& trace,
        const artis::utils::KernelInfo& info)
{
    std::lock_guard < std::mutex > lock(trace.mutex());

    trace.add_kernel_info(info);
    return trace;
}

template < class Time >
artis::utils::Trace < Time >& operator<<(
        artis::utils::Trace < Time >& trace,
        const std::string& str)
{
    std::lock_guard < std::mutex > lock(trace.mutex());

    trace.sstream() << str;
    return trace;
}

template < class Time >
artis::utils::Trace < Time >& operator<<(
        artis::utils::Trace < Time >& trace,
        typename Time::type t)
{
    std::lock_guard < std::mutex > lock(trace.mutex());

    trace.sstream() << t;
    return trace;
}

template < class Time >
std::shared_ptr < artis::utils::Trace < Time > >
artis::utils::Trace < Time >::_instance;

template < class Time >
std::once_flag artis::utils::Trace < Time >::_flag;

#endif