質問編集履歴

文章を修正

2024/01/03 04:53

投稿

samidare_chan

スコア18

title CHANGED Viewed

	@@ -1,1 +1,1 @@
1	- 画像ロード中に同じ画像がロードされるのを~~防ぐマルチスレッドの処理の~~作り~~方が知り~~たい
1	+ [ゲーム開発] 非同期のアセットのロードで同じファイルがロードされない仕組みを作りたい

body CHANGED Viewed

@@ -1,67 +1,191 @@
 ##### 質問内容
-提示コードの`///`部ですが、マルチスレッドの非同期処理で複数のスレッドが同じ画像をロードする際に、一つだけロードして残りのスレッドはロードしたものを使いまわすという処理で処理時間を高速化したいのですがそれを行うにはどういったコードを書けばいいのでしょうか？
-##### 知りたいこと
-一つだけロードして残りのスレッドはロードしたものを使いまわすという処理を作る方法が知りたい
+提示コードですが非同期処理を用いて、アセットを非同期でロードする処理なのですが現状３つの画像がそれぞれ順番にロードされてしまう原因が知りたいです。
+提示コードの非同期版のコードでは同じ画像が来た時待機するという処理を行っているのですが、なぜか同期版と同じ秒数処理時間がかかっているため同期処理と同じになって
+いると考えられます。
-##### 現状
+##### 調べたこと
-画像処理をそもそもブロックしてしまう形で、マルチスレッドの意味がありません
+非同期版と同期版両方のプログラムを記述して実行時間を計測
-##### 試したこと
+##### 知りたいこと
-ミュータックスを使って処理をブロックするというやり方が一番近いと思うのですが提示コードでは画像のロード処理そもそもをブロックしてしまうのでこれでは非同期の意味がありません。
+１，アセットのロードで同じファイルがロードされないようにしながら非同期で行いたい。
+２，そもそもどの非同期機能を使ってアセットロードを実装するのが定番なのか知りたいです。
-##### 環境
+##### 提示コードについて
-言語: c++
+提示コードはコンポーネント指向を用いています。Componentを継承して非同期で行うアセットロード処理を作り、それをGameObject(コンポーネントをの挙動を管理する)で
-ライブラリ: SDL_Image
+処理をまとめて、更に上のSceneで全部のGameObject の非同期処理を一つにまとめ、最後に全部が終わるまで待機してからUpdate()等を実行するという処理内容です。
+##### コンソール
+```
+new sprite
+found sprite
+new sprite
+2000
+```
-##### 提示コード
+##### ソースコード
 ```cpp
-#include <Context.hpp>
 #include <vector>
 #include <future>
 #include <iostream>
 #include <glm/glm.hpp>
 #include <thread>
 #include <mutex>
+#include <condition_variable>
+#include <chrono>
+#include <random>
+#include <thread>
 struct Sprite
 {
-    SDL_Surface* handle;
+    int handle;
     std::string path;
 };
-std::vector<Sprite> sprites;
+std::vector<Sprite> sprites;            //ロードした画像リスト
+std::vector<std::string> nowLoad;       //現在ロード中の画像リスト
+std::mutex loadMutex;
+std::condition_variable loadCV;
+/*##############################################################
+# 乱数取得
+##############################################################*/
+int GetRandom(int rand)
+{
+    // 現在の時間を取得して種(seed)として使用する
+    auto now = std::chrono::high_resolution_clock::now();
+    auto seed = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()).count();
+    // 乱数生成器を初期化
-std::mutex loadMutex;
+    std::mt19937_64 generator(seed);
+    // ミリ秒単位の乱数を生成
+    std::uniform_int_distribution<int> distribution(0, rand);
+    int random_number = distribution(generator);
+    //std::cout << "ミリ秒単位の乱数: " << random_number << std::endl;
+    return random_number;
+}
-//////////////////////////////////////////////////////////////////////////////////////////////////////
+/*##############################################################
+# 非同期　版
+# スプライトロード関数
+※　テスト用のためロード時間を乱数でミリ秒待機
+##############################################################*/
 Sprite LoadSprite(const char* filePath)
 {
+    std::unique_lock<std::mutex> lock(loadMutex);
-    //std::lock_guard<std::mutex> lock(loadMutex);
+    // 他のスレッドが同じ画像をロード中であれば待機
-    for(const Sprite& s : sprites)
+    loadCV.wait(lock, [&filePath]()
     {
-        if(s.path == std::string(filePath))
+        for(const std::string& path : nowLoad)
         {
+            if (path == std::string(filePath))
+            {
+                return false;
+            }
+        }
+        return true;
+    });
+    //スプライトリストから取り出す
+    for (const Sprite& s : sprites)
+    {
+        if (s.path == std::string(filePath))
+        {
-            std::cout<<"found sprite"<<std::endl;
+            std::cout << "found sprite" << std::endl;
             return s;
         }
     }
-    std::cout<<"new sprite"<<std::endl;
-    SDL_Surface* image = IMG_Load(filePath);
-    sprites.push_back(Sprite{image,std::string(filePath)});
+    std::cout << "new sprite" << std::endl;
+    // ロード中の画像リストに追加
+    nowLoad.push_back(std::string(filePath));
+    lock.unlock();  // ロックを解除して他のスレッドがロードを開始できるようにする
+    //画像ロード
+    int milliseconds = 1000;
+    //int milliseconds = GetRandom(1000);
+    std::this_thread::sleep_for(std::chrono::milliseconds(milliseconds));
+    lock.lock();  // ロックを再取得して安全に状態を更新する
+    //ロードが終わったためリストから削除
+    int i = 0;
+    for(const std::string& s : nowLoad)
+    {
+        if(s == filePath)
+        {
+           break;
+        }
+        i++;
+    }
+    nowLoad.erase(nowLoad.begin() + i);
+    //ロード済みスプライトリストに追加
+    sprites.push_back(Sprite{ milliseconds, std::string(filePath) });
+    // 画像のロードが完了したことを通知
+    loadCV.notify_all();
     return sprites.back();
 }
-//////////////////////////////////////////////////////////////////////////////////////////////////////
+/*##############################################################
+# 同期　版
+# スプライトロード関数
+※　テスト用のためロード時間を乱数でミリ秒待機
+##############################################################*/
+Sprite Sync_LoadSprite(const char* filePath)
+{
+   //スプライトリストから取り出す
+    for (const Sprite& s : sprites)
+    {
+        if (s.path == std::string(filePath))
+        {
+            std::cout << "found sprite" << std::endl;
+            return s;
+        }
+    }
+    std::cout << "new sprite" << std::endl;
+    //画像ロード
+    int milliseconds =1000;
+    //int milliseconds = GetRandom(1000);
+    std::this_thread::sleep_for(std::chrono::milliseconds(milliseconds));
+   //ロード済みスプライトリストに追加
+    sprites.push_back(Sprite{ milliseconds, std::string(filePath) });
+    return sprites.back();
+}
+/*##############################################################
+# Component 基底
+##############################################################*/
 class Component
 {
 public:
@@ -80,70 +204,158 @@
     }
 };
+/*##############################################################
+# GameObject 基底
+##############################################################*/
+class GameObject
+{
+public:
+    GameObject()
+    {
+    }
+    std::vector<std::future<void>> getPreLoad()
+    {
+        std::vector<std::future<void>> futures;
-class PlayerControl : public Component
+        for(Component *c : components)
+        {
+            futures.push_back(std::async(std::launch::async,c->PreLoad()));
+        }
+        return futures;
+    }
+    void Update()
+    {
+    }
+    void Render()
+    {
+    }
+    std::vector<Component*> components;
+};
+/*##############################################################
+# Scene 基底
+##############################################################*/
+class Scene
 {
+public:
+    std::vector<GameObject*> gameObjects;
+    void Preaload()
+    {
+        std::vector<std::future<void>> futures;
+        for(GameObject *g : gameObjects)
+        {
+            for(std::future<void> &f : g->getPreLoad())
+            {
+                futures.push_back(std::move(f));
+            }
+        }
+        for(std::future<void> &f : futures)
+        {
+            f.wait();
+        }
+    }
+};
+/*##############################################################
+# Control コンポーネント
+##############################################################*/
+class Control : public Component
+{
 public:
-    PlayerControl(): Component()
+    Control(): Component()
     {
     }
-    virtual void (*PreLoad())() override
+    void (*PreLoad())() override
     {
         return []() ->void
         {
-            std::this_thread::sleep_for(std::chrono::seconds(1));
-            Sprite sp = LoadSprite("tile01.jpg");
-            std::cout<<"PlayerControl"<<std::endl;
+// 同期
+/*
+            auto startTime = std::chrono::high_resolution_clock::now();
+            Sprite sp1 = Sync_LoadSprite("tile1.jpg");
+            Sprite sp2 = Sync_LoadSprite("tile1.jpg");
+            Sprite sp3 = Sync_LoadSprite("tile2.jpg");
+            auto endTime = std::chrono::high_resolution_clock::now();
+            auto time = std::chrono::duration_cast<std::chrono::milliseconds>(endTime - startTime);
+            std::cout<<time.count()<<std::endl;
+*/
+//非同期
+            auto startTime = std::chrono::high_resolution_clock::now();
+            Sprite sp1 = LoadSprite("tile1.jpg");
+            Sprite sp2 = LoadSprite("tile1.jpg");
+            Sprite sp3 = LoadSprite("tile2.jpg");
+            auto endTime = std::chrono::high_resolution_clock::now();
+            auto time = std::chrono::duration_cast<std::chrono::milliseconds>(endTime - startTime);
+            std::cout<<time.count()<<std::endl;
         };
     }
 };
+/*##############################################################
+# Player ゲームオブジェクト
+##############################################################*/
-class EnemyControl : public Component
+class Player : public GameObject
 {
 public:
-    EnemyControl(): Component()
+    Player(): GameObject()
     {
+        components.push_back(new Control());
     }
+};
+/*##############################################################
+# Game シーン
+##############################################################*/
-    virtual void (*PreLoad())() override
+class Game : public Scene
+{
+public:
+    Game(): Scene()
     {
-        return []() ->void
-        {
-            std::this_thread::sleep_for(std::chrono::seconds(1));
+        gameObjects.push_back(new Player());
-            Sprite sp = LoadSprite("tile01.jpg")
-            std::cout<<"EnemyControl"<<std::endl;
-        };
     }
 };
 int main()
 {
-    Engine::Context::Init("Game",glm::ivec2(860,480));
-    std::vector<std::future<void>> futures;
+    Game *g = new Game();
-    PlayerControl player;
-    EnemyControl enemy;
+    g->Preaload();
-    futures.push_back(std::async(std::launch::async,enemy.PreLoad()));
-    futures.push_back(std::async(std::launch::async,player.PreLoad()));
-    for(std::future<void>& f : futures)
-    {
-        f.wait();
-    }
-    Engine::Context::Finalize();
     return 0;
 }
 ```

マルチスレッド C++SDL2 (Simple DirectMedia Layer2)