thread.hpp

Go to the documentation of this file.

/* SPDX-License-Identifier: BSD-2-Clause */
 
/*
 * Copyright (C) 2020 Chris Johns (http://contemporary.software)
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. 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.
 *
 * 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 OWNER 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.
 */
 
#if !defined(RTEMS_THREAD_HPP)
#define RTEMS_THREAD_HPP
 
#include <functional>
#include <iostream>
#include <string>
#include <thread>
#include <utility>
 
namespace rtems
{
  namespace thread
  {
    class attributes
    {
    public:
      enum sched_attr {
        sched_inherit,    
        sched_explicit    
      };
 
      enum sched_policy {
        sched_other,      
        sched_fifo,       
        sched_roundrobin, 
        sched_sporadic    
      };
 
      attributes();
 
      /*
       * Copy construct the thread attributes.
       *
       * @param attr The attributes to copy.
       */
      attributes(const attributes& attr);
 
      void set_name(const std::string& name);
 
      void set_name(const char* name);
 
      const std::string& get_name() const;
 
      void set_priority(int priority);
 
      int get_priority() const;
 
      void set_stack_size(size_t size);
 
      size_t get_stack_size() const;
 
      void set_scheduler(const std::string& scheduler);
 
      void set_scheduler(const char* scheduler);
 
      const std::string& get_scheduler();
 
      sched_attr get_scheduler_attr() const;
 
      void set_scheduler_policy(sched_policy policy);
 
      sched_policy get_scheduler_policy() const;
 
      void commit();
 
      void update();
 
      attributes& operator=(const attributes& attr);
 
      bool operator==(const attributes& attr) const;
 
    private:
      std::string  name;        
      int          priority;    
      size_t       stack_size;  
      std::string  scheduler;   
      sched_attr   attr;        
      sched_policy policy;      
      /* affinity, cpu set size is? */
    };
 
    template <class T>
    inline typename std::decay<T>::type
    decay_copy(T&& t) {
      return std::forward<T>(t);
    }
 
    class thread
    {
      friend void* thread_generic_entry(void* arg);
 
      struct state_base
      {
        virtual ~state_base();
        virtual const attributes get_attributes() = 0;
        virtual void run() = 0;
      };
 
      using state_ptr = std::unique_ptr<state_base>;
 
    public:
 
      template <typename A, class DecayA = typename std::decay<A>::type>
      using enable_if_attributes = typename std::enable_if
        <std::is_same<DecayA, attributes>::value>::type;
 
      class id {
      public:
        id() noexcept : id_(0) { }
        explicit id(pthread_t id_) : id_(id_) { }
      private:
        pthread_t id_;
 
        friend class thread;
        friend bool operator==(thread::id l, thread::id r) noexcept;
 
        template<class CharT, class Traits>
        friend std::basic_ostream<CharT, Traits>&
        operator<<(std::basic_ostream<CharT, Traits>& out, thread::id id_);
      };
 
      thread() noexcept = default;
 
      template<typename F, typename... Args>
      explicit thread(F&& func, Args&&... args);
 
      template <typename A, typename F, typename ...Args,
                class = enable_if_attributes<A>>
      explicit thread(A&& attr, F&& func, Args&&... args)
        : id_(0) {
        start_thread(
          make_state(attr,
                     make_invoker(decay_copy(std::forward<F>(func)),
                                  decay_copy(std::forward<Args>(args))...))
        );
      }
 
      thread& operator=(thread&& thread_);
 
      void swap(thread& thread_) noexcept;
 
      bool joinable() const noexcept;
 
      void join();
 
      void detach();
 
      /*
       * Constrain use. These are not available.
       */
      thread(thread&) = delete;
      thread(const thread&) = delete;
      thread(const thread&&) = delete;
      thread& operator=(const thread&) = delete;
 
      std::thread::id get_id() const noexcept;
 
    private:
 
      id id_;
 
      template<typename Parms>
      struct invoker {
        Parms p;
 
        template<size_t Index>
        static std::__tuple_element_t<Index, Parms>&& declval();
 
        template<size_t... Ind>
        auto invoke(std::_Index_tuple<Ind...>)
          noexcept(noexcept(std::invoke(declval<Ind>()...)))
          -> decltype(std::invoke(declval<Ind>()...)) {
          return std::invoke(std::get<Ind>(std::move(p))...);
        }
 
        using indices =
          typename std::_Build_index_tuple<std::tuple_size<Parms>::value>::__type;
 
        void run() {
          invoke(indices());
        }
      };
 
      template<typename Invoker>
      struct state : state_base {
        const attributes attr;
        Invoker          i;
 
        state(const attributes& attr, Invoker&& i)
          : attr(attr),
            i(std::forward<Invoker>(i)) {
        }
 
        const attributes get_attributes() override {
          return attr;
        }
 
        void run() override {
          i.run();
        }
      };
 
      template<typename Invoker>
      static state_ptr
      make_state(const attributes& attr, Invoker&& i) {
        using state_impl = state<Invoker>;
        return state_ptr{ new state_impl(attr, std::forward<Invoker>(i)) };
      }
 
      template<typename... T>
      using decayed_tuple = std::tuple<typename std::decay<T>::type...>;
 
      template<typename F, typename... Args>
      static invoker<decayed_tuple<F, Args...>>
      make_invoker(F&& func, Args&&... args)
      {
        return {
          decayed_tuple<F, Args...> {
            std::forward<F>(func), std::forward<Args>(args)...
          }
        };
      }
 
      void start_thread(state_ptr s);
    };
 
    template<typename F, typename... Args>
    thread::thread(F&& func, Args&&... args)
      : id_(0)  {
      attributes attr;
      start_thread(
        make_state(attr,
                   make_invoker(decay_copy(std::forward<F>(func)),
                                decay_copy(std::forward<Args>(args))...))
      );
    }
 
    inline std::thread::id thread::get_id() const noexcept {
      return std::thread::id(id_.id_);
    }
 
    inline bool
    operator==(thread::id l, thread::id r) noexcept {
      return l.id_ == r.id_;
    }
 
    inline bool
    operator!=(thread::id l, thread::id r) noexcept {
      return !(l == r);
    }
 
    template<class C, class T>
    inline std::basic_ostream<C, T>&
    operator<<(std::basic_ostream<C, T>& out, thread::id id_) {
      return out << std::thread::id(id_.id_);
    }
  };
};
 
#endif