1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-27 02:47:35 +00:00

Userland: Rename LibThread => LibThreading

Also rename the "LibThread" namespace to "Threading"
This commit is contained in:
Andreas Kling 2021-05-22 18:47:42 +02:00
parent 5729b4e9a5
commit b5d73c834f
25 changed files with 69 additions and 69 deletions

View file

@ -0,0 +1,54 @@
/*
* Copyright (c) 2019-2020, Sergey Bugaev <bugaevc@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <AK/Queue.h>
#include <LibThreading/BackgroundAction.h>
#include <LibThreading/Lock.h>
#include <LibThreading/Thread.h>
static Threading::Lockable<Queue<Function<void()>>>* s_all_actions;
static Threading::Thread* s_background_thread;
static intptr_t background_thread_func()
{
while (true) {
Function<void()> work_item;
{
Threading::Locker locker(s_all_actions->lock());
if (!s_all_actions->resource().is_empty())
work_item = s_all_actions->resource().dequeue();
}
if (work_item)
work_item();
else
sleep(1);
}
VERIFY_NOT_REACHED();
}
static void init()
{
s_all_actions = new Threading::Lockable<Queue<Function<void()>>>();
s_background_thread = &Threading::Thread::construct(background_thread_func).leak_ref();
s_background_thread->set_name("Background thread");
s_background_thread->start();
}
Threading::Lockable<Queue<Function<void()>>>& Threading::BackgroundActionBase::all_actions()
{
if (s_all_actions == nullptr)
init();
return *s_all_actions;
}
Threading::Thread& Threading::BackgroundActionBase::background_thread()
{
if (s_background_thread == nullptr)
init();
return *s_background_thread;
}

View file

@ -0,0 +1,77 @@
/*
* Copyright (c) 2019-2020, Sergey Bugaev <bugaevc@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <AK/Function.h>
#include <AK/NonnullRefPtr.h>
#include <AK/Optional.h>
#include <AK/Queue.h>
#include <LibCore/Event.h>
#include <LibCore/EventLoop.h>
#include <LibCore/Object.h>
#include <LibThreading/Lock.h>
#include <LibThreading/Thread.h>
namespace Threading {
template<typename Result>
class BackgroundAction;
class BackgroundActionBase {
template<typename Result>
friend class BackgroundAction;
private:
BackgroundActionBase() { }
static Lockable<Queue<Function<void()>>>& all_actions();
static Thread& background_thread();
};
template<typename Result>
class BackgroundAction final : public Core::Object
, private BackgroundActionBase {
C_OBJECT(BackgroundAction);
public:
static NonnullRefPtr<BackgroundAction<Result>> create(
Function<Result()> action,
Function<void(Result)> on_complete = nullptr)
{
return adopt_ref(*new BackgroundAction(move(action), move(on_complete)));
}
virtual ~BackgroundAction() { }
private:
BackgroundAction(Function<Result()> action, Function<void(Result)> on_complete)
: Core::Object(&background_thread())
, m_action(move(action))
, m_on_complete(move(on_complete))
{
Locker locker(all_actions().lock());
all_actions().resource().enqueue([this] {
m_result = m_action();
if (m_on_complete) {
Core::EventLoop::current().post_event(*this, make<Core::DeferredInvocationEvent>([this](auto&) {
m_on_complete(m_result.release_value());
this->remove_from_parent();
}));
Core::EventLoop::wake();
} else {
this->remove_from_parent();
}
});
}
Function<Result()> m_action;
Function<void(Result)> m_on_complete;
Optional<Result> m_result;
};
}

View file

@ -0,0 +1,7 @@
set(SOURCES
BackgroundAction.cpp
Thread.cpp
)
serenity_lib(LibThreading threading)
target_link_libraries(LibThreading LibC LibCore LibPthread)

View file

@ -0,0 +1,122 @@
/*
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <AK/Assertions.h>
#include <AK/Atomic.h>
#include <AK/Types.h>
#ifdef __serenity__
# include <unistd.h>
#else
# include <pthread.h>
#endif
namespace Threading {
class Lock {
public:
Lock() { }
~Lock() { }
void lock();
void unlock();
private:
#ifdef __serenity__
using ThreadID = int;
ALWAYS_INLINE static ThreadID self()
{
return gettid();
}
#else
using ThreadID = pthread_t;
ALWAYS_INLINE static ThreadID self()
{
return pthread_self();
}
#endif
Atomic<ThreadID> m_holder { 0 };
u32 m_level { 0 };
};
class Locker {
public:
ALWAYS_INLINE explicit Locker(Lock& l)
: m_lock(l)
{
lock();
}
ALWAYS_INLINE ~Locker() { unlock(); }
ALWAYS_INLINE void unlock() { m_lock.unlock(); }
ALWAYS_INLINE void lock() { m_lock.lock(); }
private:
Lock& m_lock;
};
ALWAYS_INLINE void Lock::lock()
{
ThreadID tid = self();
if (m_holder == tid) {
++m_level;
return;
}
for (;;) {
ThreadID expected = 0;
if (m_holder.compare_exchange_strong(expected, tid, AK::memory_order_acq_rel)) {
m_level = 1;
return;
}
#ifdef __serenity__
donate(expected);
#endif
}
}
inline void Lock::unlock()
{
VERIFY(m_holder == self());
VERIFY(m_level);
if (m_level == 1)
m_holder.store(0, AK::memory_order_release);
else
--m_level;
}
template<typename T>
class Lockable {
public:
Lockable() { }
template<typename... Args>
Lockable(Args&&... args)
: m_resource(forward(args)...)
{
}
Lockable(T&& resource)
: m_resource(move(resource))
{
}
Lock& lock() { return m_lock; }
T& resource() { return m_resource; }
T lock_and_copy()
{
Locker locker(m_lock);
return m_resource;
}
private:
T m_resource;
Lock m_lock;
};
}

View file

@ -0,0 +1,48 @@
/*
* Copyright (c) 2019-2020, Sergey Bugaev <bugaevc@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <LibThreading/Thread.h>
#include <pthread.h>
#include <string.h>
#include <unistd.h>
Threading::Thread::Thread(Function<intptr_t()> action, StringView thread_name)
: Core::Object(nullptr)
, m_action(move(action))
, m_thread_name(thread_name.is_null() ? "" : thread_name)
{
register_property("thread_name", [&] { return JsonValue { m_thread_name }; });
register_property("tid", [&] { return JsonValue { m_tid }; });
}
Threading::Thread::~Thread()
{
if (m_tid) {
dbgln("Destroying thread \"{}\"({}) while it is still running!", m_thread_name, m_tid);
[[maybe_unused]] auto res = join();
}
}
void Threading::Thread::start()
{
int rc = pthread_create(
&m_tid,
nullptr,
[](void* arg) -> void* {
Thread* self = static_cast<Thread*>(arg);
auto exit_code = self->m_action();
self->m_tid = 0;
return reinterpret_cast<void*>(exit_code);
},
static_cast<void*>(this));
VERIFY(rc == 0);
if (!m_thread_name.is_empty()) {
rc = pthread_setname_np(m_tid, m_thread_name.characters());
VERIFY(rc == 0);
}
dbgln("Started thread \"{}\", tid = {}", m_thread_name, m_tid);
}

View file

@ -0,0 +1,57 @@
/*
* Copyright (c) 2019-2020, Sergey Bugaev <bugaevc@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <AK/DistinctNumeric.h>
#include <AK/Function.h>
#include <AK/Result.h>
#include <AK/String.h>
#include <LibCore/Object.h>
#include <pthread.h>
namespace Threading {
TYPEDEF_DISTINCT_ORDERED_ID(intptr_t, ThreadError);
class Thread final : public Core::Object {
C_OBJECT(Thread);
public:
virtual ~Thread();
void start();
template<typename T = void>
Result<T, ThreadError> join();
String thread_name() const { return m_thread_name; }
pthread_t tid() const { return m_tid; }
private:
explicit Thread(Function<intptr_t()> action, StringView thread_name = nullptr);
Function<intptr_t()> m_action;
pthread_t m_tid { 0 };
String m_thread_name;
};
template<typename T>
Result<T, ThreadError> Thread::join()
{
void* thread_return = nullptr;
int rc = pthread_join(m_tid, &thread_return);
if (rc != 0) {
return ThreadError { rc };
}
m_tid = 0;
if constexpr (IsVoid<T>)
return {};
else
return { static_cast<T>(thread_return) };
}
}