/home/rex/ebltrunk/tools/libeblearntools/include/job.h

/***************************************************************************
 *   Copyright (C) 2009 by Pierre Sermanet   *
 *   pierre.sermanet@gmail.com   *
 *   All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Redistribution under a license not approved by the Open Source 
 *       Initiative (http://www.opensource.org) must display the 
 *       following acknowledgement in all advertising material:
 *        This product includes software developed at the Courant
 *        Institute of Mathematical Sciences (http://cims.nyu.edu).
 *     * The names of the authors may not be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED 
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL ThE AUTHORS BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ***************************************************************************/

#ifndef JOB_H_
#define JOB_H_

#include "configuration.h"
#include "metaparser.h"
#include "utils.h"

#include <sstream>
#include <stdlib.h>
#include <stdio.h>

#ifndef __WINDOWS__
#include <sys/wait.h>
#include <unistd.h>
#endif

using namespace std;

namespace ebl {

  // job
  
  class EXPORT job {
  public:
    job(configuration &conf, const char *oconffname = NULL,
        bool resume = false);
    virtual ~job();

    virtual void run();

    virtual bool started();

    virtual bool write(bool reset_progress = false);

    virtual bool alive();

    virtual bool running();
    virtual int getpid();
    virtual string &name();
    virtual string shortname();

    virtual string get_root();
    virtual double minutes();
    virtual void force_started();
    virtual void reset_started();
    virtual string elapsed();
    virtual bool resumed();
    virtual bool finished();
    virtual int progress() const;

    // file-based resuming capabilities

    virtual bool declare_started();
    virtual bool declare_finished();
    virtual bool check_started();
    virtual bool check_running();
    virtual int check_progress();
    virtual bool check_finished();
    static void write_progress(uint i, uint total,
                               const char *additional = NULL,
                               const char *root = NULL);
    static string get_progress_filename(const char *root = NULL);
    static void write_finished(const char *root = NULL);
    virtual void figure_resume_from_weights(const char *dir = NULL);
    
  protected:
    virtual void run_child();
    virtual void figure_resume_out();

    // members
  protected:
    configuration       conf; 
    configuration       rconf; 
    string              exe;    
    string              outdir; 
    string              confname;       
    string              oconffname_;    
    timer               t;
    bool                _locally_started; 
    bool                _started; 
    bool                _running; 
    bool                _alive; 
    int                 pid;    
    bool                resumed_; 
    bool                _finished; 
    int                 _progress; 
    string              progress_fname; 
    string              finished_fname; 
  };

  EXPORT bool job_progress_cmp(const job *a, const job *b);

  // job manager

  class EXPORT job_manager {
  public:
    job_manager();

    virtual ~job_manager();

    virtual bool read_metaconf(const char *fname, const string *tstamp = NULL,
                               const char *resume_name = NULL, 
                               bool resumedir = false,
                               bool nomax = false, int maxjobs = -1);
    virtual void set_copy(const string &path);
    virtual void prepare(bool reset_progress = false);
    virtual void initialize_other(const string &other);
    virtual void run(bool force_start = false);
    virtual void monitor(const char *conffname);

  protected:

    virtual void release_dead_children();
    virtual void jobs_info();
    virtual void report();
    virtual void last_report();
    virtual list<string> *list_job_dirs(const char *conffname);

    // members
  protected:
    meta_configuration  mconf;     
    meta_configuration  rmconf;    
    string              mconf_fullfname;
    string              mconf_fname;    
    vector<job*>        jobs;      
    string              copy_path; 
    uint                max_jobs;  
    metaparser          parser;
    int                 maxiter;
    int                 maxiter_tmp;
    double              mintime;
    double              maxtime;
    uint                nalive;
    uint                nrunning;
    uint                unstarted;
    uint                finished;
    uint                unfinished;
    int                 ready_slots;
    ostringstream       infos;
    ostringstream       summary; 
    varmaplist          best; 
    varmaplist          besteach; 
    uint                swait; 
    timer               time; 
  };

} // end namespace ebl

#endif /* JOB_H_ */