#75 wip: xboxビルドテスト v67

ienaga · ienaga · commit 1ebec3a6aa00 · 2026-07-09T12:28:11.000+09:00
diff --git a/templates/xbox/src/gpu/DawnContext.cpp b/templates/xbox/src/gpu/DawnContext.cpp
@@ -1,6 +1,11 @@
 #include "DawnContext.h"
 
 #include <Windows.h>
+#include <chrono>
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+#include <filesystem>
 #include <fstream>
 #include <iostream>
 #include <string>
@@ -41,6 +46,117 @@ void HandleUncapturedError(const wgpu::Device&, wgpu::ErrorType type, wgpu::Stri
     AppendGpuLog(line);
 }
 
+// --- GPU Blob キャッシュ (シェーダ/パイプラインのコンパイル結果) -------------
+// D3D12 の HLSL コンパイル (FXC) はパイプライン初回生成時に走り、起動直後や
+// 新しいエフェクト初出時のフレームヒッチの原因になる。Dawn の BlobCache を
+// %LOCALAPPDATA%\Next2D\gpucache に永続化し、2 回目以降の起動で再利用する
+// (V8 バイトコードキャッシュの GPU 版)。
+// 呼び出し規約 (dawn/native/BlobCache.cpp LoadInternal で検証済み):
+//   load は 2 段階 — まず value=nullptr でサイズ問い合わせ (戻り値 0 = miss)、
+//   次に確保済みバッファへの読み込み (戻り値がサイズと不一致なら miss 扱い)。
+// キーには Dawn がアダプタ/ドライバ情報を織り込むため、環境が変われば自然に
+// 別エントリになる。あらゆる失敗は 0 / 何もしない (graceful degrade)。
+
+uint64_t Fnv1a(const void* data, size_t size, uint64_t hash = 1469598103934665603ull)
+{
+    const auto* p = static_cast<const unsigned char*>(data);
+    for (size_t i = 0; i < size; ++i) {
+        hash ^= p[i];
+        hash *= 1099511628211ull;
+    }
+    return hash;
+}
+
+const std::filesystem::path& GpuCacheDir()
+{
+    static const std::filesystem::path dir = []() -> std::filesystem::path {
+        const char* base = std::getenv("LOCALAPPDATA");
+        if (!base || !*base) {
+            return {};
+        }
+        std::error_code ec;
+        std::filesystem::path d = std::filesystem::path(base) / "Next2D" / "gpucache";
+        std::filesystem::create_directories(d, ec);
+        if (ec) {
+            return {};
+        }
+        // ドライバ/Dawn 更新でキーが変わると旧 blob は孤児になる。
+        // 30 日アクセスの無い .blob を掃除する (load ヒット時に touch する LRU)。
+        const auto now = std::filesystem::file_time_type::clock::now();
+        std::error_code iter_ec;
+        for (const auto& entry : std::filesystem::directory_iterator(d, iter_ec)) {
+            std::error_code e2;
+            if (entry.path().extension() != ".blob") {
+                continue;
+            }
+            const auto t = std::filesystem::last_write_time(entry.path(), e2);
+            if (!e2 && now - t > std::chrono::hours(24 * 30)) {
+                std::filesystem::remove(entry.path(), e2);
+            }
+        }
+        return d;
+    }();
+    return dir;
+}
+
+std::filesystem::path GpuCacheFileFor(const void* key, size_t key_size)
+{
+    const std::filesystem::path& dir = GpuCacheDir();
+    if (dir.empty()) {
+        return {};
+    }
+    char buf[17] = {};
+    std::snprintf(buf, sizeof(buf), "%016llx",
+                  static_cast<unsigned long long>(Fnv1a(key, key_size)));
+    return dir / (std::string(buf) + ".blob");
+}
+
+size_t LoadGpuCacheData(const void* key, size_t key_size,
+                        void* value, size_t value_size, void*)
+{
+    const std::filesystem::path file = GpuCacheFileFor(key, key_size);
+    if (file.empty()) {
+        return 0;
+    }
+    std::error_code ec;
+    const auto size = std::filesystem::file_size(file, ec);
+    if (ec || size == 0) {
+        return 0;
+    }
+    if (value == nullptr) {
+        // 1 段階目: サイズ問い合わせ
+        return static_cast<size_t>(size);
+    }
+    if (value_size < size) {
+        return 0;
+    }
+    std::ifstream ifs(file, std::ios::binary);
+    if (!ifs || !ifs.read(static_cast<char*>(value), static_cast<std::streamsize>(size))) {
+        return 0;
+    }
+    // 使用時に touch して 30 日掃除を LRU として機能させる
+    std::filesystem::last_write_time(
+        file, std::filesystem::file_time_type::clock::now(), ec);
+    return static_cast<size_t>(size);
+}
+
+void StoreGpuCacheData(const void* key, size_t key_size,
+                       const void* value, size_t value_size, void*)
+{
+    if (!value || value_size == 0) {
+        return;
+    }
+    const std::filesystem::path file = GpuCacheFileFor(key, key_size);
+    if (file.empty()) {
+        return;
+    }
+    std::ofstream ofs(file, std::ios::binary | std::ios::trunc);
+    if (ofs) {
+        ofs.write(static_cast<const char*>(value),
+                  static_cast<std::streamsize>(value_size));
+    }
+}
+
 } // namespace
 
 DawnContext::~DawnContext() = default;
