145 lines
4.1 KiB
C++
145 lines
4.1 KiB
C++
/*
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
*
|
|
* Copyright 2019 Danny Robson <danny@nerdcruft.net>
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include "../win32/handle.hpp"
|
|
#include "../win32/windows.hpp"
|
|
#include "../win32/except.hpp"
|
|
|
|
#include <chrono>
|
|
|
|
namespace cruft::thread {
|
|
inline namespace win32 {
|
|
namespace detail {
|
|
template <class T>
|
|
std::decay_t<T>
|
|
decay_copy (T&& v)
|
|
{
|
|
return std::forward<T>(v);
|
|
}
|
|
|
|
|
|
template <typename FunctionT, typename ...ArgsT>
|
|
class dispatcher {
|
|
public:
|
|
dispatcher (FunctionT &&func, ArgsT &&...args)
|
|
: m_func (std::forward<FunctionT> (func))
|
|
, m_args (std::forward<ArgsT> (args)...)
|
|
{ ; }
|
|
|
|
void run (void)
|
|
{
|
|
return _run (
|
|
std::make_index_sequence<sizeof...(ArgsT)> {}
|
|
);
|
|
}
|
|
|
|
private:
|
|
template <std::size_t... S>
|
|
void _run (std::index_sequence <S...>)
|
|
{
|
|
std::invoke (
|
|
decay_copy (std::forward<FunctionT> (m_func)),
|
|
decay_copy (std::forward<ArgsT> (std::get<S> (m_args)))...
|
|
);
|
|
}
|
|
|
|
FunctionT m_func;
|
|
std::tuple<ArgsT...> m_args;
|
|
};
|
|
|
|
template <typename DispatcherT>
|
|
DWORD WINAPI run (LPVOID arg)
|
|
{
|
|
auto *obj = reinterpret_cast<DispatcherT*> (arg);
|
|
|
|
try {
|
|
obj->run ();
|
|
return 0;
|
|
} catch (...) {
|
|
delete obj;
|
|
throw;
|
|
}
|
|
}
|
|
};
|
|
|
|
struct thread {
|
|
using id = ::cruft::win32::handle::native_type;
|
|
|
|
thread () noexcept;
|
|
thread (thread &&) noexcept;
|
|
|
|
template <typename FunctionT, typename... ArgsT>
|
|
thread (FunctionT &&func, ArgsT&&...args)
|
|
{
|
|
using dispatch_t = detail::dispatcher<FunctionT,ArgsT...>;
|
|
|
|
auto data = std::make_unique<dispatch_t> (
|
|
std::forward<FunctionT> (func),
|
|
std::forward<ArgsT> (args)...
|
|
);
|
|
|
|
m_handle.reset (
|
|
CreateThread (
|
|
nullptr, 0,
|
|
detail::run<dispatch_t>,
|
|
static_cast<void*> (data.get ()),
|
|
0,
|
|
nullptr
|
|
)
|
|
);
|
|
|
|
if (!m_handle)
|
|
throw std::system_error (
|
|
cruft::win32::error::last_code (),
|
|
std::generic_category ()
|
|
);
|
|
|
|
data.release ();
|
|
}
|
|
|
|
|
|
thread (thread const&) = delete;
|
|
|
|
thread& operator= (thread&&) noexcept;
|
|
|
|
void join (void);
|
|
|
|
static unsigned int hardware_concurrency () noexcept;
|
|
|
|
private:
|
|
::cruft::win32::handle m_handle;
|
|
};
|
|
|
|
namespace this_thread {
|
|
void yield (void) noexcept;
|
|
|
|
thread::id get_id (void) noexcept;
|
|
|
|
template <class Rep, class Period>
|
|
void sleep_for (
|
|
std::chrono::duration<Rep, Period> const& sleep_duration
|
|
) {
|
|
auto remain = std::chrono::duration_cast<std::chrono::milliseconds> (
|
|
sleep_duration
|
|
).count ();
|
|
|
|
while (remain > 0) {
|
|
auto const step = cruft::min (remain, INFINITE - 1);
|
|
Sleep (remain);
|
|
remain -= step;
|
|
}
|
|
}
|
|
|
|
template <class Clock, class Duration>
|
|
void sleep_until (std::chrono::time_point<Clock,Duration> const& sleep_time);
|
|
}
|
|
};
|
|
}
|