LoBaylogAnalyzer.C

/**
   \file  Robots/LoBot/control/LoBaylogAnalyzer.C
   \brief This file defines the non-inline member functions of the
   lobot::BaylogAnalyzer class.
*/

// //////////////////////////////////////////////////////////////////// //
// The iLab Neuromorphic Vision C++ Toolkit - Copyright (C) 2000-2005   //
// by the University of Southern California (USC) and the iLab at USC.  //
// See http://iLab.usc.edu for information about this project.          //
// //////////////////////////////////////////////////////////////////// //
// Major portions of the iLab Neuromorphic Vision Toolkit are protected //
// under the U.S. patent ``Computation of Intrinsic Perceptual Saliency //
// in Visual Environments, and Applications'' by Christof Koch and      //
// Laurent Itti, California Institute of Technology, 2001 (patent       //
// pending; application number 09/912,225 filed July 23, 2001; see      //
// http://pair.uspto.gov/cgi-bin/final/home.pl for current status).     //
// //////////////////////////////////////////////////////////////////// //
// This file is part of the iLab Neuromorphic Vision C++ Toolkit.       //
//                                                                      //
// The iLab Neuromorphic Vision C++ Toolkit 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 2 of the License, or (at your option) any later version.     //
//                                                                      //
// The iLab Neuromorphic Vision C++ Toolkit 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 the iLab Neuromorphic Vision C++ Toolkit; if not, write   //
// to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,   //
// Boston, MA 02111-1307 USA.                                           //
// //////////////////////////////////////////////////////////////////// //
//
// Primary maintainer for this file: mviswana usc edu
// $HeadURL: svn://isvn.usc.edu/software/invt/trunk/saliency/src/Robots/LoBot/baylog/LoBaylogAnalyzer.C $
// $Id: LoBaylogAnalyzer.C 14083 2010-09-30 13:59:37Z mviswana $
//

//------------------------------ HEADERS --------------------------------

// lobot headers
#include "Robots/LoBot/baylog/LoBaylogAnalyzer.H"
#include "Robots/LoBot/baylog/LoTTIMap.H"
#include "Robots/LoBot/baylog/LoDirList.H"

#include "Robots/LoBot/config/LoConfigHelpers.H"
#include "Robots/LoBot/thread/LoMutex.H"

#include "Robots/LoBot/util/LoFile.H"
#include "Robots/LoBot/util/LoString.H"

// DEVNOTE: We must supply the definition of YY_EXTRA_TYPE prior to
// including LoBaylogParser.H, which is generated by flex. Otherwise, the
// generated header will define YY_EXTRA_TYPE as void* and the linker
// will fail to find the lobay_parser_set_extra function, which will end
// up being declared in this module as taking a void* rather than a
// lobot::TTIMap* as it actually does.
//
// Moreover, we must include the flex-generated LoBaylogParser.H header
// after LoTTIMap.H. Otherwise, the lobot::TTIMap class will not be
// properly declared or defined and the compiler really detests that.
#define YY_EXTRA_TYPE lobot::TTIMap*
#include "Robots/LoBot/baylog/LoBaylogParser.H"

// Standard C++ headers
#include <iostream>
#include <fstream>
#include <string>
#include <algorithm>
#include <vector>

// Standard C headers
#include <stdio.h>

//-------------------------- KNOB TWIDDLING -----------------------------

namespace {

// Retrieve settings from global section of config file
template<typename T>
inline T conf(const std::string& key, const T& default_value)
{
   return lobot::global_conf<T>(key, default_value) ;
}

/// This inner class encapsulates various parameters that can be used to
/// tweak different aspects of the Bayesian TTI prediction analysis.
class AnalyzerParams : public lobot::singleton<AnalyzerParams> {
   /// Each dataset for the Bayesian time-to-impact prediction
   /// experiments consists of ten (or more) log files. This setting
   /// specifies a regular expression that defines the pattern for the
   /// names of these log files.
   std::string m_log_name ;

