settings.hpp

/* Copyright 2009-2017 Francesco Biscani (bluescarni@gmail.com)

This file is part of the Piranha library.

The Piranha library is free software; you can redistribute it and/or modify
it under the terms of either:

  * the GNU Lesser General Public License as published by the Free
    Software Foundation; either version 3 of the License, or (at your
    option) any later version.

or

  * 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.

or both in parallel, as here.

The Piranha library 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 copies of the GNU General Public License and the
GNU Lesser General Public License along with the Piranha library.  If not,
see https://www.gnu.org/licenses/. */

#ifndef PIRANHA_SETTINGS_HPP
#define PIRANHA_SETTINGS_HPP

#include <atomic>
#include <mutex>
#include <stdexcept>

#include <piranha/config.hpp>
#include <piranha/exceptions.hpp>
#include <piranha/runtime_info.hpp>
#include <piranha/thread_pool.hpp>

namespace piranha
{

namespace detail
{

template <typename = int>
struct base_settings {
    static std::mutex m_mutex;
    static unsigned m_cache_line_size;
    static unsigned long m_max_term_output;
    static const unsigned long m_default_max_term_output = 20ul;
    static std::atomic_ullong s_min_work_per_thread;
    // NOTE: this corresponds to circa 2% overhead from thread management on a common desktop
    // machine around 2012 for the fastest series multiplication scenario.
    static const unsigned long long s_default_min_work_per_thread = 250000ull;
};

template <typename T>
std::mutex base_settings<T>::m_mutex;

template <typename T>
unsigned base_settings<T>::m_cache_line_size = runtime_info::get_cache_line_size();

template <typename T>
unsigned long base_settings<T>::m_max_term_output = base_settings<T>::m_default_max_term_output;

template <typename T>
const unsigned long base_settings<T>::m_default_max_term_output;

template <typename T>
const unsigned long long base_settings<T>::s_default_min_work_per_thread;

template <typename T>
std::atomic_ullong base_settings<T>::s_min_work_per_thread(base_settings<T>::s_default_min_work_per_thread);
}


template <typename = void>
class settings_ : private detail::base_settings<>
{
public:

    static unsigned get_n_threads()
    {
        return thread_pool::size();
    }

    static void set_n_threads(unsigned n)
    {
        thread_pool::resize(n);
    }

    static void reset_n_threads()
    {
        const auto candidate = runtime_info::get_hardware_concurrency();
        set_n_threads((candidate > 0u) ? candidate : 1u);
    }

    static void set_thread_binding(bool flag)
    {
        thread_pool::set_binding(flag);
    }

    static bool get_thread_binding()
    {
        return thread_pool::get_binding();
    }

    static unsigned get_cache_line_size()
    {
        std::lock_guard<std::mutex> lock(m_mutex);
        return m_cache_line_size;
    }

    static void set_cache_line_size(unsigned n)
    {
        std::lock_guard<std::mutex> lock(m_mutex);
        m_cache_line_size = n;
    }

    static void reset_cache_line_size()
    {
        std::lock_guard<std::mutex> lock(m_mutex);
        m_cache_line_size = runtime_info::get_cache_line_size();
    }

    static unsigned long get_max_term_output()
    {
        std::lock_guard<std::mutex> lock(m_mutex);
        return m_max_term_output;
    }

    static void set_max_term_output(unsigned long n)
    {
        std::lock_guard<std::mutex> lock(m_mutex);
        m_max_term_output = n;
    }

    static void reset_max_term_output()
    {
        std::lock_guard<std::mutex> lock(m_mutex);
        m_max_term_output = m_default_max_term_output;
    }

    static unsigned long long get_min_work_per_thread()
    {
        return s_min_work_per_thread.load();
    }

    static void set_min_work_per_thread(unsigned long long n)
    {
        if (unlikely(n == 0u)) {
            piranha_throw(std::invalid_argument, "the minimum work per thread value must be strictly positive");
        }
        return s_min_work_per_thread.store(n);
    }

    static void reset_min_work_per_thread()
    {
        s_min_work_per_thread.store(s_default_min_work_per_thread);
    }
};


using settings = settings_<>;
}

#endif