Fleet.h

Go to the documentation of this file.

/* Globally shared variables and declarations */

#pragma once 

#include <sys/resource.h> // just for setting priority defaulty 
#include <unistd.h>
#include <stdlib.h>
#include <signal.h>

const std::string FLEET_VERSION = "0.0.98";

//#include "Statistics/FleetStatistics.h"

#include "Timing.h"
#include "Control.h"

// Thie one really should be included last because it depends on Primitves
// so we will include it here 
#include "VirtualMachine/applyPrimitives.h"


#include "FleetArgs.h"

unsigned long random_seed  = 0;

// This is global that checks whether CTRL_C has been pressed
// NOTE: this must be registered in main with signal(SIGINT, Fleet::fleet_interrupt_handler);
// which happens in 
volatile sig_atomic_t CTRL_C = false;

// apparently some OSes don't define this
#ifndef HOST_NAME_MAX
    const size_t HOST_NAME_MAX = 256;
#endif
char hostname[HOST_NAME_MAX];   

class Fleet {
public:
    CLI::App app;
    timept start_time;
    bool done; // if this is true, we don't call completed on destruction
    
    Fleet(std::string brief) : app{brief}, done(false) {

        app.add_option("--seed",        random_seed, "Seed the rng (0 is no seed)");
        app.add_option("--steps",       FleetArgs::steps, "Number of MCMC or MCTS search steps to run");
        app.add_option("--inner-steps", FleetArgs::inner_steps, "Steps to run inner loop of a search");
        app.add_option("--burn",        FleetArgs::burn, "Burn this many steps");
        app.add_option("--thin",        FleetArgs::thin, "Thinning on callbacks");
        app.add_option("--print",       FleetArgs::print, "Print out every this many");
        app.add_option("--top",         FleetArgs::ntop, "The number to store");
        app.add_option("-n,--threads",  FleetArgs::nthreads, "Number of threads for parallel search");
        app.add_option("--explore",     FleetArgs::explore, "Exploration parameter for MCTS");
        app.add_option("--restart",     FleetArgs::restart, "If we don't improve after this many, restart a chain");
        app.add_option("-c,--chains",   FleetArgs::nchains, "How many chains to run");
        
        app.add_option("--header",      FleetArgs::print_header, "Set to 0 to not print header");

        
        app.add_option("--output",      FleetArgs::output_path, "Where we write output");
        app.add_option("--input",       FleetArgs::input_path, "Read standard input from here");
        app.add_option("-T,--time",     FleetArgs::timestring, "Stop (via CTRL-C) after this much time (takes smhd as seconds/minutes/hour/day units)");
        app.add_option("--inner-time",  FleetArgs::inner_timestring, "Inner time");
        app.add_option("--tree",        FleetArgs::tree_path, "Write the tree here");
        
//      app.add_flag(  "-q,--quiet",    quiet, "Don't print very much and do so on one line");
//      app.add_flag(  "-C,--checkpoint",   checkpoint, "Checkpoint every this many steps");

        start_time = now();
        
    }
    
    virtual ~Fleet() {
        if(not done) completed();
    }
    


    static void fleet_interrupt_handler(int signum) { 
        if(signum == SIGINT) {
            CTRL_C = true; 
        }
        else if(signum == SIGHUP) {
            // do nothing -- defaultly Fleet mutes SIGHUP so that commands left in the terminal will continue
            // this is so that if we get disconnected on a terminal run, the job is maintained
        }   
    } 
    
    template<typename T> 
    void add_option(std::string c, T& var, std::string description ) {
        app.add_option(c, var, description);
    }
    template<typename T> 
    void add_flag(std::string c, T& var, std::string description ) {
        app.add_flag(c, var, description);
    }
        
    int initialize(int argc, char** argv) {
        CLI11_PARSE(app, argc, argv);
        
        // set our own handlers -- defaulty HUP won't stop
        signal(SIGINT, Fleet::fleet_interrupt_handler);
        signal(SIGHUP, Fleet::fleet_interrupt_handler);
        
        // give us a defaultly kinda nice niceness
        setpriority(PRIO_PROCESS, 0, 5);

        // set up the random seed:
        if(random_seed != 0) {
            rng.seed(random_seed);
        }
        
        // convert everything to ms
        FleetArgs::runtime = convert_time(FleetArgs::timestring);   
        FleetArgs::inner_runtime = convert_time(FleetArgs::inner_timestring);

        if(FleetArgs::print_header) {
            // Print standard fleet header
            gethostname(hostname, HOST_NAME_MAX);

            // and build the command to get the md5 checksum of myself
            char tmp[64]; sprintf(tmp, "md5sum /proc/%d/exe", getpid());
        
            COUT "# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" ENDL;
            COUT "# Running Fleet on " << hostname << " with PID=" << getpid() << " by user " << getenv("USER") << " at " <<  datestring() ENDL;
            COUT "# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" ENDL;
            COUT "# Fleet version: " << FLEET_VERSION ENDL;
            COUT "# Executable checksum: " << system_exec(tmp);
            COUT "# Run options: " ENDL;
            COUT "# \t --input=" << FleetArgs::input_path ENDL;
            COUT "# \t --threads=" << FleetArgs::nthreads ENDL;
            COUT "# \t --chains=" << FleetArgs::nchains ENDL;
            COUT "# \t --steps=" << FleetArgs::steps ENDL;
            COUT "# \t --inner_steps=" << FleetArgs::inner_steps ENDL;
            COUT "# \t --thin=" << FleetArgs::thin ENDL;
            COUT "# \t --print=" << FleetArgs::print ENDL;
            COUT "# \t --time=" << FleetArgs::timestring << " (" << FleetArgs::runtime << " ms)" ENDL;
            COUT "# \t --restart=" << FleetArgs::restart ENDL;
            COUT "# \t --seed=" << random_seed ENDL;
            COUT "# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" ENDL; 
            
        }
        
        // give warning for infinite runs:
        if(FleetArgs::steps == 0 and FleetArgs::runtime==0) {
            CERR "# Warning: you haven not specified --time or --mcmc so this will run forever or until CTRL-C." ENDL;
        }
        
        return 0;
    }
    
    
    void completed() {
        
        if(FleetArgs::print_header) {
            auto elapsed_seconds = time_since(start_time) / 1000.0;
            
            COUT "# Elapsed time:"        TAB elapsed_seconds << " seconds " ENDL;
            if(FleetStatistics::global_sample_count > 0) {
                COUT "# Samples per second:"  TAB FleetStatistics::global_sample_count/elapsed_seconds ENDL;
                COUT "# Global sample count:" TAB FleetStatistics::global_sample_count ENDL;
            }
            if(FleetStatistics::beam_steps > 0) {
                COUT "# Total Beam Search steps:" TAB FleetStatistics::beam_steps ENDL;
            }
            if(FleetStatistics::enumeration_steps > 0) {
                COUT "# Total enumeration steps:" TAB FleetStatistics::enumeration_steps ENDL;
            }       
            
            
            COUT "# Total posterior calls:" TAB FleetStatistics::posterior_calls ENDL;
            COUT "# VM ops per second:" TAB FleetStatistics::vm_ops/elapsed_seconds ENDL;
        }
        
        // setting this makes sure we won't call it again
        done = true;
        
        // HMM CANT DO THIS BC THERE MAY BE MORE THAN ONE TREE....
        //COUT "# MCTS tree size:" TAB m.size() ENDL;   
        //COUT "# Max score: " TAB maxscore ENDL;
        //COUT "# MCTS steps per second:" TAB m.statistics.N ENDL;  
    }
    
};