   /// Once all the log files for a dataset have been parsed, the results
   /// will be written to a file under the same directory as the
   /// dataset's log files with the name specified by this setting.
   std::string m_result_file ;

   /// Private constructor because this is a singleton.
   AnalyzerParams() ;

   // Boilerplate code to make generic singleton design pattern work
   friend class lobot::singleton<AnalyzerParams> ;

public:
   /// Accessing the various parameters.
   //@{
   static const std::string& log_name()    {return instance().m_log_name    ;}
   static const std::string& result_file() {return instance().m_result_file ;}
   //@}
} ;

// Parameters initialization
AnalyzerParams::AnalyzerParams()
   : m_log_name(conf<std::string>("log_file_name",
                                  "(metlog-[[:digit:]]{8}-[[:digit:]]{6})$")),
     m_result_file(conf<std::string>("result_file_name", "result"))
{}

// Shortcut
typedef AnalyzerParams Params ;

} // end of local anonymous namespace encapsulating above helpers

//----------------------------- NAMESPACE -------------------------------

namespace lobot {

//-------------------------- INITIALIZATION -----------------------------

BaylogAnalyzer* BaylogAnalyzer::create(const DirList& L)
{
   return new BaylogAnalyzer(L) ;
}

BaylogAnalyzer::BaylogAnalyzer(const DirList& L)
   : m_dirs(L)
{
   static int n ;
   static Mutex m ;

   AutoMutex M(m) ;
   start(std::string("lobay_analyzer_") + to_string(++n)) ;
}

//-------------------------- METLOG PARSING -----------------------------

// A helper function object for loading and parsing the log file for an
// individual experiment in a dataset.
namespace {

class process_log {
   std::string m_thread_name ;
   yyscan_t m_parser ;
public:
   process_log(const std::string& thread_name, yyscan_t parser) ;
   void operator()(const std::string& log_file_name) const ;
} ;

process_log::process_log(const std::string& thread_name, yyscan_t parser)
   : m_thread_name(thread_name), m_parser(parser)
{}

void process_log::operator()(const std::string& log_file_name) const
{
   FILE* file = fopen(log_file_name.c_str(), "r") ;
   if (! file) {
      std::cerr << m_thread_name << ": "
                << log_file_name << ": unable to open\n" ;
      return ;
   }

   lobay_parser_set_in(file, m_parser) ;
   lobay_parser_lex(m_parser) ;
   lobay_parser_set_in(stdin, m_parser) ;
   fclose(file) ;
}

} // end of local anonymous namespace encapsulating above helper

// This function analyzes a dataset and writes the results of the
// analysis to a file.
//
// Since the lobay program is designed to process multiple datasets in
// parallel, there will be multiple instances of this class, each one
// executing this function in a separate thread. All of them will use a
// shared lobot::DirList object to figure out which dataset to work on
// next and process the datasets specified therein one-by-one.
void BaylogAnalyzer::run()
{
   yyscan_t parser ;
   try
   {
      lobay_parser_lex_init(&parser) ;
      for(;;)
      {
         std::string dir = m_dirs.next() ;
         std::vector<std::string> logs = find_file(dir, Params::log_name()) ;

         TTIMap result ;
         lobay_parser_set_extra(&result, parser) ;
         std::for_each(logs.begin(), logs.end(),
                       process_log(Thread::name(), parser)) ;
         lobay_parser_set_extra(0, parser) ;

         std::string result_file_name = dir + "/" + Params::result_file() ;
         std::ofstream result_file(result_file_name.c_str()) ;
         result_file << result ;
      }
   }
   catch (DirList::eol&)
   {
      lobay_parser_lex_destroy(parser) ;
   }
}

//-----------------------------------------------------------------------

} // end of namespace encapsulating this file's definitions

/* So things look consistent in everyone's emacs... */
/* Local Variables: */
/* indent-tabs-mode: nil */
/* End: */