log_time_interval.hpp

Go to the documentation of this file.

/*************************************************************************
 * Copyright (C) 2011 by Saleh Dindar and the Swarm-NG Development Team  *
 *                                                                       *
 * 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.        *
 *                                                                       *
 * 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, write to the                         *
 * Free Software Foundation, Inc.,                                       *
 * 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ************************************************************************/

#pragma once

namespace swarm {
  namespace monitors {

struct log_time_interval_params {
        double time_interval;
  //        bool log_on;
        log_time_interval_params(const config &cfg)
        {
                time_interval = cfg.require("log_interval", 0.0);
                //              log_on = cfg.optional("log_on_interval",true);
        }
};

template<class log_t>
class log_time_interval {
        public:
        typedef log_time_interval_params params;

        private:
        params _params;
        bool condition_met;

        ensemble::SystemRef& _sys;
        double _next_log_time;
        log_t& _log;

        public:
                template<class T>
                static GENERIC int thread_per_system(T compile_time_param){
                        return 1;
                }

                template<class T>
                static GENERIC int shmem_per_system(T compile_time_param) {
                         return 0;
                }
        GPUAPI bool is_deactivate_on() { return false; };
  //        GPUAPI bool is_log_on() { return _params.log_on; };
        GPUAPI bool is_log_on() { return _params.time_interval!=0.; };
        GPUAPI bool is_verbose_on() { return false; };
        GPUAPI bool is_any_on() { return is_deactivate_on() || is_log_on() || is_verbose_on() ; }
        GPUAPI bool is_condition_met () { return ( condition_met ); }
        GPUAPI bool need_to_log_system () 
          { return (is_log_on() && is_condition_met() ); }
        GPUAPI bool need_to_deactivate () 
          { return ( is_deactivate_on() && is_condition_met() ); }

        GPUAPI void log_system()  {  log::system(_log, _sys);  }
        
        GPUAPI void operator () (const int thread_in_system) 
          { 
            pass_one(thread_in_system);
            pass_two(thread_in_system);
            if(need_to_log_system() && (thread_in_system==0) )
              log_system();
          }

        GPUAPI bool pass_one (int thread_in_system) 
          {
            condition_met = false;
            if(is_log_on())
              {
                if(thread_in_system == 0 && _sys.time() >= _next_log_time )  
                  {
                    condition_met = true; 
                    _next_log_time += _params.time_interval; 
                    //lprintf(_log,"Logging at %lg\n",_sys.time());
                  }
              }
            return condition_met;
          }
            

        GPUAPI int pass_two (int thread_in_system) 
          {   return _sys.state();  }


        GPUAPI log_time_interval(const params& p,ensemble::SystemRef& s,log_t& l)
                :_params(p),_sys(s),_log(l),_next_log_time(s.time()){}
        
};

}


}