@@ -117,6 +233,14 @@ bool DawnContext::AcquireDevice()
     device_desc.SetDeviceLostCallback(wgpu::CallbackMode::AllowProcessEvents, HandleDeviceLost);
     device_desc.SetUncapturedErrorCallback(HandleUncapturedError);
 
+    // GPU Blob キャッシュを接続する (シェーダコンパイル結果の永続化)。
+    // 関数ポインタは Dawn が device 生成時に BlobCache へコピーするため、
+    // この記述子自体は RequestDevice 完了までの生存で足りる。
+    wgpu::DawnCacheDeviceDescriptor cache_desc = {};
+    cache_desc.loadDataFunction  = LoadGpuCacheData;
+    cache_desc.storeDataFunction = StoreGpuCacheData;
+    device_desc.nextInChain = &cache_desc;
+
 #ifdef NDEBUG
     // Release では Dawn の API 検証 (skip_validation) と robustness (OOB クランプ) を
     // 無効化する。両方とも全描画コマンドのエンコードで毎フレーム CPU を消費する
@@ -128,7 +252,7 @@ bool DawnContext::AcquireDevice()
     wgpu::DawnTogglesDescriptor device_toggles = {};
     device_toggles.enabledToggles     = kReleaseToggles;
     device_toggles.enabledToggleCount = 2;
