process.h

Go to the documentation of this file.

/*
 *  Copyright (c) 2000-2022 Inria
 *  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.
 *  * Neither the name of the ALICE Project-Team nor the names of its
 *  contributors may be used to endorse or promote products derived from this
 *  software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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.
 *
 *  Contact: Bruno Levy
 *
 *     https://www.inria.fr/fr/bruno-levy
 *
 *     Inria,
 *     Domaine de Voluceau,
 *     78150 Le Chesnay - Rocquencourt
 *     FRANCE
 *
 */
 
#ifndef GEOGRAM_BASIC_PROCESS
#define GEOGRAM_BASIC_PROCESS
 
#include <geogram/basic/common.h>
#include <geogram/basic/thread_sync.h>
#include <geogram/basic/counted.h>
#include <geogram/basic/smart_pointer.h>
#include <functional>
 
namespace GEO {
 
    class GEOGRAM_API Thread : public Counted {
    public:
 
        Thread() : id_(0) {
        }
 
        virtual void run() = 0;
 
        index_t id() const {
            return id_;
        }
 
        static Thread* current();
 
        static index_t current_id() {
            return current() == nullptr ? 0 : current()->id();
        }
 
    protected:
        ~Thread() override;
 
 
    private:
        void set_id(index_t id_in) {
            id_ = id_in;
        }
 
        static void set_current(Thread* thread);
 
        index_t id_;
 
        // ThreadManager needs to access set_current() and
        // set_id().
        friend class ThreadManager;
    };
 
    typedef SmartPointer<Thread> Thread_var;
 
    typedef std::vector<Thread_var> ThreadGroup;
 
    template <class THREAD>
    class TypedThreadGroup : public ThreadGroup {
    public:
        TypedThreadGroup() {
        }
 
        THREAD* operator[] (index_t i) {
            geo_debug_assert(i < size());
            Thread* result = ThreadGroup::operator[] (i);
            return static_cast<THREAD*>(result);
        }
    };
 
    class GEOGRAM_API ThreadManager : public Counted {
    public:
        virtual void run_threads(ThreadGroup& threads);
 
        virtual index_t maximum_concurrent_threads() = 0;
 
    protected:
        virtual void run_concurrent_threads(
            ThreadGroup& threads, index_t max_threads
        ) = 0;
 
 
        static void set_thread_id(Thread* thread, index_t id) {
            thread->set_id(id);
        }
 
        static void set_current_thread(Thread* thread) {
            Thread::set_current(thread);
        }
 
        ~ThreadManager() override;
    };
 
    typedef SmartPointer<ThreadManager> ThreadManager_var;
 
    class GEOGRAM_API MonoThreadingThreadManager : public ThreadManager {
    public:
        index_t maximum_concurrent_threads() override;
 
    protected:
        ~MonoThreadingThreadManager() override;
 
        void run_concurrent_threads(
            ThreadGroup& threads, index_t max_threads
        ) override;
    };
 
    namespace Process {
 
        void GEOGRAM_API initialize(int flags);
 
        void GEOGRAM_API terminate();
 
 
        void GEOGRAM_API sleep(index_t microseconds);
 
        void GEOGRAM_API show_stats();
 
        void GEOGRAM_API brute_force_kill();
 
        index_t GEOGRAM_API maximum_concurrent_threads();
 
        void GEOGRAM_API run_threads(ThreadGroup& threads);
 
        index_t GEOGRAM_API number_of_cores();
 
        void GEOGRAM_API set_thread_manager(ThreadManager* thread_manager);
 
        bool GEOGRAM_API is_running_threads();
 
        void GEOGRAM_API enable_FPE(bool flag);
 
        bool GEOGRAM_API FPE_enabled();
 
        void GEOGRAM_API enable_multithreading(bool flag);
 
        bool GEOGRAM_API multithreading_enabled();
 
        void GEOGRAM_API set_max_threads(index_t num_threads);
 
        index_t GEOGRAM_API max_threads();
 
        void GEOGRAM_API enable_cancel(bool flag);
 
        bool GEOGRAM_API cancel_enabled();
 
        size_t GEOGRAM_API used_memory();
 
        size_t GEOGRAM_API max_used_memory();
 
        std::string GEOGRAM_API executable_filename();
 
        void print_stack_trace();
    }
 
    void GEOGRAM_API parallel_for(
        index_t from, index_t to, std::function<void(index_t)> func,
        index_t threads_per_core = 1,
        bool interleaved = false
    );
 
    void GEOGRAM_API parallel_for_slice(
        index_t from, index_t to, std::function<void(index_t, index_t)> func,
        index_t threads_per_core = 1
    );
 
    void GEOGRAM_API parallel(
        std::function<void()> f1,
        std::function<void()> f2
    );
 
    void GEOGRAM_API parallel(
        std::function<void()> f1,
        std::function<void()> f2,
        std::function<void()> f3,
        std::function<void()> f4
    );
 
    void GEOGRAM_API parallel(
        std::function<void()> f1,
        std::function<void()> f2,
        std::function<void()> f3,
        std::function<void()> f4,
        std::function<void()> f5,
        std::function<void()> f6,
        std::function<void()> f7,
        std::function<void()> f8
    );
 
}
 
#endif