[common] unify std::random_device

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

src/common/random.cpp

@@ -0,0 +1,19 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include <random>
+#include "common/random.h"
+
+static std::random_device g_random_device;
+
+namespace Common::Random {
+    [[nodiscard]] u32 Random32(u32 seed) noexcept {
+        return g_random_device();
+    }
+    [[nodiscard]] u64 Random64(u64 seed) noexcept {
+        return g_random_device();
+    }
+    [[nodiscard]] std::mt19937 GetMT19937() noexcept {
+        return std::mt19937(g_random_device);
+    }
+}

src/common/random.h

@@ -0,0 +1,13 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include <random>
+#include "common/common_types.h"
+
+namespace Common::Random {
+    [[nodiscard]] u32 Random32(u32 seed) noexcept;
+    [[nodiscard]] u64 Random64(u64 seed) noexcept;
+    [[nodiscard]] std::mt19937 GetMT19937() noexcept;
+}

src/common/uuid.cpp

@@ -10,6 +10,7 @@
 #include "common/assert.h"
 #include "common/tiny_mt.h"
 #include "common/uuid.h"
+#include "common/random.h"
 
 namespace Common {
 
@@ -175,21 +176,16 @@ u128 UUID::AsU128() const {
 }
 
 UUID UUID::MakeRandom() {
-    std::random_device device;
-
-    return MakeRandomWithSeed(device());
+    return MakeRandomWithSeed(Common::Random::Random32(0));
 }
 
 UUID UUID::MakeRandomWithSeed(u32 seed) {
     // Create and initialize our RNG.
     TinyMT rng;
     rng.Initialize(seed);
-
     UUID uuid;
-
     // Populate the UUID with random bytes.
     rng.GenerateRandomBytes(uuid.uuid.data(), sizeof(UUID));
-
     return uuid;
 }
 

src/core/hle/service/mii/mii_util.h

@@ -7,6 +7,7 @@
 #include <span>
 
 #include "common/common_types.h"
+#include "common/random.h"
 #include "common/swap.h"
 #include "common/uuid.h"
 #include "core/hle/service/mii/mii_types.h"
@@ -65,11 +66,9 @@ public:
 
     template <typename T>
     static T GetRandomValue(T min, T max) {
-        std::random_device device;
-        std::mt19937 gen(device());
-        std::uniform_int_distribution<u64> distribution(static_cast<u64>(min),
-                                                        static_cast<u64>(max));
-        return static_cast<T>(distribution(gen));
+        std::uniform_int_distribution<u64> distribution{u64(min), u64(max)};
+        auto gen = Common::Random::GetMT19937();
+        return T(distribution(gen));
     }
 
     template <typename T>

src/core/loader/deconstructed_rom_directory.cpp

@@ -6,6 +6,7 @@
 
 #include <cstring>
 #include "common/logging.h"
+#include "common/random.h"
 #include "common/settings.h"
 #include "core/core.h"
 #include "core/file_sys/content_archive.h"
@@ -229,7 +230,7 @@ AppLoader_DeconstructedRomDirectory::LoadResult AppLoader_DeconstructedRomDirect
     // TODO: this is bad form of ASLR, it sucks
     size_t aslr_offset = ((::Settings::values.rng_seed_enabled.GetValue()
         ? ::Settings::values.rng_seed.GetValue()
-        : std::rand()) * 0x734287f27) & 0xfff000;
+        : Common::Random::Random64(0)) * 0x734287f27) & 0xfff000;
 
     // Setup the process code layout
     if (process.LoadFromMetadata(metadata, code_size, fastmem_base, aslr_offset, is_hbl).IsError()) {

src/core/loader/kip.cpp

@@ -6,6 +6,7 @@
 
 #include <cstring>
 #include "common/settings.h"
+#include "common/random.h"
 #include "core/file_sys/kernel_executable.h"
 #include "core/file_sys/program_metadata.h"
 #include "core/hle/kernel/code_set.h"
@@ -90,7 +91,7 @@ AppLoader::LoadResult AppLoader_KIP::Load(Kernel::KProcess& process,
     // TODO: this is bad form of ASLR, it sucks
     size_t aslr_offset = ((::Settings::values.rng_seed_enabled.GetValue()
         ? ::Settings::values.rng_seed.GetValue()
-        : std::rand()) * 0x734287f27) & 0xfff000;
+        : Common::Random::Random64(0)) * 0x734287f27) & 0xfff000;
 
     // Setup the process code layout
     if (process.LoadFromMetadata(FileSys::ProgramMetadata::GetDefault(), codeset.memory.size(), 0, aslr_offset, false).IsError()) {

src/core/loader/nro.cpp

@@ -11,6 +11,7 @@
 #include "common/common_types.h"
 #include "common/logging.h"
 #include "common/settings.h"
+#include "common/random.h"
 #include "common/swap.h"
 #include "core/core.h"
 #include "core/file_sys/control_metadata.h"
@@ -243,7 +244,7 @@ static bool LoadNroImpl(Core::System& system, Kernel::KProcess& process,
     // TODO: this is bad form of ASLR, it sucks
     size_t aslr_offset = ((::Settings::values.rng_seed_enabled.GetValue()
         ? ::Settings::values.rng_seed.GetValue()
-        : std::rand()) * 0x734287f27) & 0xfff000;
+        : Common::Random::Random64(0)) * 0x734287f27) & 0xfff000;
 
     // Setup the process code layout
     if (process

src/frontend_common/settings_generator.cpp

@@ -4,22 +4,21 @@
 #include <random>
 #include <frozen/string.h>
 #include "common/settings.h"
+#include "common/random.h"
 #include "settings_generator.h"
 
 namespace FrontendCommon {
 
 void GenerateSettings() {
-    static std::random_device rd;
-
+    auto gen = Common::Random::GetMT19937();
     // Web Token
     if (Settings::values.eden_token.GetValue().empty()) {
         static constexpr const size_t token_length = 48;
         static constexpr const frozen::string token_set = "abcdefghijklmnopqrstuvwxyz";
         static std::uniform_int_distribution<int> token_dist(0, token_set.size() - 1);
         std::string result;
-
         for (size_t i = 0; i < token_length; ++i) {
-            size_t idx = token_dist(rd);
+            size_t idx = token_dist(gen);
             result += token_set[idx];
         }
         Settings::values.eden_token.SetValue(result);
@@ -27,8 +26,6 @@ void GenerateSettings() {
 
     // Randomly generated number because, well, we fill the rest automagically ;)
     // Other serial parts are filled by Region_Index
-    std::random_device device;
-    std::mt19937 gen(device());
     std::uniform_int_distribution<u32> distribution(1, (std::numeric_limits<u32>::max)());
     if (Settings::values.serial_unit.GetValue() == 0)
         Settings::values.serial_unit.SetValue(distribution(gen));

src/hid_core/frontend/input_converter.cpp

@@ -4,6 +4,7 @@
 #include <algorithm>
 #include <random>
 
+#include "common/random.h"
 #include "common/input.h"
 #include "hid_core/frontend/input_converter.h"
 
@@ -119,15 +120,14 @@ Common::Input::MotionStatus TransformToMotion(const Common::Input::CallbackStatu
             .properties = properties,
         };
         if (TransformToButton(callback).value) {
-            std::random_device device;
-            std::mt19937 gen(device());
             std::uniform_int_distribution<s16> distribution(-5000, 5000);
-            status.accel.x.raw_value = static_cast<f32>(distribution(gen)) * 0.001f;
-            status.accel.y.raw_value = static_cast<f32>(distribution(gen)) * 0.001f;
-            status.accel.z.raw_value = static_cast<f32>(distribution(gen)) * 0.001f;
-            status.gyro.x.raw_value = static_cast<f32>(distribution(gen)) * 0.001f;
-            status.gyro.y.raw_value = static_cast<f32>(distribution(gen)) * 0.001f;
-            status.gyro.z.raw_value = static_cast<f32>(distribution(gen)) * 0.001f;
+            auto gen = Common::Random::GetMT19937();
+            status.accel.x.raw_value = f32(distribution(gen)) * 0.001f;
+            status.accel.y.raw_value = f32(distribution(gen)) * 0.001f;
+            status.accel.z.raw_value = f32(distribution(gen)) * 0.001f;
+            status.gyro.x.raw_value = f32(distribution(gen)) * 0.001f;
+            status.gyro.y.raw_value = f32(distribution(gen)) * 0.001f;
+            status.gyro.z.raw_value = f32(distribution(gen)) * 0.001f;
         }
         break;
     }

src/input_common/drivers/udp_client.cpp

@@ -11,6 +11,7 @@
 
 #include "common/logging.h"
 #include "common/param_package.h"
+#include "common/random.h"
 #include "common/settings.h"
 #include "input_common/drivers/udp_client.h"
 #include "input_common/helpers/udp_protocol.h"
@@ -31,7 +32,7 @@ public:
 
     explicit Socket(const std::string& host, u16 port, SocketCallback callback_)
         : callback(std::move(callback_)), timer(io_context),
-          socket(io_context, udp::endpoint(udp::v4(), 0)), client_id(GenerateRandomClientId()) {
+          socket(io_context, udp::endpoint(udp::v4(), 0)), client_id(Common::Random::Random32(0)) {
         boost::system::error_code ec{};
         auto ipv4 = boost::asio::ip::make_address_v4(host, ec);
         if (ec.value() != boost::system::errc::success) {
@@ -64,11 +65,6 @@ public:
     }
 
 private:
-    u32 GenerateRandomClientId() const {
-        std::random_device device;
-        return device();
-    }
-
     void HandleReceive(const boost::system::error_code&, std::size_t bytes_transferred) {
         if (auto type = Response::Validate(receive_buffer.data(), bytes_transferred)) {
             switch (*type) {

src/network/room.cpp

@@ -23,8 +23,6 @@ namespace Network {
 
 class Room::RoomImpl {
 public:
-    std::mt19937 random_gen; ///< Random number generator. Used for GenerateFakeIPAddress
-
     ENetHost* server = nullptr; ///< Network interface.
 
     std::atomic<State> state{State::Closed}; ///< Current state of the room.
@@ -51,7 +49,7 @@ public:
     IPBanList ip_ban_list;             ///< List of banned IP addresses
     mutable std::mutex ban_list_mutex; ///< Mutex for the ban lists
 
-    RoomImpl() : random_gen(std::random_device()()) {}
+    RoomImpl() {}
 
     /// Thread that receives and dispatches network packets
     std::optional<std::jthread> room_thread;