Gambit::Logging::LogMaster Class Reference

Logging "controller" object Keeps track of the various "Logger" objects. More...

#include <logmaster.hpp>

Collaboration diagram for Gambit::Logging::LogMaster:

Public Member Functions
void	set_log_debug_messages (bool flag)
	Choose whether "Debug" tagged log messages will be ignored (i.e. not logged) More...

Private Attributes
std::map< std::set< int >, BaseLogger * >	loggers
	Map to identify loggers. More...
std::set< int >	ignore
	Global ignore set; if these tags/integers are seen, ignore messages containing them. More...
bool	loggers_readyQ
	Flag to set whether loggers have been initialised not. More...
bool	silenced
	Flag to silence logger. More...
bool	separate_file_per_process
	Flag to store log messages for different processes in separate files. More...
bool	log_debug_messages
	Flag to ignore Debug tagged messages. More...
int	MPIrank
	MPI variables. More...
int	MPIsize
int	globlMaxThreads
	Max number of threads that could potentially be running. More...
int *	current_module
	Variables that need to be threadsafe. More...
int *	current_backend
std::ostringstream *	stream
	Buffer variables needed for stream logging. More...
std::set< int > *	streamtags
std::deque< Message > *	backlog
	Messages sent before logger objects are created will be buffered Same for messages sent while inside omp parallel blocks. More...
	LogMaster ()
	Default constructor. More...
	LogMaster (std::map< std::set< int >, BaseLogger *> &)
	Alternate constructor Mainly for testing; lets you pass in pre-built loggers and their tags. More...
	~LogMaster ()
	Destructor If errors happen before the inifile is loaded, we need to dump the log messages (that have been buffered) into a default log file. More...
void	init_memory ()
	Initialise dynamic memory required for thread safety. More...
void	initialise (std::vector< std::pair< std::set< std::string >, std::string >> &)
	Function to construct loggers according to blueprint. More...
void	initialise (std::map< std::set< std::string >, std::string > &)
void	initialise (std::map< std::string, std::string > &)
void	disable ()
bool	disabled ()
void	enable ()
void	emit_backlog (bool verbose)
	Print the backlogs to the default log file. More...
void	input (const std::string &)
	Functions for stream input (actual stream operators which use these are defined in logger.cpp) More...
void	input (const LogTag &)
	Handle LogTag input. More...
void	input (const endofmessage &)
	Handle end of message character. More...
void	input (const manip1)
	Handle various stream manipulators. More...
void	input (const manip2)
void	input (const manip3)
void	send (const std::string &)
	Main logging function (user-friendly overloaded version) More...
void	send (const std::string &, LogTag)
void	send (const std::string &, LogTag, LogTag)
void	send (const std::string &, LogTag, LogTag, LogTag)
void	send (const std::string &, LogTag, LogTag, LogTag, LogTag)
void	send (const std::string &, LogTag, LogTag, LogTag, LogTag, LogTag)
void	send (const std::ostringstream &)
	stringstream versions.... More...
void	send (const std::ostringstream &, LogTag)
void	send (const std::ostringstream &, LogTag, LogTag)
void	send (const std::ostringstream &, LogTag, LogTag, LogTag)
void	send (const std::ostringstream &, LogTag, LogTag, LogTag, LogTag)
void	send (const std::ostringstream &, LogTag, LogTag, LogTag, LogTag, LogTag)
void	send (const std::string &, std::set< LogTag > &)
	Internal version of main logging function. More...
void	send (const std::string &, std::set< int > &)
	Serious version of main logging function. More...
void	finalsend (const Message &)
	Version of send function used by buffer dump; skips all the tag modification stuff. More...
void	send (const std::ostringstream &, std::set< LogTag > &)
	stringstream overloads... More...
void	send (const std::ostringstream &, std::set< int > &)
void	entering_module (int)
	Set the internal variables tracking which module and/or backend is currently running. More...
void	leaving_module ()
void	entering_backend (int)
void	leaving_backend ()
void	empty_backlog ()
	Empty the backlog buffer to the 'send' function. More...

Detailed Description

Logging "controller" object Keeps track of the various "Logger" objects.

Definition at line 49 of file logmaster.hpp.

Constructor & Destructor Documentation

LogMaster() [1/2]

Gambit::Logging::LogMaster::LogMaster

(

)

Default constructor.

Logger class member function definitions.

Logging "controller" object Keeps track of the individual logging objects.

Definition at line 55 of file logmaster.cpp.

      : loggers_readyQ (false)
      , silenced       (false)
      , separate_file_per_process(true)
      , log_debug_messages(false)
      , MPIrank        (0)
      , MPIsize        (1)
      , globlMaxThreads(omp_get_max_threads())
      , current_module (NULL)
      , current_backend(NULL)
      , stream         (NULL)
      , streamtags     (NULL)
      , backlog        (NULL)
    {
      // Note! MPIrank and MPIsize will not be correct until initialisation occurs!
    }

LogMaster() [2/2]

