mirror of
https://github.com/LadybirdBrowser/ladybird.git
synced 2025-01-25 18:52:22 -05:00
125122a9ab
The audio enqueuer thread goes to sleep when there is no more audio data present, and through normal Core::EventLoop events it can be woken up. However, that waking up only happens when the thread is not currently running, so that the wake-up events don't queue up and cause weirdness. The atomic variable responsible for keeping track of whether the thread is active can lead to a racy deadlock however, where the audio enqueuer thread will never wake up again despite there being audio data to enqueue. Consider this scenario: - Main thread calls into async_enqueue. It detects that according to the atomic variable, the other thread is still running, skipping the event queue wake. - Enqueuer thread has just finished playing the last chunk of audio and detects that there is no audio left. It enters the if block with the dbgln "Reached end of provided audio data..." - Main thread enqueues audio, making the user sample queue non-empty. - Enqueuer thread does not check this condition again, instead setting the atomic variable to indicate that it is not running. It exits into an event loop sleep. - Main thread exits async_enqueue. The calling audio enqueuing system (see e.g. Piano, but all of them function similarly) will wait until the enqueuer thread has played enough samples before async_enqueue is called again. However, since the enqueuer thread will never play any audio, this condition is never fulfilled and audio playback deadlocks This commit fixes that by allowing the event loop to not enqueue an event that already exists, therefore overloading the audio enqueuer event loop by at maximum one message in weird situations. We entirely get rid of the atomic variable and the race condition is prevented.
139 lines
3.6 KiB
C++
139 lines
3.6 KiB
C++
/*
|
|
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
|
|
* Copyright (c) 2022, kleines Filmröllchen <malu.bertsch@gmail.com>
|
|
* Copyright (c) 2022, the SerenityOS developers.
|
|
*
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include <AK/Forward.h>
|
|
#include <AK/Function.h>
|
|
#include <AK/HashMap.h>
|
|
#include <AK/Noncopyable.h>
|
|
#include <AK/NonnullOwnPtr.h>
|
|
#include <AK/NonnullRefPtr.h>
|
|
#include <AK/Time.h>
|
|
#include <AK/Vector.h>
|
|
#include <AK/WeakPtr.h>
|
|
#include <LibCore/DeferredInvocationContext.h>
|
|
#include <LibCore/Event.h>
|
|
#include <LibCore/Forward.h>
|
|
#include <LibThreading/MutexProtected.h>
|
|
#include <sys/time.h>
|
|
#include <sys/types.h>
|
|
|
|
namespace Core {
|
|
|
|
class EventLoop {
|
|
public:
|
|
enum class MakeInspectable {
|
|
No,
|
|
Yes,
|
|
};
|
|
|
|
enum class ShouldWake {
|
|
No,
|
|
Yes
|
|
};
|
|
|
|
explicit EventLoop(MakeInspectable = MakeInspectable::No);
|
|
~EventLoop();
|
|
static void initialize_wake_pipes();
|
|
|
|
int exec();
|
|
|
|
enum class WaitMode {
|
|
WaitForEvents,
|
|
PollForEvents,
|
|
};
|
|
|
|
// process events, generally called by exec() in a loop.
|
|
// this should really only be used for integrating with other event loops
|
|
size_t pump(WaitMode = WaitMode::WaitForEvents);
|
|
|
|
void spin_until(Function<bool()>);
|
|
|
|
void post_event(Object& receiver, NonnullOwnPtr<Event>&&, ShouldWake = ShouldWake::No);
|
|
void wake_once(Object& receiver, int custom_event_type);
|
|
|
|
static EventLoop& current();
|
|
|
|
bool was_exit_requested() const { return m_exit_requested; }
|
|
|
|
static int register_timer(Object&, int milliseconds, bool should_reload, TimerShouldFireWhenNotVisible);
|
|
static bool unregister_timer(int timer_id);
|
|
|
|
static void register_notifier(Badge<Notifier>, Notifier&);
|
|
static void unregister_notifier(Badge<Notifier>, Notifier&);
|
|
|
|
void quit(int);
|
|
void unquit();
|
|
|
|
void take_pending_events_from(EventLoop& other)
|
|
{
|
|
m_queued_events.extend(move(other.m_queued_events));
|
|
}
|
|
|
|
static void wake_current();
|
|
void wake();
|
|
|
|
static int register_signal(int signo, Function<void(int)> handler);
|
|
static void unregister_signal(int handler_id);
|
|
|
|
// Note: Boost uses Parent/Child/Prepare, but we don't really have anything
|
|
// interesting to do in the parent or before forking.
|
|
enum class ForkEvent {
|
|
Child,
|
|
};
|
|
static void notify_forked(ForkEvent);
|
|
|
|
static bool has_been_instantiated();
|
|
|
|
void deferred_invoke(Function<void()> invokee)
|
|
{
|
|
auto context = DeferredInvocationContext::construct();
|
|
post_event(context, make<Core::DeferredInvocationEvent>(context, move(invokee)));
|
|
}
|
|
|
|
private:
|
|
void wait_for_event(WaitMode);
|
|
Optional<Time> get_next_timer_expiration();
|
|
static void dispatch_signal(int);
|
|
static void handle_signal(int);
|
|
|
|
struct QueuedEvent {
|
|
AK_MAKE_NONCOPYABLE(QueuedEvent);
|
|
|
|
public:
|
|
QueuedEvent(Object& receiver, NonnullOwnPtr<Event>);
|
|
QueuedEvent(QueuedEvent&&);
|
|
~QueuedEvent() = default;
|
|
|
|
WeakPtr<Object> receiver;
|
|
NonnullOwnPtr<Event> event;
|
|
};
|
|
|
|
Vector<QueuedEvent, 64> m_queued_events;
|
|
static pid_t s_pid;
|
|
|
|
bool m_exit_requested { false };
|
|
int m_exit_code { 0 };
|
|
|
|
static thread_local int s_wake_pipe_fds[2];
|
|
static thread_local bool s_wake_pipe_initialized;
|
|
|
|
// The wake pipe of this event loop needs to be accessible from other threads.
|
|
int (*m_wake_pipe_fds)[2];
|
|
|
|
struct Private;
|
|
NonnullOwnPtr<Private> m_private;
|
|
};
|
|
|
|
inline void deferred_invoke(Function<void()> invokee)
|
|
{
|
|
EventLoop::current().deferred_invoke(move(invokee));
|
|
}
|
|
|
|
}
|