[network] use jthread and use std::vector for packet list instead of std::list

Signed-off-by: lizzie <lizzie@eden-emu.dev>

src/network/announce_multiplayer_session.cpp

@@ -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,61 +50,15 @@ WebService::WebResult AnnounceMultiplayerSession::Register() {
 }
 
 void AnnounceMultiplayerSession::Start() {
-    if (announce_multiplayer_thread) {
-        Stop();
-    }
-    shutdown_event.Reset();
-    announce_multiplayer_thread =
-        std::make_unique<std::thread>(&AnnounceMultiplayerSession::AnnounceMultiplayerLoop, this);
-}
-
-void AnnounceMultiplayerSession::Stop() {
-    if (announce_multiplayer_thread) {
-        shutdown_event.Set();
-        announce_multiplayer_thread->join();
-        announce_multiplayer_thread.reset();
-        backend->Delete();
-        registered = false;
-    }
-}
-
-AnnounceMultiplayerSession::CallbackHandle AnnounceMultiplayerSession::BindErrorCallback(
-    std::function<void(const WebService::WebResult&)> function) {
-    std::lock_guard lock(callback_mutex);
-    auto handle = std::make_shared<std::function<void(const WebService::WebResult&)>>(function);
-    error_callbacks.insert(handle);
-    return handle;
-}
-
-void AnnounceMultiplayerSession::UnbindErrorCallback(CallbackHandle handle) {
-    std::lock_guard lock(callback_mutex);
-    error_callbacks.erase(handle);
-}
-
-AnnounceMultiplayerSession::~AnnounceMultiplayerSession() {
+    if (announce_multiplayer_thread.has_value()) {
         Stop();
     }
-
-void AnnounceMultiplayerSession::UpdateBackendData(std::shared_ptr<Network::Room> room) {
-    Network::RoomInformation room_information = room->GetRoomInformation();
-    std::vector<AnnounceMultiplayerRoom::Member> memberlist = room->GetRoomMemberList();
-    backend->SetRoomInformation(room_information.name, room_information.description,
-                                room_information.port, room_information.member_slots,
-                                Network::network_version, room->HasPassword(),
-                                room_information.preferred_game);
-    backend->ClearPlayers();
-    for (const auto& member : memberlist) {
-        backend->AddPlayer(member);
-    }
-}
-
-void AnnounceMultiplayerSession::AnnounceMultiplayerLoop() {
+    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) {
+            for (auto callback : error_callbacks)
                 (*callback)(result);
-        }
         };
 
         if (!registered) {
@@ -118,10 +69,12 @@ void AnnounceMultiplayerSession::AnnounceMultiplayerLoop() {
             }
         }
 
+        // 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 += announce_time_interval;
+            update_time = std::chrono::steady_clock::now() + announce_timeslice;
             auto room = Network::GetRoom().lock();
             if (!room) {
                 break;
@@ -143,14 +96,50 @@ void AnnounceMultiplayerSession::AnnounceMultiplayerLoop() {
                 }
             }
         }
+    });
 }
 
-AnnounceMultiplayerRoom::RoomList AnnounceMultiplayerSession::GetRoomList() {
-    return backend->GetRoomList();
+void AnnounceMultiplayerSession::Stop() {
+    if (announce_multiplayer_thread.has_value()) {
+        shutdown_event.Set();
+        announce_multiplayer_thread.reset();
+        backend->Delete();
+        registered = false;
+    }
+}
+
+AnnounceMultiplayerSession::CallbackHandle AnnounceMultiplayerSession::BindErrorCallback(
+    std::function<void(const WebService::WebResult&)> function) {
+    std::lock_guard lock(callback_mutex);
+    auto handle = std::make_shared<std::function<void(const WebService::WebResult&)>>(function);
+    error_callbacks.insert(handle);
+    return handle;
+}
+
+void AnnounceMultiplayerSession::UnbindErrorCallback(CallbackHandle handle) {
+    std::lock_guard lock(callback_mutex);
+    error_callbacks.erase(handle);
+}
+
+AnnounceMultiplayerSession::~AnnounceMultiplayerSession() {
+    Stop();
 }
 
-bool AnnounceMultiplayerSession::IsRunning() const {
-    return announce_multiplayer_thread != nullptr;
+void AnnounceMultiplayerSession::UpdateBackendData(std::shared_ptr<Network::Room> room) {
+    Network::RoomInformation room_information = room->GetRoomInformation();
+    std::vector<AnnounceMultiplayerRoom::Member> memberlist = room->GetRoomMemberList();
+    backend->SetRoomInformation(room_information.name, room_information.description,
+                                room_information.port, room_information.member_slots,
+                                Network::network_version, room->HasPassword(),
+                                room_information.preferred_game);
+    backend->ClearPlayers();
+    for (const auto& member : memberlist) {
+        backend->AddPlayer(member);
+    }
+}
+
+AnnounceMultiplayerRoom::RoomList AnnounceMultiplayerSession::GetRoomList() {
+    return backend->GetRoomList();
 }
 
 void AnnounceMultiplayerSession::UpdateCredentials() {

src/network/announce_multiplayer_session.h

@@ -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
 };
 

src/network/room.cpp

@@ -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
 
@@ -54,13 +53,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 +237,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 +287,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) {
@@ -1133,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) {

src/network/room_member.cpp

@@ -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
 
@@ -18,6 +20,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 +47,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 +57,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 +82,6 @@ public:
     };
     Callbacks callbacks; ///< All CallbackSets to all events
 
-    void MemberLoop();
-
     void StartLoop();
 
     /**
@@ -146,22 +158,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 +255,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 +268,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 +742,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;
 }