-    device_desc.nextInChain = &device_toggles;
+    cache_desc.nextInChain = &device_toggles;  // device -> cache -> toggles
 #endif
 
     wgpu::Future device_future = adapter_.RequestDevice(
diff --git a/templates/xbox/src/main.cpp b/templates/xbox/src/main.cpp
@@ -30,6 +30,7 @@
 #include <iostream>
 #include <sstream>
 #include <string>
+#include <cstdio>
 #include <cstring>
 
 namespace fs = std::filesystem;
@@ -38,6 +39,56 @@ using namespace next2d;
 namespace {
 
 bool g_running = true;
+
+// --- --perf: フレーム統計 ---------------------------------------------------
+// メインループの各区間の所要時間 (ms) を集計し、300 フレーム毎に 1 行で出力する。
+// avg でボトルネックの区間を、max でヒッチ (スパイク) の在り処を特定する。
+// GUI 実行では stderr が見えないため next2d-perf.log にも追記する。
+struct PerfSection {
+    double sum = 0.0;
+    double max = 0.0;
+    void Add(double ms)
+    {
+        sum += ms;
+        if (ms > max) {
+            max = ms;
+        }
+    }
+};
+
+struct PerfStats {
+    static constexpr int kWindow = 300;   // 60fps で約 5 秒
+    PerfSection tasks;     // 入力/音声/タイマー/マイクロタスク
+    PerfSection js;        // メイン rAF (アプリロジック/描画コマンド生成)
+    PerfSection worker;    // レンダラ worker (WebGPU コマンド発行 + submit)
+    PerfSection tick;      // V8 プラットフォームタスク + Dawn Tick
+    PerfSection present;   // Present (GPU/VSync 待ちを含む)
+    PerfSection busy;      // 上記合計 (ペーシング Sleep を除く実働)
+    PerfSection frame;     // フレーム間隔 (実効フレームレートの逆数)
+    int frames = 0;
+
+    void Flush()
+    {
+        if (frames == 0) {
+            return;
+        }
+        const auto avg = [this](const PerfSection& s) { return s.sum / frames; };
+        char line[320];
+        std::snprintf(line, sizeof(line),
+            "[perf] frame %.1fms (max %.1f) busy %.1fms | "
+            "tasks %.2f/%.1f js %.2f/%.1f worker %.2f/%.1f "
+            "tick %.2f/%.1f present %.2f/%.1f (avg/max, %d frames)",
+            avg(frame), frame.max, avg(busy),
+            avg(tasks), tasks.max, avg(js), js.max, avg(worker), worker.max,
+            avg(tick), tick.max, avg(present), present.max, frames);
+        std::cerr << line << std::endl;
+        std::ofstream ofs("next2d-perf.log", std::ios::app);
+        if (ofs) {
+            ofs << line << std::endl;
+        }
+        *this = PerfStats{};
+    }
+};
 DawnContext* g_dawn = nullptr;
 HostContext* g_host = nullptr;
 V8Runtime* g_runtime = nullptr;
@@ -318,6 +369,11 @@ int WINAPI wWinMain(HINSTANCE instance, HINSTANCE, PWSTR cmd_line, int)
     // 実機/PC(GDK) 上で検証して終了する (テスト完了で自動終了)。
     const bool selftest = cmd_line && wcsstr(cmd_line, L"--selftest") != nullptr;
 
+    // --perf: フレーム統計を 300 フレーム (約 5 秒) 毎に stderr と next2d-perf.log
+    // へ出力する。どの区間 (JS / レンダラ worker / GPU / Present) にフレーム時間を
+    // 使っているかを数値化し、以降の最適化 (worker 並列化等) の要否判断に使う。
+    const bool perf = cmd_line && wcsstr(cmd_line, L"--perf") != nullptr;
+
     // 1. GDK ランタイム初期化。
     // デスクトップでは Gaming Services 未導入の環境 (CI ランナー等) でも
     // 起動できるよう、失敗を警告に留めて続行する (本ホストは XUser 等を未使用)。
@@ -459,6 +515,8 @@ int WINAPI wWinMain(HINSTANCE instance, HINSTANCE, PWSTR cmd_line, int)
     // 7. ゲームループ
     MSG msg = {};
     int exit_code = 0;
+    PerfStats perf_stats;
+    double perf_prev_frame = 0.0;
     // Isolate::Scope はループ内に限定する。Enter されたままの isolate を
     // Dispose すると V8 の fatal (Disposing the isolate that is entered) になる。
     {
@@ -478,6 +536,17 @@ int WINAPI wWinMain(HINSTANCE instance, HINSTANCE, PWSTR cmd_line, int)
 
         const double now = event_loop.Now();
 
+        // --perf: 直前の計測点からの経過を各区間へ記録する軽量マーカー
+        double perf_cursor = now;
+        const auto perf_mark = [&](PerfSection& section) {
+            if (!perf) {
+                return;
+            }
+            const double t = event_loop.Now();
+            section.Add(t - perf_cursor);
+            perf_cursor = t;
+        };
+
         v8::HandleScope handle_scope(runtime.isolate());
         v8::Local<v8::Context> ctx = runtime.context();
         v8::Context::Scope context_scope(ctx);
@@ -491,21 +560,37 @@ int WINAPI wWinMain(HINSTANCE instance, HINSTANCE, PWSTR cmd_line, int)
         // タイマー -> マイクロタスク
         event_loop.PumpTimers();
         runtime.PumpMicrotasks();
+        perf_mark(perf_stats.tasks);
 
         // メインスレッドの requestAnimationFrame (アプリのロジック/描画コマンド生成)
         event_loop.RunAnimationFrame(now);
         runtime.PumpMicrotasks();
+        perf_mark(perf_stats.js);
 
         // Worker (レンダラ等) のメッセージ配送 + rAF。
         // レンダラ worker はここで WebGPU コマンドを発行し submit する。
         workers.Pump(now);
+        perf_mark(perf_stats.worker);
 
         // V8 プラットフォームタスク + Dawn の非同期処理
         runtime.PumpPlatformTasks();
         dawn.Tick();
+        perf_mark(perf_stats.tick);
 
         // 提示
         dawn.Present();
+        perf_mark(perf_stats.present);
+
+        if (perf) {
+            perf_stats.busy.Add(perf_cursor - now);
+            if (perf_prev_frame > 0.0) {
+                perf_stats.frame.Add(now - perf_prev_frame);
+            }
+            perf_prev_frame = now;
+            if (++perf_stats.frames >= PerfStats::kWindow) {
+                perf_stats.Flush();
+            }
+        }
 
         // フレームペーシング: ブラウザの rAF 同様 ~60Hz に揃える。
         // Present はスキップ時にブロックしないため、これが無いとループが
