Logger.h

// Copyright (C) 2003-2016 Anders Logg, 2015 Jan Blechta
//
// This file is part of DOLFIN.
//
// DOLFIN is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// DOLFIN 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 Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with DOLFIN. If not, see <http://www.gnu.org/licenses/>.
//
// Thanks to Jim Tilander for many helpful hints.
//
// Modified by Ola Skavhaug 2007, 2009

#ifndef __LOGGER_H
#define __LOGGER_H

#include <map>
#include <memory>
#include <ostream>
#include <string>
#include <set>
#include <thread>
#include <tuple>

#include <dolfin/common/timing.h>
#include <dolfin/common/MPI.h>
#include "Table.h"
#include "LogLevel.h"

namespace dolfin
{


  class Logger
  {
  public:

    Logger();

    ~Logger();

    void log(std::string msg, int log_level=INFO) const;

    void log_underline(std::string msg, int log_level=INFO) const;

    void warning(std::string msg) const;

    void error(std::string msg) const;

    void dolfin_error(std::string location,
                      std::string task,
                      std::string reason,
                      int mpi_rank=-1) const;

    void deprecation(std::string feature,
                     std::string version_deprecated,
                     std::string message) const;

    void begin(std::string msg, int log_level=INFO);

    void end();

    void progress (std::string title, double p) const;

    void set_output_stream(std::ostream& stream);

    std::ostream& get_output_stream() { return *logstream; }

    void set_log_active(bool active);

    inline bool is_active() { return _active; }

    void set_log_level(int log_level);

    inline int get_log_level() const { return _log_level; }

    void set_indentation_level(std::size_t indentation_level);

    void register_timing(std::string task,
                         std::tuple<double, double, double> elapsed);

    Table timings(TimingClear clear, std::set<TimingType> type);

    void list_timings(TimingClear clear, std::set<TimingType> type);

    void dump_timings_to_xml(std::string filename, TimingClear clear);

    std::tuple<std::size_t, double, double, double>
      timing(std::string task, TimingClear clear);

    void monitor_memory_usage();

    MPI_Comm mpi_comm()
    { return _mpi_comm; }

    void _report_memory_usage(size_t num_mb);

    void __debug(std::string msg) const;

    void __dolfin_assert(std::string file, unsigned long line,
                  std::string function, std::string check) const;

  private:

    // Write message
    void write(int log_level, std::string msg) const;

    // True iff logging is active
    bool _active;

    // Current log level
    int _log_level;

    // Current indentation level
    int _indentation_level;

    // Optional stream for logging
    std::ostream* logstream;

    // List of timings for tasks, map from string to
    // (num_timings, total_wall_time, total_user_time, total_system_time)
    std::map<std::string, std::tuple<std::size_t, double, double, double>>
       _timings;

    // Thread used for monitoring memory usage
    std::unique_ptr<std::thread> _thread_monitor_memory_usage;

    // Maximum memory usage so far
    long int _maximum_memory_usage;

    // Map for stringifying TimingType
    static std::map<TimingType, std::string> _TimingType_descr;

    // FIXME: This should be a dolfin::MPI::Comm, the MPI-awareness of
    //        the logging needs to be fixed.
    // MPI Communicator
    MPI_Comm _mpi_comm;

  };

}

#endif