Gambit::Logging::LogMaster::LogMaster

(

std::map< std::set< int >, BaseLogger *> &

loggersIN

)

Alternate constructor Mainly for testing; lets you pass in pre-built loggers and their tags.

Alternate constructor.

Definition at line 74 of file logmaster.cpp.

      : loggers        (loggersIN)
      , loggers_readyQ (true)
      , silenced       (false)
      , separate_file_per_process(true)
      , log_debug_messages(false)
      , MPIrank        (0)
      , MPIsize        (1)
      , globlMaxThreads(omp_get_max_threads())
      , current_module (NULL)
      , current_backend(NULL)
      , stream         (NULL)
      , streamtags     (NULL)
      , backlog        (NULL)
    {
      // Note! MPIrank and MPIsize will not be correct until initialisation occurs!
    }

~LogMaster()

Gambit::Logging::LogMaster::~LogMaster

(

)

Destructor If errors happen before the inifile is loaded, we need to dump the log messages (that have been buffered) into a default log file.

These will be log messages coming from initialisation code and so on.

Definition at line 171 of file logmaster.cpp.

References backlog, current_backend, current_module, emit_backlog(), Gambit::EOM, loggers, silenced, stream, streamtags, and Gambit::LogTags::warn.

    {
       // See signal_handling.cpp for why we should not bail out in this situation
       // // LogMaster should not be destructed from within a parallel block. This check helps detect such a bug.
       // if(omp_get_level()!=0)
       // {
       //    // Raising an error from within the loggers within a parallel block probably will not end well, just use cout.
       //    #pragma omp critical(logmaster_destructor)
       //    {
       //      std::cout << "rank "<<MPIrank<<": "<< LOCAL_INFO << ": Tried to destruct LogMaster from inside an omp parallel block! This should not be allowed to happen, please file a bug report." << std::endl;
       //      exit(EXIT_FAILURE);
       //    }
       // }

       if(not silenced)
       {
         // Check if there is anything in the output stream that has not been sent, and send it if there is
         // (these messages will get backlogged because they are sent (ended) from a parallel block, but we are
         // about to empty the backlogs anyway so that is no problem).
         if (stream != NULL and streamtags!= NULL)
         {
           #pragma omp parallel
           {
              int i = omp_get_thread_num();
              if (not stream[i].str().empty() or not streamtags[i].empty())
              {
                *this <<"#### NO EOM RECEIVED FOR MESSAGE FROM THREAD ("<<i<<"): MESSAGE MAY BE INCOMPLETE ####"<<warn<<EOM;
              }
           }
         }

         // Output the message backlogs if needed
         emit_backlog(true);

       }

       // Delete logger objects
       for(std::map<std::set<int>,BaseLogger*>::iterator keyvalue = loggers.begin(); keyvalue != loggers.end(); ++keyvalue)
       {
         // Ensure their filestreams have been flushed before we delete them.
         // (not sure if this is really needed, I think the message is in the operating systems domain by this point)
         // Edit:  I think I have decided that this is unnecessary
         //(keyvalue->second)->flush();
         delete (keyvalue->second);
       }

       // Delete the thread variables
       if (stream != NULL)         delete [] stream;
       if (streamtags != NULL)     delete [] streamtags;
       if (backlog != NULL)        delete [] backlog;
       if (current_module !=NULL)  delete [] current_module;
       if (current_backend !=NULL) delete [] current_backend;
    }

Here is the call graph for this function:

Member Function Documentation

disable()

void Gambit::Logging::LogMaster::disable

(

)

Definition at line 363 of file logmaster.cpp.

References loggers_readyQ, and silenced.

Referenced by bail(), Gambit::gambit_core::bail(), main(), Gambit::gambit_core::process_primary_options(), and Gambit::gambit_core::run_diagnostic().

    {
       loggers_readyQ = true;
       silenced = true;
    }

Here is the caller graph for this function:

disabled()

bool Gambit::Logging::LogMaster::disabled

(

)

Definition at line 376 of file logmaster.cpp.

References silenced.

    {
       return silenced;
    }

emit_backlog()

void Gambit::Logging::LogMaster::emit_backlog

(

bool

verbose

)

Print the backlogs to the default log file.

Definition at line 137 of file logmaster.cpp.

References backlog, Gambit::Utils::construct_runtime_scratch(), Gambit::LogTags::def, empty_backlog(), Gambit::EOM, globlMaxThreads, loggers, and loggers_readyQ.

