options.hpp

Go to the documentation of this file.

#ifndef GENESIS_UTILS_CORE_OPTIONS_H_
#define GENESIS_UTILS_CORE_OPTIONS_H_
 
/*
    Genesis - A toolkit for working with phylogenetic data.
    Copyright (C) 2014-2024 Lucas Czech
 
    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, or
    (at your option) any later version.
 
    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, see <http://www.gnu.org/licenses/>.
 
    Contact:
    Lucas Czech <lucas.czech@sund.ku.dk>
    University of Copenhagen, Globe Institute, Section for GeoGenetics
    Oster Voldgade 5-7, 1350 Copenhagen K, Denmark
*/
 
#include "genesis/utils/core/info.hpp"
#include "genesis/utils/threading/thread_pool.hpp"
 
#include <atomic>
#include <cassert>
#include <chrono>
#include <memory>
#include <random>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>
 
namespace genesis {
namespace utils {
 
// =================================================================================================
//     Options
// =================================================================================================
 
class Options
{
public:
 
    // -------------------------------------------------------------------------
    //     Instance
    // -------------------------------------------------------------------------
 
    inline static Options& get()
    {
        // Meyers-Singleton
        static Options instance;
        return instance;
    }
 
    // -------------------------------------------------------------------------
    //     Command Line
    // -------------------------------------------------------------------------
 
    inline std::vector<std::string> const& command_line() const
    {
        return command_line_;
    }
 
    std::string command_line_string() const
    {
        std::string ret = "";
        for (size_t i = 0; i < command_line_.size(); ++i) {
            std::string a = command_line_[i];
            ret += (i==0 ? "" : " ") + a;
        }
        return ret;
    }
 
    void command_line( int const argc, char const* const* argv )
    {
        // Store all arguments in the array.
        command_line_.clear();
        for (int i = 0; i < argc; i++) {
            command_line_.push_back(argv[i]);
        }
    }
 
    // -------------------------------------------------------------------------
    //     Random Seed & Engine
    // -------------------------------------------------------------------------
 
    inline unsigned long random_seed() const
    {
        return random_seed_;
    }
 
    inline void random_seed( unsigned long const seed )
    {
        if( thread_pool_ ) {
            throw std::domain_error(
                "Cannot re-seed global random engine after having spawned the global thread pool, "
                "as the threads would not be aware of the re-seeding. "
                "Call Options::get().random_seed() before Options::get().init_global_thread_pool() "
                "to fix this."
            );
        }
        random_seed_ = seed;
        thread_local_random_engine_().seed( seed );
    }
 
    inline std::default_random_engine& random_engine()
    {
        return thread_local_random_engine_();
    }
 
    inline size_t seed_counter() const
    {
        return seed_counter_.load();
    }
 
private:
 
    inline unsigned long generate_thread_seed_()
    {
        return random_seed_ + seed_counter_.fetch_add( 1, std::memory_order_relaxed );
    }
 
    inline std::default_random_engine& thread_local_random_engine_()
    {
        // Private method to access the thread-local engine
        thread_local std::default_random_engine engine( generate_thread_seed_() );
        return engine;
    }
 
public:
 
    // -------------------------------------------------------------------------
    //     Global Thread Pool
    // -------------------------------------------------------------------------
 
    void init_global_thread_pool()
    {
        // Automatic guessing of the correct number of threads.
        // We then reduce it by one to account for the main thread doing work as well.
        auto const num_threads = guess_number_of_threads();
        assert( num_threads > 0 );
        if( num_threads == 0 ) {
            init_global_thread_pool( 0 );
        } else {
            init_global_thread_pool( num_threads - 1 );
        }
    }
 
    void init_global_thread_pool( size_t num_threads, size_t max_queue_size = 0 )
    {
        if( thread_pool_ ) {
            throw std::runtime_error(
                "Global thread pool has already been initialized. "
                "Cannot call Options::get().init_global_thread_pool() multiple times."
            );
        }
        thread_pool_ = std::make_shared<utils::ThreadPool>( num_threads, max_queue_size );
    }
 
    std::shared_ptr<ThreadPool> global_thread_pool() const
    {
        if( ! thread_pool_ ) {
            throw std::runtime_error(
                "Global thread pool has not been initialized. "
                "Call Options::get().init_global_thread_pool() first."
            );
        }
        return thread_pool_;
    }
 
    size_t global_thread_pool_size() const
    {
        if( ! thread_pool_ ) {
            return 1;
        }
        return thread_pool_->size() + 1;
    }
 
    // -------------------------------------------------------------------------
    //     Input Reader Threads
    // -------------------------------------------------------------------------
 
    enum class InputReadingThreadPolicy
    {
        kStrict,
 
        kTrivialAsync,
 
        kAllAsync
    };
 
    inline void input_reading_thread_policy( InputReadingThreadPolicy policy )
    {
        input_reading_thread_policy_ = policy;
    }
 
    inline InputReadingThreadPolicy input_reading_thread_policy()
    {
        return input_reading_thread_policy_;
    }
 
    // -------------------------------------------------------------------------
    //     File Output
    // -------------------------------------------------------------------------
 
    inline bool allow_file_overwriting() const
    {
        return allow_file_overwriting_;
    }
 
    inline void allow_file_overwriting( bool value )
    {
        allow_file_overwriting_ = value;
    }
 
    // -------------------------------------------------------------------------
    //     Data Members
    // -------------------------------------------------------------------------
 
private:
 
    // CLI
    std::vector<std::string> command_line_;
 
    // Random engine seeding
    unsigned long random_seed_;
    std::atomic<size_t> seed_counter_{0};
 
    // Global thread pool
    std::shared_ptr<ThreadPool> thread_pool_;
    InputReadingThreadPolicy input_reading_thread_policy_ = InputReadingThreadPolicy::kTrivialAsync;
 
    // File handling
    bool allow_file_overwriting_ = false;
 
    // -------------------------------------------------------------------------
    //     Hidden Class Members
    // -------------------------------------------------------------------------
 
private:
 
    // Everything private, as it is a singleton.
 
    Options()
    {
        // Initialize random seed with time.
        random_seed( std::chrono::system_clock::now().time_since_epoch().count() );
    }
 
    ~Options() = default;
 
    Options( const Options& ) = delete;
    Options( Options&& )      = delete;
    Options& operator= ( const Options& ) = delete;
    Options& operator= ( Options&& )      = delete;
 
};
 
} // namespace utils
} // namespace genesis
 
#endif // include guard