eden-emu/eden
24
3
Fork 15
Code Issues 138 Pull requests 56 Projects 1 Releases Packages Wiki Activity Actions

[network, qt] use jthread and use std::vector for packet list instead of std::list #254

Open
Lizzie wants to merge 3 commits from netusejthreadstuff into master
pull from: netusejthreadstuff
merge into: eden-emu:master
Conversation 1 Commits 3 Files changed 11 +310 -393
11 changed files with 310 additions and 393 deletions
Download patch file Download diff file Expand all files Collapse all files

103
src/network/announce_multiplayer_session.cpp
View file

@ -19,9 +19,6 @@
namespace Core {
// Time between room is announced to web_service
static constexpr std::chrono::seconds announce_time_interval(15);
AnnounceMultiplayerSession::AnnounceMultiplayerSession() {
#ifdef ENABLE_WEB_SERVICE
backend = std::make_unique<WebService::RoomJson>(Settings::values.web_api_url.GetValue(),
@ -53,18 +50,58 @@ WebService::WebResult AnnounceMultiplayerSession::Register() {
}
void AnnounceMultiplayerSession::Start() {
if (announce_multiplayer_thread) {
if (announce_multiplayer_thread.has_value()) {
Stop();
}
shutdown_event.Reset();
announce_multiplayer_thread =
std::make_unique<std::thread>(&AnnounceMultiplayerSession::AnnounceMultiplayerLoop, this);
announce_multiplayer_thread.emplace([&](std::stop_token stoken) {
// Invokes all current bound error callbacks.
const auto ErrorCallback = [this](WebService::WebResult result) {
std::lock_guard lock(callback_mutex);
for (auto callback : error_callbacks)
(*callback)(result);
};
if (!registered) {
WebService::WebResult result = Register();
if (result.result_code != WebService::WebResult::Code::Success) {
ErrorCallback(result);
return;
}
}
// Time between room is announced to web_service
std::chrono::seconds const announce_timeslice(15);
auto update_time = std::chrono::steady_clock::now();
std::future<WebService::WebResult> future;
while (!shutdown_event.WaitUntil(update_time)) {
update_time = std::chrono::steady_clock::now() + announce_timeslice;
auto room = Network::GetRoom().lock();
if (!room) {
break;
}
if (room->GetState() != Network::Room::State::Open) {
break;
}
UpdateBackendData(room);
WebService::WebResult result = backend->Update();
if (result.result_code != WebService::WebResult::Code::Success) {
ErrorCallback(result);
}
if (result.result_string == "404") {
registered = false;
// Needs to register the room again
WebService::WebResult register_result = Register();
if (register_result.result_code != WebService::WebResult::Code::Success) {
ErrorCallback(register_result);
}
}
}
});
}
void AnnounceMultiplayerSession::Stop() {
if (announce_multiplayer_thread) {
if (announce_multiplayer_thread.has_value()) {
shutdown_event.Set();
announce_multiplayer_thread->join();
announce_multiplayer_thread.reset();
backend->Delete();
registered = false;
@ -101,58 +138,10 @@ void AnnounceMultiplayerSession::UpdateBackendData(std::shared_ptr<Network::Room
}
}
void AnnounceMultiplayerSession::AnnounceMultiplayerLoop() {
// Invokes all current bound error callbacks.
const auto ErrorCallback = [this](WebService::WebResult result) {
std::lock_guard lock(callback_mutex);
for (auto callback : error_callbacks) {
(*callback)(result);
}
};
if (!registered) {
WebService::WebResult result = Register();
if (result.result_code != WebService::WebResult::Code::Success) {
ErrorCallback(result);
return;
}
}
auto update_time = std::chrono::steady_clock::now();
std::future<WebService::WebResult> future;
while (!shutdown_event.WaitUntil(update_time)) {
update_time += announce_time_interval;
auto room = Network::GetRoom().lock();
if (!room) {
break;
}
if (room->GetState() != Network::Room::State::Open) {
break;
}
UpdateBackendData(room);
WebService::WebResult result = backend->Update();
if (result.result_code != WebService::WebResult::Code::Success) {
ErrorCallback(result);
}
if (result.result_string == "404") {
registered = false;
// Needs to register the room again
WebService::WebResult register_result = Register();
if (register_result.result_code != WebService::WebResult::Code::Success) {
ErrorCallback(register_result);
}
}
}
}
AnnounceMultiplayerRoom::RoomList AnnounceMultiplayerSession::GetRoomList() {
return backend->GetRoomList();
}
bool AnnounceMultiplayerSession::IsRunning() const {
return announce_multiplayer_thread != nullptr;
}
void AnnounceMultiplayerSession::UpdateCredentials() {
ASSERT_MSG(!IsRunning(), "Credentials can only be updated when session is not running");
#ifdef ENABLE_WEB_SERVICE

11
src/network/announce_multiplayer_session.h
View file

@ -72,7 +72,9 @@ public:
/**
* Whether the announce session is still running
*/
bool IsRunning() const;
[[nodiscard]] bool IsRunning() const {
return announce_multiplayer_thread.has_value();
}
/**
* Recreates the backend, updating the credentials.
@ -82,16 +84,13 @@ public:
private:
void UpdateBackendData(std::shared_ptr<Network::Room> room);
void AnnounceMultiplayerLoop();
Common::Event shutdown_event;
std::mutex callback_mutex;
std::set<CallbackHandle> error_callbacks;
std::unique_ptr<std::thread> announce_multiplayer_thread;
std::optional<std::jthread> announce_multiplayer_thread;
/// Backend interface that logs fields
std::unique_ptr<AnnounceMultiplayerRoom::Backend> backend;
std::mutex callback_mutex;
std::atomic_bool registered = false; ///< Whether the room has been registered
};

15
src/network/room.cpp
View file

@ -1,6 +1,5 @@
// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2017 Citra Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
@ -13,6 +12,7 @@
#include <shared_mutex>
#include <sstream>
#include <thread>
#include "common/polyfill_thread.h"
#include "common/logging/log.h"
#include "enet/enet.h"
#include "network/packet.h"
@ -54,13 +54,11 @@ public:
RoomImpl() : random_gen(std::random_device()()) {}
/// Thread that receives and dispatches network packets
std::unique_ptr<std::thread> room_thread;
std::optional<std::jthread> room_thread;
/// Verification backend of the room
std::unique_ptr<VerifyUser::Backend> verify_backend;
/// Thread function that will receive and dispatch messages until the room is destroyed.
void ServerLoop();
void StartLoop();
/**
@ -240,7 +238,8 @@ public:
};
// RoomImpl
void Room::RoomImpl::ServerLoop() {
void Room::RoomImpl::StartLoop() {
room_thread.emplace([&](std::stop_token stoken) {
while (state != State::Closed) {
ENetEvent event;
if (enet_host_service(server, &event, 5) > 0) {
@ -289,10 +288,7 @@ void Room::RoomImpl::ServerLoop() {
}
// Close the connection to all members:
SendCloseMessage();
}
void Room::RoomImpl::StartLoop() {
room_thread = std::make_unique<std::thread>(&Room::RoomImpl::ServerLoop, this);
});
}
void Room::RoomImpl::HandleJoinRequest(const ENetEvent* event) {
@ -1132,7 +1128,6 @@ void Room::SetVerifyUID(const std::string& uid) {
void Room::Destroy() {
room_impl->state = State::Closed;
room_impl->room_thread->join();
room_impl->room_thread.reset();
if (room_impl->server) {

56
src/network/room_member.cpp
View file

@ -1,3 +1,5 @@
// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2017 Citra Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
@ -7,6 +9,7 @@
#include <set>
#include <thread>
#include "common/assert.h"
#include "common/polyfill_thread.h"
#include "common/socket_types.h"
#include "enet/enet.h"
#include "network/packet.h"
@ -18,6 +21,21 @@ constexpr u32 ConnectionTimeoutMs = 5000;
class RoomMember::RoomMemberImpl {
public:
void SetState(const State new_state) noexcept {
if (state != new_state) {
state = new_state;
Invoke<State>(state);
}
}
void SetError(const Error new_error) noexcept {
Invoke<Error>(new_error);
}
[[nodiscard]] bool IsConnected() const noexcept {
return state == State::Joining || state == State::Joined || state == State::Moderator;
}
ENetHost* client = nullptr; ///< ENet network interface.
ENetPeer* server = nullptr; ///< The server peer the client is connected to
@ -30,9 +48,6 @@ public:
GameInfo current_game_info;
std::atomic<State> state{State::Idle}; ///< Current state of the RoomMember.
void SetState(const State new_state);
void SetError(const Error new_error);
bool IsConnected() const;
std::string nickname; ///< The nickname of this member.
@ -43,9 +58,9 @@ public:
std::mutex network_mutex; ///< Mutex that controls access to the `client` variable.
/// Thread that receives and dispatches network packets
std::unique_ptr<std::thread> loop_thread;
std::optional<std::jthread> loop_thread;
std::mutex send_list_mutex; ///< Mutex that controls access to the `send_list` variable.
std::list<Packet> send_list; ///< A list that stores all packets to send the async
std::vector<Packet> send_list; ///< A list that stores all packets to send the async
template <typename T>
using CallbackSet = std::set<CallbackHandle<T>>;
@ -68,8 +83,6 @@ public:
};
Callbacks callbacks; ///< All CallbackSets to all events
void MemberLoop();
void StartLoop();
/**
@ -146,22 +159,8 @@ public:
};
// RoomMemberImpl
void RoomMember::RoomMemberImpl::SetState(const State new_state) {
if (state != new_state) {
state = new_state;
Invoke<State>(state);
}
}
void RoomMember::RoomMemberImpl::SetError(const Error new_error) {
Invoke<Error>(new_error);
}
bool RoomMember::RoomMemberImpl::IsConnected() const {
return state == State::Joining || state == State::Joined || state == State::Moderator;
}
void RoomMember::RoomMemberImpl::MemberLoop() {
void RoomMember::RoomMemberImpl::StartLoop() {
loop_thread.emplace([&](std::stop_token stoken) {
// Receive packets while the connection is open
while (IsConnected()) {
std::lock_guard lock(network_mutex);
@ -257,12 +256,12 @@ void RoomMember::RoomMemberImpl::MemberLoop() {
break;
}
}
std::list<Packet> packets;
std::vector<Packet> packets;
{
std::lock_guard send_lock(send_list_mutex);
packets.swap(send_list);
}
for (const auto& packet : packets) {
for (auto const& packet : packets) {
ENetPacket* enetPacket = enet_packet_create(packet.GetData(), packet.GetDataSize(),
ENET_PACKET_FLAG_RELIABLE);
enet_peer_send(server, 0, enetPacket);
@ -270,10 +269,7 @@ void RoomMember::RoomMemberImpl::MemberLoop() {
enet_host_flush(client);
}
Disconnect();
};
void RoomMember::RoomMemberImpl::StartLoop() {
loop_thread = std::make_unique<std::thread>(&RoomMember::RoomMemberImpl::MemberLoop, this);
});
}
void RoomMember::RoomMemberImpl::Send(Packet&& packet) {
@ -747,9 +743,7 @@ void RoomMember::Unbind(CallbackHandle<T> handle) {
void RoomMember::Leave() {
room_member_impl->SetState(State::Idle);
room_member_impl->loop_thread->join();
room_member_impl->loop_thread.reset();
enet_host_destroy(room_member_impl->client);
room_member_impl->client = nullptr;
}

15
src/tests/input_common/calibration_configuration_job.cpp
View file

@ -1,3 +1,6 @@
// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
@ -18,13 +21,9 @@ public:
: socket(io_context, boost::asio::ip::udp::endpoint(boost::asio::ip::udp::v4(), 0)) {}
~FakeCemuhookServer() {
is_running = false;
boost::system::error_code error_code;
socket.shutdown(boost::asio::socket_base::shutdown_both, error_code);
socket.close();
if (handler.joinable()) {
handler.join();
}
}
u16 GetPort() {
@ -41,10 +40,9 @@ public:
sizeof(InputCommon::CemuhookUDP::Message<InputCommon::CemuhookUDP::Response::PadData>);
REQUIRE(touch_movement_path.size() > 0);
is_running = true;
handler = std::thread([touch_movement_path, this]() {
handler = std::jthread([touch_movement_path, this](std::stop_token stoken) {
auto current_touch_position = touch_movement_path.begin();
while (is_running) {
while (!stoken.stop_requested()) {
boost::asio::ip::udp::endpoint sender_endpoint;
boost::system::error_code error_code;
auto received_size = socket.receive_from(boost::asio::buffer(receive_buffer),
@ -87,8 +85,7 @@ private:
boost::asio::ip::udp::socket socket;
std::array<u8, InputCommon::CemuhookUDP::MAX_PACKET_SIZE> send_buffer;
std::array<u8, InputCommon::CemuhookUDP::MAX_PACKET_SIZE> receive_buffer;
bool is_running = false;
std::thread handler;
std::jthread handler;
};
TEST_CASE("CalibrationConfigurationJob completed", "[input_common]") {

37
src/yuzu/applets/qt_software_keyboard.cpp
View file

@ -1,3 +1,5 @@
// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
@ -1492,31 +1494,9 @@ void QtSoftwareKeyboardDialog::MoveTextCursorDirection(Direction direction) {
}
void QtSoftwareKeyboardDialog::StartInputThread() {
if (input_thread_running) {
return;
}
input_thread_running = true;
input_thread = std::thread(&QtSoftwareKeyboardDialog::InputThread, this);
}
void QtSoftwareKeyboardDialog::StopInputThread() {
input_thread_running = false;
if (input_thread.joinable()) {
input_thread.join();
}
if (input_interpreter) {
input_interpreter->ResetButtonStates();
}
}
void QtSoftwareKeyboardDialog::InputThread() {
while (input_thread_running) {
input_thread = std::jthread([&](std::stop_token stoken) {
while (!stoken.stop_requested()) {
input_interpreter->PollInput();
HandleButtonPressedOnce<
Core::HID::NpadButton::A, Core::HID::NpadButton::B, Core::HID::NpadButton::X,
Core::HID::NpadButton::Y, Core::HID::NpadButton::StickL, Core::HID::NpadButton::StickR,
@ -1527,7 +1507,6 @@ void QtSoftwareKeyboardDialog::InputThread() {
Core::HID::NpadButton::StickLDown, Core::HID::NpadButton::StickRLeft,
Core::HID::NpadButton::StickRUp, Core::HID::NpadButton::StickRRight,
Core::HID::NpadButton::StickRDown>();
HandleButtonHold<Core::HID::NpadButton::B, Core::HID::NpadButton::L,
Core::HID::NpadButton::R, Core::HID::NpadButton::Left,
Core::HID::NpadButton::Up, Core::HID::NpadButton::Right,
@ -1536,9 +1515,15 @@ void QtSoftwareKeyboardDialog::InputThread() {
Core::HID::NpadButton::StickLDown, Core::HID::NpadButton::StickRLeft,
Core::HID::NpadButton::StickRUp, Core::HID::NpadButton::StickRRight,
Core::HID::NpadButton::StickRDown>();
std::this_thread::sleep_for(std::chrono::milliseconds(50));
}
});
}
void QtSoftwareKeyboardDialog::StopInputThread() {
input_thread.request_stop();
if (input_interpreter)
input_interpreter->ResetButtonStates();
}
QtSoftwareKeyboard::QtSoftwareKeyboard(GMainWindow& main_window) {

10
src/yuzu/applets/qt_software_keyboard.h
View file

@ -1,3 +1,5 @@
// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
@ -182,9 +184,6 @@ private:
void StartInputThread();
void StopInputThread();
/// The thread where input is being polled and processed.
void InputThread();
std::unique_ptr<Ui::QtSoftwareKeyboardDialog> ui;
Core::System& system;
@ -220,10 +219,7 @@ private:
std::atomic<bool> caps_lock_enabled{false};
std::unique_ptr<InputInterpreter> input_interpreter;
std::thread input_thread;
std::atomic<bool> input_thread_running{};
std::jthread input_thread;
};
class QtSoftwareKeyboard final : public QObject, public Core::Frontend::SoftwareKeyboardApplet {

36
src/yuzu/applets/qt_web_browser.cpp
View file

@ -1,3 +1,6 @@
// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
@ -282,34 +285,13 @@ void QtNXWebEngineView::SendKeyPressEvent(int key) {
}
void QtNXWebEngineView::StartInputThread() {
if (input_thread_running) {
return;
}
input_thread_running = true;
input_thread = std::thread(&QtNXWebEngineView::InputThread, this);
}
void QtNXWebEngineView::StopInputThread() {
if (is_local) {
QWidget::releaseKeyboard();
}
input_thread_running = false;
if (input_thread.joinable()) {
input_thread.join();
}
}
void QtNXWebEngineView::InputThread() {
input_thread = std::jthread([&](std::stop_token stoken) {
// Wait for 1 second before allowing any inputs to be processed.
std::this_thread::sleep_for(std::chrono::seconds(1));
if (is_local) {
QWidget::grabKeyboard();
}
while (input_thread_running) {
while (!stoken.stop_requested()) {
input_interpreter->PollInput();
HandleWindowFooterButtonPressedOnce<Core::HID::NpadButton::A, Core::HID::NpadButton::B,
@ -330,6 +312,14 @@ void QtNXWebEngineView::InputThread() {
std::this_thread::sleep_for(std::chrono::milliseconds(50));
}
});
}
void QtNXWebEngineView::StopInputThread() {
if (is_local) {
QWidget::releaseKeyboard();
}
input_thread.request_stop();
}
void QtNXWebEngineView::LoadExtractedFonts() {

21
src/yuzu/applets/qt_web_browser.h
View file

@ -1,3 +1,6 @@
// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
@ -155,9 +158,6 @@ private:
void StartInputThread();
void StopInputThread();
/// The thread where input is being polled and processed.
void InputThread();
/// Loads the extracted fonts using JavaScript.
void LoadExtractedFonts();
@ -165,24 +165,13 @@ private:
void FocusFirstLinkElement();
InputCommon::InputSubsystem* input_subsystem;
std::unique_ptr<UrlRequestInterceptor> url_interceptor;
std::unique_ptr<InputInterpreter> input_interpreter;
std::thread input_thread;
std::atomic<bool> input_thread_running{};
std::jthread input_thread;
std::atomic<bool> finished{};
Service::AM::Frontend::WebExitReason exit_reason{
Service::AM::Frontend::WebExitReason::EndButtonPressed};
Service::AM::Frontend::WebExitReason exit_reason{Service::AM::Frontend::WebExitReason::EndButtonPressed};
std::string last_url{"http://localhost/"};
bool is_local{};
QWebEngineProfile* default_profile;
QWebEngineSettings* global_settings;
};

30
src/yuzu/util/overlay_dialog.cpp
View file

@ -1,3 +1,5 @@
// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
@ -231,34 +233,20 @@ void OverlayDialog::TranslateButtonPress(Core::HID::NpadButton button) {
}
void OverlayDialog::StartInputThread() {
if (input_thread_running) {
return;
}
input_thread_running = true;
input_thread = std::thread(&OverlayDialog::InputThread, this);
}
void OverlayDialog::StopInputThread() {
input_thread_running = false;
if (input_thread.joinable()) {
input_thread.join();
}
}
void OverlayDialog::InputThread() {
while (input_thread_running) {
input_thread = std::jthread([&](std::stop_token stoken) {
while (!stoken.stop_requested()) {
input_interpreter->PollInput();
HandleButtonPressedOnce<Core::HID::NpadButton::A, Core::HID::NpadButton::B,
Core::HID::NpadButton::Left, Core::HID::NpadButton::Right,
Core::HID::NpadButton::StickLLeft,
Core::HID::NpadButton::StickLRight>();
std::this_thread::sleep_for(std::chrono::milliseconds(50));
}
});
}
void OverlayDialog::StopInputThread() {
input_thread.request_stop();
}
void OverlayDialog::keyPressEvent(QKeyEvent* e) {

11
src/yuzu/util/overlay_dialog.h
View file

@ -1,9 +1,10 @@
// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include <atomic>
#include <memory>
#include <thread>
@ -91,9 +92,6 @@ private:
void StartInputThread();
void StopInputThread();
/// The thread where input is being polled and processed.
void InputThread();
void keyPressEvent(QKeyEvent* e) override;
std::unique_ptr<Ui::OverlayDialog> ui;
@ -101,8 +99,5 @@ private:
bool use_rich_text;
std::unique_ptr<InputInterpreter> input_interpreter;
std::thread input_thread;
std::atomic<bool> input_thread_running{};
std::jthread input_thread;
};