Fleet.h

Go to the documentation of this file.

#pragma once 

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

// For macs:
#ifdef __APPLE__
    #include <sys/syslimits.h> // used to get PATH_MAX
    #include <mach-o/dyld.h> // dynamic link editor with method to get executable path
#endif


const std::string FLEET_VERSION = "0.1.4";

#include "Random.h"
#include "Timing.h"
#include "Control.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);
//volatile sig_atomic_t CTRL_C = false;
std::atomic<bool> 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];   

// store the main thread id if we want it
std::thread::id main_thread_id = std::this_thread::get_id();

#include "FleetStatistics.h"

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("-S,--seed",      random_seed, "Seed the rng (0 is no seed)");
        app.add_option("-s,--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("-p,--print",     FleetArgs::print, "Print out every this many");
        app.add_option("-t,--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("--ct",           FleetArgs::chainsthreads, "Specify chains and threads at the same time");
        
        app.add_option("--partition-depth",   FleetArgs::partition_depth, "How deep do we recurse when we do partition-mcmc?");
                
        app.add_option("-o,--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-restart",  FleetArgs::inner_restart, "Inner restart");
        app.add_option("--inner-time",     FleetArgs::inner_timestring, "Inner time");
        app.add_option("--inner-thin",     FleetArgs::inner_thin, "Inner thinning");
        app.add_option("--tree",           FleetArgs::tree_path, "Write the tree here");

        app.add_option("--omp-threads",    FleetArgs::omp_threads, "How many threads to run with OMP");
        
        app.add_option("--header",         FleetArgs::print_header, "Set to 0 to not print header");
                
        app.add_flag("--top-print-best",   FleetArgs::top_print_best, "Should all tops defaultly print their best?");
        app.add_flag("--print-proposals",  FleetArgs::print_proposals, "Should we print out proposals?");
        
//      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();
        
        // now if we are running MPI
//      #ifdef FLEET_MPI
        
//      #endif
        
    }
    
    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);
        app.parse(argc, argv); // parse here -- and DO NOT catch exit codes (unlike the macro above)
                               // if we catch exit codes, we silently keep running without parsing...
        
        // set our own handlers -- defaulty HUP won't stop
        std::signal(SIGINT, Fleet::fleet_interrupt_handler);
        std::signal(SIGHUP, Fleet::fleet_interrupt_handler);
        
        // give us a defaultly kinda nice niceness
        setpriority(PRIO_PROCESS, 0, 5);
        
        // convert everything to ms
        FleetArgs::runtime = convert_time(FleetArgs::timestring);   
        FleetArgs::inner_runtime = convert_time(FleetArgs::inner_timestring);


        // 
        if( FleetArgs::chainsthreads != 0) {
            assert((FleetArgs::nchains == 1 and FleetArgs::nthreads==1) && "*** Cannot specify chains or threads with --ct");
            FleetArgs::nchains  = FleetArgs::chainsthreads;
            FleetArgs::nthreads = FleetArgs::chainsthreads;
        }

        // seed the rng
        DefaultRNG.seed(random_seed);

        if(FleetArgs::print_header) {
            // Print standard fleet header
            gethostname(hostname, HOST_NAME_MAX);
            
            #ifdef __APPLE__
                 char path[PATH_MAX+1]; 
                uint32_t size = sizeof(path); 
                _NSGetExecutablePath(path, &size); 
                char tmp[128]; sprintf(tmp, "md5sum %s", path);
            #else 
            
                // and build the command to get the md5 checksum of myself
                char tmp[128]; sprintf(tmp, "md5sum /proc/%d/exe", getpid());
            #endif
                
            std::filesystem::path cwd = std::filesystem::current_path();
            std::string exc = system_exec(tmp); exc.erase(exc.length()-1); // came with a newline?
            
            print("# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
            print("# Running Fleet on " +  std::string(hostname) + " with PID=" + str(getpid()) + " by user " + getenv("USER") + " at " + datestring());
            print("# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
            print("# Fleet version: ", FLEET_VERSION);
            print("# Executable checksum: ", exc);
            print("# Path:", cwd.string() );
            print("# Run options: ");
            for(int a=0;a<argc;a++) {
                print("#\t", argv[a]);
            }
            print("# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");    
            
        }
        
        // give warning for infinite runs:
        if(FleetArgs::steps == 0 and FleetArgs::runtime==0) {
            CERR "# Warning: you haven not specified --time or --steps 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;
            }       
            if(FleetStatistics::depth_exceptions > 0){
                COUT "# Warning: " TAB FleetStatistics::depth_exceptions TAB " grammar depth exceptions." ENDL;
            }
            
            COUT "# Total posterior calls:" TAB FleetStatistics::posterior_calls ENDL;
            COUT "# Millions of VM ops per second:" TAB (FleetStatistics::vm_ops/1000000)/elapsed_seconds ENDL;
            
            COUT "# Fleet completed at " <<  datestring() 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;  
    }
    
};