Referenced by Gambit::gambit_core::run_diagnostic(), and ~LogMaster().

    {
       if (backlog!=NULL)
       {
         bool backlog_empty = true;
         for(int i=0; i<globlMaxThreads; i++)
         {
            if(backlog[i].size()!=0) backlog_empty = false;
         }
         if (not backlog_empty)
         {
           if (verbose) *this<<"Logger backlog buffer not empty during LogMaster destruction; attempting to deliver unsent messages to the logs..."<<EOM;
           // If LogMaster was never initialised, create a default log file to which the messages can be dumped.
           if (not loggers_readyQ)
           {
             str log_path = Utils::construct_runtime_scratch(false) + "default.log";
             #ifdef WITH_MPI
               if (GMPI::Is_initialized() and not GMPI::Is_finalized())
                 log_path += ("_" + std::to_string(GMPI::Comm().Get_rank()));
             #endif
             if (verbose) std::cout<<std::endl<<"GAMBIT logger was never initialised. Outputting default log to "<<log_path<<std::endl;
             StdLogger* deflogger = new StdLogger(log_path);
             std::set<int> deftag;
             deftag.insert(def);
             loggers[deftag] = deflogger;
             loggers_readyQ = true;
           }
           // Dump buffered messages
           empty_backlog();
         }
       }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

empty_backlog()

void Gambit::Logging::LogMaster::empty_backlog ( )

private

Empty the backlog buffer to the 'send' function.

Definition at line 382 of file logmaster.cpp.

References backlog, finalsend(), and globlMaxThreads.

Referenced by emit_backlog(), initialise(), send(), and set_log_debug_messages().

    {
       // See signal_handling.cpp for why we should not bail out in this situation
       //if(omp_get_level()!=0)
       //{
       //   // Raising an error from within the loggers within a parallel block probably will not end well, just use cout.
       //   #pragma omp critical(logmaster_empty_backlog)
       //   {
       //     std::cout << LOCAL_INFO << ": (rank "<<MPIrank<<") Tried to run empty_backlog() (in LogMaster) from inside an omp parallel block! This should not be possible, please file a bug report." << std::endl;
       //     exit(EXIT_FAILURE);
       //   }
       //}

       for(int i=0; i<globlMaxThreads; i++)
       {
         for(size_t j=0; j<backlog[i].size(); j++)
         {
            finalsend(backlog[i].front());
            backlog[i].pop_front();
         }
       }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

enable()

void Gambit::Logging::LogMaster::enable

(

)

Definition at line 370 of file logmaster.cpp.

References silenced.

Referenced by main().

    {
       silenced = false;
    }

Here is the caller graph for this function:

entering_backend()

void Gambit::Logging::LogMaster::entering_backend

(

int

i

)

Definition at line 633 of file logmaster.cpp.

References current_backend, Gambit::LogTags::debug, Gambit::EOM, init_memory(), and Gambit::LogTags::logs.

Referenced by Gambit::backend_functor< TYPE(*)(ARGS...), TYPE, ARGS... >::operator()(), Gambit::backend_functor< void(*)(ARGS...), void, ARGS... >::operator()(), Gambit::backend_functor< typename variadic_ptr< TYPE, ARGS... >::type, TYPE, ARGS... >::operator()(), and Gambit::backend_functor< typename variadic_ptr< void, ARGS... >::type, void, ARGS... >::operator()().

    {
       init_memory();
       current_backend[omp_get_thread_num()] = i;
       *this<<"Setting current_backend="<<i;
       *this<<logs<<debug<<EOM;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

entering_module()

void Gambit::Logging::LogMaster::entering_module

(

int

i

)

Set the internal variables tracking which module and/or backend is currently running.

Definition at line 620 of file logmaster.cpp.

References current_module, and init_memory().

Referenced by Gambit::module_functor< ModelParameters >::calculate(), and Gambit::module_functor< void >::calculate().

    {
       init_memory();
       current_module[omp_get_thread_num()] = i;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

finalsend()

void Gambit::Logging::LogMaster::finalsend

(

const Message &

mail

)

Version of send function used by buffer dump; skips all the tag modification stuff.

Definition at line 574 of file logmaster.cpp.

References ignore, cyclic_include_check::includes, Gambit::Utils::is_disjoint(), loggers, Gambit::Logging::Message::message, Gambit::LogTags::repeat_to_cerr, Gambit::LogTags::repeat_to_cout, silenced, and Gambit::Logging::Message::tags.

Referenced by empty_backlog(), and send().

    {
       // Check the 'ignore' set; if any of the specified tags are in this set, then do nothing more, i.e. ignore the message.
       // (need to add extra stuff to ignore modules and backends, since these cannot be normal tags)
       // Also ignore the message if logs have been 'silenced'.
       if( silenced or not Utils::is_disjoint(mail.tags, ignore) )
       {
         //std::cout<<"Ignoring message..."<<std::endl;
         return;
       }

       // If the "cout" tag is seen, repeat the message to stdout
       if(mail.tags.find(repeat_to_cout) != mail.tags.end()) std::cout << mail.message << std::endl;

       // If the "cerr" tag is seen, repeat the message to sterr
       if(mail.tags.find(repeat_to_cerr) != mail.tags.end()) std::cerr << mail.message << std::endl;

       // Sort the tags
       const SortedMessage sortedmsg(mail);

       // Main loop for message distribution

       // Loop through the map of loggers and see if any of them match subsets of 'key'.
       for(std::map<std::set<int>,BaseLogger*>::iterator keyvalue = loggers.begin(); keyvalue != loggers.end(); ++keyvalue)
       {
         // if set1 includes set2
         if( std::includes(mail.tags.begin(), mail.tags.end(),
                           (keyvalue->first).begin(), (keyvalue->first).end()) )
         {
           // Matching logger object found! Send it the sorted message object
           (keyvalue->second)->write(sortedmsg);
         }
       } //end loop over loggers
    } // end LogMaster::finalsend

Here is the call graph for this function:

Here is the caller graph for this function:

init_memory()

void Gambit::Logging::LogMaster::init_memory

(

)

Initialise dynamic memory required for thread safety.

Definition at line 93 of file logmaster.cpp.

References backlog, current_backend, current_module, globlMaxThreads, generate_raster_scan_settings::n, stream, and streamtags.

Referenced by entering_backend(), entering_module(), input(), leaving_backend(), and leaving_module().

    {
      int n = globlMaxThreads;
      // Reserve enough space to hold as many variables as there are slots (threads) allowed
      if(stream==NULL)
      {
        #pragma omp critical(logmaster_common_init_memory_stream)
        {
          if(stream==NULL) stream = new std::ostringstream[n];
        }
      }
      if(streamtags==NULL)
      {
        #pragma omp critical(logmaster_common_init_memory_streamtags)
        {
          if(streamtags==NULL) streamtags = new std::set<int>[n];
        }
      }
      if(backlog==NULL)
      {
        #pragma omp critical(logmaster_common_init_memory_backlog)
        {
          if(backlog==NULL) backlog = new std::deque<Message>[n];
        }
      }
      if(current_module==NULL)
      {
        #pragma omp critical(logmaster_common_init_memory_current_module)
        {
          if(current_module==NULL) current_module = new int[n];
          std::fill(current_module, current_module+n, -1);
        }
      }
      if(current_backend==NULL)
      {
        #pragma omp critical(logmaster_common_init_memory_current_backend)
        {
          if(current_backend==NULL) current_backend = new int[n];
          std::fill(current_backend, current_backend+n, -1);
        }
      }
    }

Here is the caller graph for this function:

initialise() [1/3]

void Gambit::Logging::LogMaster::initialise

(

std::vector< std::pair< std::set< std::string >, std::string >> &

loggerinfo

)

Function to construct loggers according to blueprint.

Definition at line 227 of file logmaster.cpp.

References Gambit::LogTags::debug, empty_backlog(), Gambit::EOM, ignore, LOCAL_INFO, log_debug_messages, loggers, loggers_readyQ, Gambit::logging_error(), Gambit::LogTags::logs, MPIrank, MPIsize, separate_file_per_process, and Gambit::Logging::str2tag().

Referenced by Gambit::IniParser::Parser::basicParse(), initialise(), Gambit::initialise_standalone_logs(), and main().

    {
       // Fix up the MPI variables
       #ifdef WITH_MPI
       if(GMPI::Is_initialized())
       {
         GMPI::Comm COMM_WORLD;
         MPIsize = COMM_WORLD.Get_size();
         MPIrank = COMM_WORLD.Get_rank();
       }
       #endif

       // Check options and inform user what they are
       if (MPIrank == 0) std::cout << "Initialising logger...";
       // NOTE! Option to merge log files no longer exists. Concurrent write access is a nightmare. Log messages were
       // being lost due to different processes overwriting each others data, and using the FileLock system doesn't
       // help because the issue is the file pointer location. To fix that, files have to be closed and reopened
       // constantly, which creates a lot of overhead. On top of this, it is very hard to overwrite old log files at the
       // beginning of the run since we have to coordinate who creates the file at the beginning of the run, would have
       // to add a bunch of message passing. Overall it just isn't worth it.
       // #ifdef WITH_MPI
       // std::cout << std::endl << "  separate_file_per_process = ";
       // if(separate_file_per_process){ std::cout << "true; log messages will be stored in separate files for each MPI process (filename will be appended with underscore + MPI rank)"; }
       // else{ std::cout << "false; log messages from separate MPI processes will be merged into one file (orchestrated by the OS; some mangling of concurrently written log messages may occur. Set this separate_file_per_process to 'True' if this mangling is a problem for you)";}
       // #endif
       std::ostringstream logmsg;
       logmsg << "  log_debug_messages = ";
       if(log_debug_messages) logmsg << "true; log messages tagged as 'Debug' WILL be logged. " << endl << "WARNING: This may lead to very large log files!";
       else
       {
          // Add "Debug" tag to the global ignore list
          ignore.insert(LogTag::debug);
          logmsg << "false; log messages tagged as 'Debug' will NOT be logged";
       }

       if (MPIrank == 0) std::cout << logmsg.str() << std::endl;
       *this << LogTag::logs << LogTag::debug << logmsg.str() << EOM;

       // Iterate through map and build the logger objects
       for(std::vector<std::pair< std::set<std::string>, std::string >>::iterator infopair = loggerinfo.begin();
            infopair != loggerinfo.end(); ++infopair)
       {
          std::set<std::string> yamltags = infopair->first;
          std::string filename = infopair->second;
          std::set<int> tags;

          if(separate_file_per_process and MPIsize>1
             and filename!="stdout" and filename!="stderr")
          {
            std::ostringstream unique_filename;
            unique_filename << filename << "_" << MPIrank;
            filename = unique_filename.str();
          }

          // Log the loggers being created :)
          // (will be put into a preliminary buffer until loggers are all constructed)
          *this << LogTag::logs << LogTag::debug << std::endl << "Creating logger for tags [";

          // Iterate through string tags and convert them to the corresponding index
          for(std::set<std::string>::iterator stag = yamltags.begin();
                stag != yamltags.end(); ++stag)
          {
            // Finding the tag index from the tag string is kind of a drag, have to do a brute search
            int newtag = str2tag(*stag);
            // Check that valid tag was found (returns -1 if no tag found)
            if(newtag==-1)
            {
              // If we didn't find the tag, raise an exception (probably means there was an error in the yaml file)
              std::ostringstream errormsg;
              errormsg << "If you have an entry something like this:"<< endl
                       << "  Logger:" << endl
                       << "    redirection:" << endl
                       << "    [" << *stag << "] : \"blah.log\"" << endl
                       << "in your yaml file, then you probably should remove the last line.  The LogTag" << endl
                       << "\"" << *stag << "\" is not recognised by the logger system.  This commonly happens" << endl
                       << "if you try to redirect log output for a module that either doesn't exist, or was" << endl
                       << "ditched at cmake time." << endl;
              logging_error().raise(LOCAL_INFO,errormsg.str());
            }
            *this << *stag <<", ";
            tags.insert(newtag);
          }
          // Build the logger object
          StdLogger* newlogger;
          if(filename=="stdout")
          {
            newlogger = new StdLogger(std::cout);
          }
          else if(filename=="stderr")
          {
            newlogger = new StdLogger(std::cerr);
          }
          else
          {
            newlogger = new StdLogger(filename);
          }
          *this << "]; output is \"" << filename << "\"";
          loggers[tags] = newlogger;
       }
       *this << EOM; // End message about loggers.
       // Set logger objects ready for use and dump any buffered messages
       loggers_readyQ = true;
       empty_backlog();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

initialise() [2/3]

void Gambit::Logging::LogMaster::initialise

(

std::map< std::set< std::string >, std::string > &

loggerinfo

)

Definition at line 333 of file logmaster.cpp.

References initialise().

    {
       std::vector<std::pair< std::set<std::string>, std::string >> loggerinfo_vec;
       // Iterate through map and convert it to a vector of pairs
       for(std::map<std::set<std::string>, std::string>::iterator infopair = loggerinfo.begin();
            infopair != loggerinfo.end(); ++infopair)
       {
          loggerinfo_vec.push_back(std::make_pair(infopair->first,infopair->second));
       }
       // Run the 'normal' initialise function
       initialise(loggerinfo_vec);
    }

Here is the call graph for this function:

initialise() [3/3]

void Gambit::Logging::LogMaster::initialise

(

std::map< std::string, std::string > &

loggerinfo

)

Definition at line 347 of file logmaster.cpp.

References Gambit::Utils::delimiterSplit(), and initialise().

    {
      std::map<std::set<std::string>, std::string> loggerinfo_set;
      // Translate the string containing the tags into (map of) a set of tags
      for(std::map<std::string, std::string>::iterator infopair = loggerinfo.begin();
            infopair != loggerinfo.end(); ++infopair)
      {
        std::vector<std::string> tags_vec(Utils::delimiterSplit(infopair->first, ","));
        std::set<std::string> tags_set(tags_vec.begin(), tags_vec.end());
        loggerinfo_set[tags_set] = infopair->second;
      }
      // Run the 'normal' initialise function
      initialise(loggerinfo_set);
    }

Here is the call graph for this function:

input() [1/6]

void Gambit::Logging::LogMaster::input

(

const std::string &

in

)

Functions for stream input (actual stream operators which use these are defined in logger.cpp)

Handle strings.

Definition at line 671 of file logmaster.cpp.

References init_memory(), and stream.

Referenced by Gambit::Logging::operator<<().

    {
       init_memory();
       stream[omp_get_thread_num()] << in;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

input() [2/6]

void Gambit::Logging::LogMaster::input

(

const LogTag &

tag

)

Handle LogTag input.

Definition at line 652 of file logmaster.cpp.

References init_memory(), and streamtags.

    {
       init_memory();
       streamtags[omp_get_thread_num()].insert(tag);
    }

Here is the call graph for this function:

input() [3/6]

void Gambit::Logging::LogMaster::input

(

const endofmessage &

)

Handle end of message character.

Definition at line 659 of file logmaster.cpp.

References init_memory(), send(), stream, and streamtags.

    {
       init_memory();
       size_t i = omp_get_thread_num();
       // Collect the stream and tags, then send the message
       send(stream[i].str(), streamtags[i]);
       // Clear stream and tags for next message;
       stream[i].str(std::string()); //TODO: check that this works properly on all compilers...
       streamtags[i].clear();
    }

Here is the call graph for this function:

input() [4/6]

void Gambit::Logging::LogMaster::input

(

const manip1

fp

)

Handle various stream manipulators.

Definition at line 678 of file logmaster.cpp.

References init_memory(), and stream.

    {
       init_memory();
       stream[omp_get_thread_num()] << fp;
    }

Here is the call graph for this function:

input() [5/6]

void Gambit::Logging::LogMaster::input

(

const manip2

fp

)

Definition at line 684 of file logmaster.cpp.

References init_memory(), and stream.

    {
       init_memory();
       stream[omp_get_thread_num()] << fp;
    }

Here is the call graph for this function:

input() [6/6]

void Gambit::Logging::LogMaster::input

(

const manip3

fp

)

Definition at line 690 of file logmaster.cpp.

References init_memory(), and stream.

    {
       init_memory();
       stream[omp_get_thread_num()] << fp;
    }

Here is the call graph for this function:

leaving_backend()

void Gambit::Logging::LogMaster::leaving_backend

(

)

Definition at line 640 of file logmaster.cpp.

References current_backend, Gambit::LogTags::debug, Gambit::EOM, init_memory(), and Gambit::LogTags::logs.

Referenced by leaving_module(), Gambit::backend_functor< TYPE(*)(ARGS...), TYPE, ARGS... >::operator()(), Gambit::backend_functor< void(*)(ARGS...), void, ARGS... >::operator()(), Gambit::backend_functor< typename variadic_ptr< TYPE, ARGS... >::type, TYPE, ARGS... >::operator()(), and Gambit::backend_functor< typename variadic_ptr< void, ARGS... >::type, void, ARGS... >::operator()().

    {
       init_memory();
       int cb_test;
       cb_test = current_backend[omp_get_thread_num()];
       if (cb_test == -1) return;
       current_backend[omp_get_thread_num()] = -1;
       *this<<"Restoring current_backend="<<-1;
       *this<<logs<<debug<<EOM;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

leaving_module()

void Gambit::Logging::LogMaster::leaving_module

(

)

Definition at line 626 of file logmaster.cpp.

References current_module, init_memory(), and leaving_backend().

Referenced by Gambit::module_functor< ModelParameters >::calculate(), Gambit::module_functor< void >::calculate(), and Gambit::Likelihood_Container::main().

    {
       init_memory();
       current_module[omp_get_thread_num()] = -1;
       leaving_backend();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

send() [1/16]

void Gambit::Logging::LogMaster::send

(

const std::string &

message

)

Main logging function (user-friendly overloaded version)

Definition at line 407 of file logmaster.cpp.

Referenced by input(), and send().

    {
      std::set<LogTag> tags;
      send(message,tags);
    }

Here is the caller graph for this function:

send() [2/16]

void Gambit::Logging::LogMaster::send	(	const std::string &	message,
		LogTag	tag1
	)

Definition at line 413 of file logmaster.cpp.

References send().

    {
      std::set<LogTag> tags;
      tags.insert(tag1);
      send(message,tags);
    }

Here is the call graph for this function:

send() [3/16]

void Gambit::Logging::LogMaster::send	(	const std::string &	message,
		LogTag	tag1,
		LogTag	tag2
	)

Definition at line 420 of file logmaster.cpp.

References send().

    {
      std::set<LogTag> tags;
      tags.insert(tag1);
      tags.insert(tag2);
      send(message,tags);
    }

Here is the call graph for this function:

send() [4/16]

void Gambit::Logging::LogMaster::send	(	const std::string &	message,
		LogTag	tag1,
		LogTag	tag2,
		LogTag	tag3
	)

Definition at line 428 of file logmaster.cpp.

References send().

    {
      std::set<LogTag> tags;
      tags.insert(tag1);
      tags.insert(tag2);
      tags.insert(tag3);
      send(message,tags);
    }

Here is the call graph for this function:

send() [5/16]

void Gambit::Logging::LogMaster::send	(	const std::string &	message,
		LogTag	tag1,
		LogTag	tag2,
		LogTag	tag3,
		LogTag	tag4
	)

Definition at line 437 of file logmaster.cpp.

References send().

    {
      std::set<LogTag> tags;
      tags.insert(tag1);
      tags.insert(tag2);
      tags.insert(tag3);
      tags.insert(tag4);
      send(message,tags);
    }

Here is the call graph for this function:

send() [6/16]

void Gambit::Logging::LogMaster::send	(	const std::string &	message,
		LogTag	tag1,
		LogTag	tag2,
		LogTag	tag3,
		LogTag	tag4,
		LogTag	tag5
	)

Definition at line 447 of file logmaster.cpp.

References send().

    {
      std::set<LogTag> tags;
      tags.insert(tag1);
      tags.insert(tag2);
      tags.insert(tag3);
      tags.insert(tag4);
      tags.insert(tag5);
      send(message,tags);
    }

Here is the call graph for this function:

send() [7/16]

void Gambit::Logging::LogMaster::send

(

const std::ostringstream &

message

)

stringstream versions....

Definition at line 461 of file logmaster.cpp.

References send().

    {
      std::set<LogTag> tags;
      send(message.str(),tags);
    }

Here is the call graph for this function:

send() [8/16]

void Gambit::Logging::LogMaster::send	(	const std::ostringstream &	message,
		LogTag	tag1
	)

Definition at line 467 of file logmaster.cpp.

References send().

    {
      std::set<LogTag> tags;
      tags.insert(tag1);
      send(message.str(),tags);
    }

Here is the call graph for this function:

send() [9/16]

void Gambit::Logging::LogMaster::send	(	const std::ostringstream &	message,
		LogTag	tag1,
		LogTag	tag2
	)

Definition at line 474 of file logmaster.cpp.

References send().

    {
      std::set<LogTag> tags;
      tags.insert(tag1);
      tags.insert(tag2);
      send(message.str(),tags);
    }

Here is the call graph for this function:

send() [10/16]

void Gambit::Logging::LogMaster::send	(	const std::ostringstream &	message,
		LogTag	tag1,
		LogTag	tag2,
		LogTag	tag3
	)

Definition at line 482 of file logmaster.cpp.

References send().

    {
      std::set<LogTag> tags;
      tags.insert(tag1);
      tags.insert(tag2);
      tags.insert(tag3);
      send(message.str(),tags);
    }

Here is the call graph for this function:

send() [11/16]

void Gambit::Logging::LogMaster::send	(	const std::ostringstream &	message,
		LogTag	tag1,
		LogTag	tag2,
		LogTag	tag3,
		LogTag	tag4
	)

Definition at line 491 of file logmaster.cpp.

References send().

    {
      std::set<LogTag> tags;
      tags.insert(tag1);
      tags.insert(tag2);
      tags.insert(tag3);
      tags.insert(tag4);
      send(message.str(),tags);
    }

Here is the call graph for this function:

send() [12/16]

void Gambit::Logging::LogMaster::send	(	const std::ostringstream &	message,
		LogTag	tag1,
		LogTag	tag2,
		LogTag	tag3,
		LogTag	tag4,
		LogTag	tag5
	)

Definition at line 501 of file logmaster.cpp.

References send().

    {
      std::set<LogTag> tags;
      tags.insert(tag1);
      tags.insert(tag2);
      tags.insert(tag3);
      tags.insert(tag4);
      tags.insert(tag5);
      send(message.str(),tags);
    }

Here is the call graph for this function:

send() [13/16]

void Gambit::Logging::LogMaster::send	(	const std::string &	message,
		std::set< LogTag > &	tags
	)

Internal version of main logging function.

Definition at line 516 of file logmaster.cpp.

References send().

    {
      //std::set<int>& int_tags = static_cast< std::set<int> >(tags);
      // I cannot seem to get the static cast to work, so just copying for now:
      //std::set<int> int_tags(tags);
      // Gah that seems not to work for the same reason, do one by one:
      std::set<int> int_tags;
      for(std::set<LogTag>::iterator tag = tags.begin(); tag != tags.end(); ++tag)
      {
        int_tags.insert(*tag); //static_cast<int>(*tag));
      }
      send(message, int_tags);
    }

Here is the call graph for this function:

send() [14/16]

void Gambit::Logging::LogMaster::send	(	const std::string &	message,
		std::set< int > &	tags
	)

Serious version of main logging function.

Definition at line 533 of file logmaster.cpp.

References backlog, current_backend, current_module, Gambit::LogTags::def, empty_backlog(), finalsend(), and loggers_readyQ.

    {
       // LogMaster keeps an internal map of all the logging objects, where the keys are sets of 'LogTag's, constructed according to the inifile. So to figure out where the message has to go, we just compare the "tags" to these keys; if any of these keys are a subset of our tags, then we send the message to that LogHub.
       // Well almost. We have to seperate out the components first, because we can "send" a message to multiple components at once, but a direction command will never include two component tags (it is an error if it does).

       // Testing...
       //std::cout<<"msg: "<<message<<std::endl;

       // Preliminary stuff

       // Get thread number
       int i = omp_get_thread_num();

       // Automatically add the "def" (Default) tag so that the message definitely tries to go somewhere
       tags.insert(def);

       // Automatically add the tags for the "current" module and backend to the tags list
       if (current_module[i] != -1)
       {
         //std::cout<<"current_module="<<current_module<<"; adding tag "<<tag2str()[current_module]<<std::endl;
         tags.insert(current_module[i]);
       }
       if (current_backend[i] != -1)
       {
         //std::cout<<"current_backend="<<current_backend<<"; adding tag "<<tag2str()[current_backend]<<std::endl;
         tags.insert(current_backend[i]);
       }

       // If the loggers have not yet been initialised, buffer the message
       if(omp_get_level()!=0 or not loggers_readyQ)
       {
         backlog[i].emplace_back(message,tags); //time stamp automatically added NOW
       }
       else
       {
         if(omp_get_level()==0) empty_backlog();
         finalsend(Message(message,tags)); //time stamp automatically added NOW
       }
    } // end LogHub::send

Here is the call graph for this function:

send() [15/16]

void Gambit::Logging::LogMaster::send	(	const std::ostringstream &	message,
		std::set< LogTag > &	tags
	)

stringstream overloads...

Definition at line 610 of file logmaster.cpp.

References send().

    {
      send(message.str(), tags);
    }

Here is the call graph for this function:

send() [16/16]

void Gambit::Logging::LogMaster::send	(	const std::ostringstream &	message,
		std::set< int > &	tags
	)

Definition at line 615 of file logmaster.cpp.

References send().

    {
      send(message.str(), tags);
    }

Here is the call graph for this function:

set_log_debug_messages()

void Gambit::Logging::LogMaster::set_log_debug_messages ( bool  flag )

inline

Choose whether "Debug" tagged log messages will be ignored (i.e. not logged)

Setters for behaviour options Must be used before "initialise" in order to have any effect Choose whether a separate log file for each MPI process is used NOW FORBIDDEN! Always must be true to avoid concurrent write access issues void set_separate_file_per_process(bool flag) {separate_file_per_process=flag;}

Definition at line 138 of file logmaster.hpp.

References empty_backlog(), and log_debug_messages.

Referenced by Gambit::IniParser::Parser::basicParse(), and main().

{log_debug_messages=flag;}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

backlog

std::deque<Message>* Gambit::Logging::LogMaster::backlog

private

Messages sent before logger objects are created will be buffered Same for messages sent while inside omp parallel blocks.

Definition at line 183 of file logmaster.hpp.

Referenced by emit_backlog(), empty_backlog(), init_memory(), send(), and ~LogMaster().

current_backend

int* Gambit::Logging::LogMaster::current_backend

private

Definition at line 175 of file logmaster.hpp.

Referenced by entering_backend(), init_memory(), leaving_backend(), send(), and ~LogMaster().

current_module

int* Gambit::Logging::LogMaster::current_module

private

Variables that need to be threadsafe.

int current_function; Can generalise to this if we discover that we really want to...

Definition at line 174 of file logmaster.hpp.

Referenced by entering_module(), init_memory(), leaving_module(), send(), and ~LogMaster().

globlMaxThreads

int Gambit::Logging::LogMaster::globlMaxThreads

private

Max number of threads that could potentially be running.

Definition at line 169 of file logmaster.hpp.

Referenced by emit_backlog(), empty_backlog(), and init_memory().

ignore

std::set<int> Gambit::Logging::LogMaster::ignore

private

Global ignore set; if these tags/integers are seen, ignore messages containing them.

Definition at line 150 of file logmaster.hpp.

Referenced by finalsend(), and initialise().

log_debug_messages

bool Gambit::Logging::LogMaster::log_debug_messages

private

Flag to ignore Debug tagged messages.

Definition at line 162 of file logmaster.hpp.

Referenced by initialise(), and set_log_debug_messages().

loggers

std::map<std::set<int>,BaseLogger*> Gambit::Logging::LogMaster::loggers

private

Map to identify loggers.

Definition at line 147 of file logmaster.hpp.

Referenced by emit_backlog(), finalsend(), initialise(), and ~LogMaster().

loggers_readyQ

bool Gambit::Logging::LogMaster::loggers_readyQ

private

Flag to set whether loggers have been initialised not.

Definition at line 153 of file logmaster.hpp.

Referenced by disable(), emit_backlog(), initialise(), and send().

MPIrank

int Gambit::Logging::LogMaster::MPIrank

private

MPI variables.

Definition at line 165 of file logmaster.hpp.

Referenced by initialise().

MPIsize

int Gambit::Logging::LogMaster::MPIsize

private

Definition at line 166 of file logmaster.hpp.

Referenced by initialise().

separate_file_per_process

bool Gambit::Logging::LogMaster::separate_file_per_process

private

Flag to store log messages for different processes in separate files.

Definition at line 159 of file logmaster.hpp.

Referenced by initialise().

silenced

bool Gambit::Logging::LogMaster::silenced

private

Flag to silence logger.

Definition at line 156 of file logmaster.hpp.

Referenced by disable(), disabled(), enable(), finalsend(), and ~LogMaster().

stream

std::ostringstream* Gambit::Logging::LogMaster::stream

private

Buffer variables needed for stream logging.

Definition at line 178 of file logmaster.hpp.

Referenced by init_memory(), input(), and ~LogMaster().

streamtags

std::set<int>* Gambit::Logging::LogMaster::streamtags

private

Definition at line 179 of file logmaster.hpp.

Referenced by init_memory(), input(), and ~LogMaster().

---

The documentation for this class was generated from the following files:

• Logs/include/gambit/Logs/logmaster.hpp
• Logs/src/logmaster.cpp