---
title: RE ENGINEのC++とC#～高速開発と高性能を支える技術 [RE:2026 2026年10月2日登壇]
tags:  #capcom #カプコン技研 #カプコン #re engine #re2026capcom #ゲーム開発 #ゲームエンジン #プログラミング言語 #il2cpp  
author: [カプコン技研](https://image.docswell.com/user/CAPCOM_RandD)
site: [Docswell](https://www.docswell.com/)
thumbnail: https://bcdn.docswell.com/page/9J2RGP837R.jpg?width=480
description: 2026年10月にカプコンが開催した「CAPCOM オープンカンファレンス RE:2026」の講演資料です。  ■ 講演映像 https://www.youtube.com/watch?v=m4RYHfjuvv8&amp;list=PLD_N6X6tKlCM
published: November 20, 26
canonical: https://image.docswell.com/s/CAPCOM_RandD/59NP2W-RE2026-WEST-2
---
# Page. 1

![Page Image](https://bcdn.docswell.com/page/9J2RGP837R.jpg)

RE ENGINEのC++とC#
〜素早い移植と⾼性能を⽀える技術
⽊本 雅博
平塚 恒輝


# Page. 2

![Page Image](https://bcdn.docswell.com/page/DEYDV568EM.jpg)

RE ENGINEのC++とC#
〜素早い移植と⾼性能を⽀える技術
⽊本 雅博
平塚 恒輝
では、RE2026、RE ENGINEのC++とC#、素早い移植と⾼性能を⽀える技術、という題で⽊本と、共同執筆者である平塚より発表させていただきます。
1


# Page. 3

![Page Image](https://bcdn.docswell.com/page/VJN6MNZ9J8.jpg)

アジェンダ
RE ENGINEの
runtime
RE ENGINEの
スクリプトシステム
 RE ENGINE runtimeの今
 スクリプトシステム概要
 C++20の活⽤事例
 開発時︓イテレーションの⾼速化
 C++20への道
 製品時︓独⾃のIL2CPP
 ビルドの維持
 製品時︓IL2CPPによる最適化
2
こちらが本⽇のアジェンダとなります。
RE ENGINEでは、C++で実装された実⾏環境であるruntimeと、その上で動作するC#スクリプトでゲームを実装しています。
C++については、現在どういう環境で開発されているかと、C++20について触れ、最後にビルド環境についてお話させていただきます。
C#については、開発時と製品時での挙動の違いや、製品向けに独⾃に実装したIL2CPPでの最適化についてお話します。
2


# Page. 4

![Page Image](https://bcdn.docswell.com/page/YE9LNRZ373.jpg)

3
では、まずは実⾏環境であるruntimeについてお話します。
3


# Page. 5

![Page Image](https://bcdn.docswell.com/page/GE8XKW1LJD.jpg)

RE ENGINEの
runtime
RE ENGINEの
スクリプトシステム
 RE ENGINE runtimeの今
 スクリプトシステム概要
 C++20の活⽤事例
 開発時︓イテレーションの⾼速化
 C++20への道
 製品時︓独⾃のIL2CPP
 ビルドの維持
 製品時︓IL2CPPによる最適化
4
これからお話するのは、C++側のお話となります。
4


# Page. 6

![Page Image](https://bcdn.docswell.com/page/LEL8ZNQQ7R.jpg)

5
まず、RE ENGINEのruntimeの今の姿についてお話します。
5


# Page. 7

![Page Image](https://bcdn.docswell.com/page/4JM6VQKKEW.jpg)

【C++】RE ENGINE runtimeの今
BIOHAZARD 7の歩み
 ゲーム専⽤機
PlayStation 4 / PlayStation 5 / XBOX One /
XBOX Series X|S / Nintendo Switch 2
 クラウドゲーミング
Nintendo Switch / Amazon Luna /
Google Stadia
RE ENGINE初タイトルのBIOHAZARD 7は
2017年以来、毎年100万本以上の販売を達成。
複数回のプラットフォーム追加と対応⾔語
追加でユーザーを拡⼤してきた。
 モバイル
iOS
 対応⾔語︓15ヶ国語
6
RE ENGINEの初タイトルであるBIOHAZARD 7は、2017年の発売以来、毎年100万本以上の販売を達成しています。
これまで複数回のプラットフォーム追加で、ゲーム専⽤機については5プラットフォーム、
クラウドゲーミングについては3プラットフォーム、そしてモバイルも含め、幅広いハードに展開しています。
また、⾔語についても15ヶ国語に対応しています。
6


# Page. 8

![Page Image](https://bcdn.docswell.com/page/PJRP28X6E9.jpg)

【C++】RE ENGINE runtimeの今
素早い移植を⽀えるRE ENGINEの互換性維持
RE ENGINEの設計⽅針
 1つのエンジンで全てのタイトルを開発
• タイトル独⾃のエンジンコード変更を禁⽌
• タイトルでの最適化は全体向けに昇華
 モジュラー構造
エンジンの対応プラットフォーム追加で、
タイトルの対応プラットフォームが増える
 下位互換性の維持
•
全ての既存タイトルが最新エンジンで
動作することを保証
関連資料
他タイトルの最適化の恩恵が
受けられる
【CAPCOM RE:2019】複数のAAAタイトル開発に耐える汎⽤ゲームエンジンの設計と運⽤
https://www.youtube.com/watch?v=fc3avwM-oTE
7
このように多くのプラットフォーム、多くの⾔語でのリリースを⽀えるのが、素早い移植を⽀えるRE ENGINEの互換性維持の考え⽅です。
RE:2019の「複数のAAAタイトル開発に耐える汎⽤ゲームエンジンの設計と運⽤」でも触れている内容ですが、
RE ENGINEの設計⽅針として、1つのエンジンで全てのタイトルを開発する、というものがあります。
タイトル独⾃のエンジンコード変更は禁⽌しています。
⼀⽅で、タイトル向けの最適化は全体に恩恵が受けられるように昇華して取り込むようになっています。
後ほど触れますがモジュラー構造であることも重要なポイントとなります。
また、下位互換性の維持を掲げています。
下位互換性の維持により、全ての既存タイトルが最新のエンジンで動作することを保証しています。
そのため、エンジンの対応プラットフォームが追加されると、タイトルの対応プラットフォームを増やせるわけです。
また、他タイトルで実施された最適化の恩恵を受けられるため、過去タイトルを改めて出すときに⾃然と最適化されていることが多々あります。
7


# Page. 9

![Page Image](https://bcdn.docswell.com/page/PEX3D86DJX.jpg)

【C++】RE ENGINE runtimeの今
RE ENGINE runtimeの開発環境
 IDE
• Visual Studio
• Xcode
• Android Studio
- Mac / iOS で利⽤
- Android で利⽤
 コンパイラー
CL / Clang-CL / Clang
 C++20
8
この後の説明のために、RE ENGINEのruntimeの開発環境を紹介します。
IDEには、主にVisual Studioを使⽤していますが、Mac/iOSの開発にはXcode、Androidの開発にはAndroid Studioを利⽤しています。
また、コンパイラーは主にCL/Clang-CL/Clangを利⽤しています。
また、後ほど詳しく触れますが、C++のバージョンは20になっています。
8


# Page. 10

![Page Image](https://bcdn.docswell.com/page/3EKYXK1DJD.jpg)

【C++】RE ENGINE runtimeの今
標準ライブラリの利⽤状況
全プラットフォームで使えるものを、RE ENGINE向けの名前空間に移植して使っている。
これによりコードの移植性を⾼めている。
namespace RE
{
using std::atomic; // 全プラットフォームで使えるものはそのまま使う
template &lt;…&gt;
class unordered_map : std::unordered_map&lt;…&gt;
{
public:
bool contains(…); // プラットフォームによっては未実装のものを追加する
};
}
9
次に、C++の標準ライブラリは使っているのか、というお話をしたいと思います。
ゲーム業界では標準ライブラリは使えないんですよね、といった質問をされることもありますが、バリバリ使っています。
ただし、RE ENGINE向けに⽤意した名前空間に移植したものだけを使っています。
これは、プラットフォームによってコンパイラーのバージョンに違いがあり、⼀部ライブラリの機能が実装されていなかったりするためです。
RE ENGINE向け名前空間にあるものは、RE ENGINEがサポートしている全プラットフォームで使えることを保証したものだけになっている、というわけです。
これにより、どのプラットフォーム、どのコンパイラーでもビルドが通るため、移植性が⾼まります。
例えば、std::atomicのように全プラットフォームで問題無く使えるものはそのまま使います。
他にも、C++17の時代に、C++20で追加されたcontainsが便利なので先に使いたいと⾔われた場合は、
このようにラッパークラス側に追加してしまうことで、簡単に提供可能です。
なお、この名前空間は適当に付けただけで、実際の名前空間ではありません。
9


# Page. 11

![Page Image](https://bcdn.docswell.com/page/L7395ZQP75.jpg)

【C++】RE ENGINE runtimeの今
標準ライブラリの先⾏実装
便利な機能は必要に応じて先取りする。
 is_constant_evaluated
namespace RE
{
(C++20)
#if __cpp_lib_is_constant_evaluated
• コンパイラーの機能で実装可能
• CLでもClangでも同じ組み込み機能を
実装しているケースが増えている
#else
using std::is_constant_evaluated;
constexpr bool is_constant_evaluated()
{
 is_scoped_enum (C++23)
• 既存のtype_traitsの組合せで
実装可能
return __builtin_is_constant_evaluated();
}
#endif
}
10
先ほど触れたcontainsのように、便利な機能は必要に応じて先取りすることもあります。
ここでは、簡単な例として、is_constant_evaluatedを紹介します。
最近はVisual StudioにClangが取り込まれた結果、同じ名前の組み込み機能で実装されるケースが増えているので、
それを利⽤するだけでC++20で組み込まれる標準ライブラリの機能が、CL/Clangの区別をしなくても、C++20になる前から使えました。
他にも、is_scoped_enumのように既存のtype_traitsを組み合わせるだけなのでC++23を待つまでもなく使えるようにしたりしています。
10


# Page. 12

![Page Image](https://bcdn.docswell.com/page/87DGDR937G.jpg)

【C++】RE ENGINE runtimeの今
C++のバージョンを上げるモチベーション
RE ENGINEでは、互換性を重視しつつも、C++のバージョンは可能な限り上げており、
現在はC++20を使っている。
 追加されていく標準ライブラリを活⽤したい
•
標準ライブラリはどのプラットフォームでもそのまま使えることが多い
 conceptによりSFINAEを減らしたい
•
各モジュールの担当者は機能の専⾨家でC++の専⾨家ではない
•
より簡潔に書けることは喜ばしい
 コンパイル時に計算できることが増えて、パフォーマンス向上が⾒込める
 コンパイラーのバージョンアップでのデフォルト⾔語バージョンの変更に追従したい
11
RE ENGINEでは、互換性を維持することを重視しつつ、C++のバージョンについては可能な限り上げるようにしており、
先ほども述べたように現在はC++20を使っています。
C++のバージョンを上げるモチベーションの⼀つは、追加されていく標準ライブラリを活⽤したい、ということがあります。
標準ライブラリは、どのプラットフォームでもそのまま使えることが多いため、移植しやすいコードを書く上でも活⽤したいところです。
また、C++20で⼊ったconceptを活⽤することでSFINAEのような書き⽅を減らしたい、というのもあります。
レンダリングの担当者はレンダリングの、サウンドの担当者はサウンドの専⾨家であって、C++の専⾨家ではありません。
より簡潔に書けて、エラーメッセージなどが分かりやすくなる⽅が専⾨領域に集中してもらえます。
更に、C++のバージョンが上がるほどコンパイル時に計算できることが増えるため、パフォーマンス向上に寄与します。
また、コンパイラーのバージョンアップによって、デフォルト⾔語バージョンが上がっていくため、それに追従していけるようにする、というのもあります。
ちゃんと追従しておかないと、ある⽇突然コンパイルエラーになったんだけど、という報告が来てしまいます。
最後に、書いてないのですが、⼀番のモチベーションは⾃分が使いたいからです。やはり新しい機能を使いたいですよね。
11


# Page. 13

![Page Image](https://bcdn.docswell.com/page/VJP3XWZPE8.jpg)

RE ENGINEの
runtime
RE ENGINEの
スクリプトシステム
 RE ENGINE runtimeの今
 スクリプトシステム概要
 C++20の活⽤事例
 開発時︓イテレーションの⾼速化
 C++20への道
 製品時︓独⾃のIL2CPP
 ビルドの維持
 製品時︓IL2CPPによる最適化
12
続いて、C++20の活⽤事例に触れた上で、C++20への移⾏についてお話します。
12


# Page. 14

![Page Image](https://bcdn.docswell.com/page/2EV4L8WVJQ.jpg)

13
では、実際にC++20を活⽤した例を紹介したいと思います。
13


# Page. 15

![Page Image](https://bcdn.docswell.com/page/57G1X5D1EL.jpg)

【C++】C++20の活⽤事例
コンパイル時に⽂字列を組み合わせてハッシュを計算（1/3）
C++20で可変サイズコンテナのconstexpr化が許可されたため、コンパイル時⽂字列構築が容易になった。
シェーダーのバリエーション名をコンパイル時に構築することで、管理しやすく抜け漏れ無しに。
auto shaderHashes = combinatorial_hash(
&quot;Draw&quot;,
// ベース
{ &quot;Line&quot;, &quot;Dots&quot; },
// 線の種類
{ &quot;Red&quot;, &quot;Green&quot;, &quot;Blue&quot; } // ⾊
);
auto shader = findShader(shaderHashes[LineType][LineColor]);
14
C++20で活⽤したい機能の⼀つとして、可変サイズコンテナのconstexpr化があります。
これにより、コンパイル時の⽂字列構築が容易になりました。
これを活⽤することで、例えばこのようにシェーダーのバリエーション名をコンパイル時に構築し、ハッシュ値を計算しておくのを楽にできます。
この例だと、DrawLineRed, DrawLineGreen, DrawLineBlueとDrawDotsRed, DrawDotsGreen, DrawDotsBlueの6パターンのハッシュ値が
2x3の配列として⽣成されます。
ハッシュ値からシェーダーを⾒つけるfindShaderを使う場合に、バリエーションに合わせてどのハッシュ値を使うか、というのを
if⽂ではなく配列から取り出すことで、分岐を減らすことができます。
14


# Page. 16

![Page Image](https://bcdn.docswell.com/page/4EQD8Z1NJP.jpg)

【C++】C++20の活⽤事例
コンパイル時に⽂字列を組み合わせてハッシュを計算（2/3）
Variadic templateにより様々なサイズの配列を受け取れる。
template &lt;size_t N&gt;consteval auto
combinatorial_hash(
const string base,
const string (&amp;variation)[N]);
template &lt;size_t N, size_t... M&gt;
consteval auto combinatorial_hash(
const string base,
const string (&amp;variation)[N],
const string (&amp;...restVariation)[M]);
15
詳細な実装については述べませんが、実装のポイントとして、Variadic templateで様々なサイズの配列を受け取るためのインターフェースを紹介します。
まず、最初のインターフェースはバリエーションを配列として受け取ります。
このとき、関数ポインタのように名前を丸括弧で囲んで参照として配列を渡すことでサイズが推論できるようになります。
このインターフェースは、Variadic templateで再帰的に関数を呼び出す場合の終端として機能します。
次に、N以外のサイズの配列も受け取れるインターフェースを⽤意します。
それぞれ違うサイズを取ることを⽰すために、テンプレートパラメータにはsize_tのあとに...を書きます。
ここがポイントなのですが、このテンプレートパラメータを展開する場合、配列の名前の前、&amp;のあとに...を書きます。
後は再帰的に呼びだしながら、⽂字列を構築し、ハッシュ値を計算し、配列を埋めていくだけです。
返り値の型はautoにして推論に任せています。
15


# Page. 17

![Page Image](https://bcdn.docswell.com/page/KJ4Z23R371.jpg)

【C++】C++20の活⽤事例
コンパイル時に⽂字列を組み合わせてハッシュを計算（3/3）
パターンを増やし過ぎるとコンパイラーのコンパイル時計算の上限を突破することがあるが、
上限はコンパイルオプションで増やせる。
CL
/constexpr:steps N
Clang
-fconstexpr-steps=N
分散ビルドツールで消えることが
あったため “/constexpr:steps N”
と囲むのが吉
増やし過ぎるとビルド時間が延びるため注意が必要
16
さて、このcombinatorial_hashを最初に作ったときは、そんなに何段もバリエーションを作ることは無いと思っていたのですが、
8段のバリエーションを持つこともあるそうで、コンパイラーのコンパイル時計算の上限を突破してしまいました。
そう、上限があるんですよね。通常遭遇することは無いと思います。
幸い、CLにもClangにもconstexprの上限を設定する機能があったので事なきを得ました。
CLの場合は/constexpr:stepsで指定できます。ただし、分散ビルドツールによってはこの空⽩を消したりして上⼿く動作しないケースがあったので、
ダブルクオーテーションで囲っておくのが良さそうです。
Clangの場合は-fconstexpr-stepsで指定できます。
ただし、増やし過ぎるとビルド時間が延びるのでビルドが通る適当な数を探るようにしてください。
16


# Page. 18

![Page Image](https://bcdn.docswell.com/page/LE1RM1QZEG.jpg)

17
では、RE ENGINEは順調にC++20までバージョンを上げてきたのかというと、そういうわけでもありません。
ここからは、C++20に対応するまでのお話をしたいと思います。
17


# Page. 19

![Page Image](https://bcdn.docswell.com/page/GEW138M672.jpg)

【C++】C++20への道
RE ENGINE混沌期
CLではC++20以降、C++標準への準拠が強化される。 (つまり以前は準拠していない)
Clang向けにはCLに合わせた警告の緩和が⾏われていた。
(delayed-template-parsingなど)
C++標準に準拠させると
ビルドが通らないコードが散⾒された。
•
インスタンス化されないテンプレート内にカンマや
セミコロンが無いコードがあった
•
for eachのようなコンパイラーに依存した拡張が使われていた
コンパイラーに怒られないとキレイなコードを維持するのは難しい
18
RE ENGINE混沌期、
CLでは、C++20以降でC++標準への準拠が強化されます。つまり、それより前は標準準拠でない部分があるということです。
RE ENGINEでは、より標準準拠に厳しいClang向けにはCLに合わせるために警告緩和を⼊れていました。
例としては、テンプレートの解析タイミングを変更するdelayed-template-parsingなどです。
これをC++標準に準拠させるようにすると、ビルドが通らないコードが散⾒されました。
インスタンス化されていないテンプレート内にカンマやセミコロンが無い。
for eachのようにCL拡張が使われていたりもしました。
RE ENGINEの開発者であっても、コンパイラーが怒らないとキレイなコードを維持するのは難しいのです。
18


# Page. 20

![Page Image](https://bcdn.docswell.com/page/47ZPV8QRE3.jpg)

【C++】C++20への道
C++20への移⾏までのフロー
CLの標準準拠モードを活⽤し、コードをキレイにした後に
C++17、C++20へと移⾏した。
標準準拠
C++17
C++20
19
そこで、まずはCLの標準準拠モードを活⽤してコードをキレイにしてから、順次C++17、C++20へと移⾏しました。
19


# Page. 21

![Page Image](https://bcdn.docswell.com/page/YJ6M5P617V.jpg)

【C++】C++20への道
標準準拠の強化
依存関係のルートとなるモジュールから順に、じわじわと標準準拠モードへの切り替えを⾏った。
 ⼤きな変更はレビューを難しいものにしてしまうし動作保証も難しい
 OSSのバージョンアップ
•
互換性維持のために基本的にはバージョンを固定している
•
古いバージョンのものでは標準準拠できないケースでのみ
バージョンアップした
 for each (Microsoft拡張)の排除
 右辺値のアドレス取得
 delayed-template-parsingの排除
20
RE ENGINEはモジュール単位で分割されていますが、モジュール間には依存関係があるので、
依存関係のルートから順に幅優先でじわじわと標準準拠モードへと切り替え、ビルドエラーをつぶしていきました。
まとめて変更すると、レビューも難しく、動作保証も難しいです。
また、基本的には互換性維持のためにOSSもバージョンを固定しているのですが、古いままだとC++の新しいバージョンに対応できないケースがあり、
その場合にはバージョンアップを⾏いました。
他には、for eachというMicrosoft拡張を使っている箇所があったり、右辺値のアドレス取得があったりしました。
右辺値は消えてしまうのでアドレスを保持されると困りますよね。
それでも運良く動いていると気付かないものなのです。
delayed-template-parsingについては、少しややこしい話なので次のページでもう少し詳しくお話します。
20


# Page. 22

![Page Image](https://bcdn.docswell.com/page/GJ5ZYK6LE4.jpg)

【C++】C++20への道
delayed-template-parsingの排除
CLではテンプレートがインスタンス化されるまでは、チェックできる構⽂エラーもチェックしない。
 Clangにはこの挙動を模倣するdelayed-template-parsingを指定していた
標準準拠モードではエラーになるため、無事delayed-template-parsingを取り除けた。
template&lt;class T&gt;
size_t rarely_called_function(T v)
{
char tmp v; // 代⼊忘れ
}
return tmp // セミコロン忘れ
問題のあるコードを増殖させるような設定を⼊れてはいけない
21
本来、C++ではテンプレートパラメーターに依存しない部分はテンプレートであっても構⽂チェックが⾏われるのですが、
CLはテンプレートがインスタンス化されるまでチェックしない、という⽅針を取っていました。
元々CLベースでRE ENGINEを開発していて、後々Clangでビルドするときに問題になったため、
この挙動を模倣するdelayed-template-parsingというオプションを指定していました。
時は流れ、CLに標準準拠モードが導⼊されると、この挙動はエラー扱いになったため、無事delayed-template-parsingを取り除くことができました。
といっても、例にあるように、代⼊忘れやセミコロン忘れのような単純なものも含め、いろいろと修正が必要でした。
というわけで、問題のあるコードを増殖させてしまうような設定は原則⼊れない、⼊れても早めに取り除く、ということが⼤事です。
21


# Page. 23

![Page Image](https://bcdn.docswell.com/page/LE395ZQDE5.jpg)

【C++】C++20への道
C++17への移⾏
標準準拠のおかげで、
⼤きく変化する部分の対応だけで完了。
 std::allocator, std::iterator, std::result_ofの削除への対応
 registerキーワードの削除
•
レジスターを使うための最適化キーワードだったがC++11で
⾮推奨になりC++17で削除された
22
標準準拠によってコードをキレイにしたことで、C++17への移⾏は破壊的変更となる部分だけで済みました。
標準ライブラリから消えた、std::allocator，std::iterator，std::result_ofの削除への対応と、registerキーワード削除への対応です。
registerキーワードは最近⾒かけなくなったので知らない⽅もいるかもしれません。
これは、指定した変数についてはレジスターを積極的に使うように、とコンパイラーに指⽰することで、最適化を促すものだったのですが、
C++11時点で⾮推奨となっており、まさか使っている⼈がいるとは思いもよらなかったのですが、特に指定している理由もなかったようなので削除しました。
22


# Page. 24

![Page Image](https://bcdn.docswell.com/page/8EDGDR92EG.jpg)

【C++】C++20への道
C++17からC++20へ
どうしてもC++20に切り替えるタイミングで対応するしかない変更があった。
 enumから整数への暗黙変換禁⽌
•
間違って変換しているケースや、違うenumの組合せが発⾒された
 lambdaでのthisキャプチャの変化
•
[=]でのthisキャプチャから[=, this]へ
•
•
ClangではC++17でもC++20拡張だという警告を無視すれば使えたが
CLでは使えないため、C++20でまとめて変更
こうしてC++20が使えるキレイな環境が出来上がった
23
C++17からC++20も簡単だったかというとそうではありません。
どうしてもC++20に切り替えたタイミングでまとめて変更するしかないものがありました。
例えば、enumから整数への暗黙変換禁⽌については、C++17では合法なため、警告を抑えることを検討しました。
しかし、間違った変換や間違えてenumを組み合わせているケースが⾒つかったため、C++20に移⾏するまでは定期的に間引いていました。
また、lambdaでのthisキャプチャの書き⽅の変化も問題でした。
ClangではC++17で書くとC++20拡張だという警告が出るのですが、CLでは同様の警告が無かったため、C++20でまとめて変更するしかありませんでした。
いくつかの⼭を乗り越え、何とかC++20が使える環境が出来上がりました。
23


# Page. 25

![Page Image](https://bcdn.docswell.com/page/V7P3XWZLJ8.jpg)

RE ENGINEの
runtime
RE ENGINEの
スクリプトシステム
 RE ENGINE runtimeの今
 スクリプトシステム概要
 C++20の活⽤事例
 開発時︓イテレーションの⾼速化
 C++20への道
 製品時︓独⾃のIL2CPP
 ビルドの維持
 製品時︓IL2CPPによる最適化
24
最後に、runtimeのビルド維持のお話に移ります。
24


# Page. 26

![Page Image](https://bcdn.docswell.com/page/2JV4L8W67Q.jpg)

25
ここまで⾔語バージョンを上げる話をしましたが、各種プラットフォームのSDKや開発環境も⽇々更新されているので、
それらに追従しつつ、RE ENGINEの開発チームが安定してビルドできる環境を維持することも重要です。
25


# Page. 27

![Page Image](https://bcdn.docswell.com/page/5EG1X5D2JL.jpg)

【C++】ビルドの維持
Visual Studioのバージョンを固定する
安定してパッケージをビルドできるVisual Studioのバージョンを共有している。
トラブル事例（Visual Studio 2022）
 Clang-CLのメジャーバージョンが
(観測した範囲で)17から19まで変わっている
•
メジャーバージョン更新により、警告が増えてビルドエラーに
 ⾏数オーバーによる最適化時のクラッシュが発⽣
 17.10ではSTLの破壊的変更によりバージョン違いを混ぜると
クラッシュすることがあった
マイナーバージョンアップでも
エンジン側で各タイトルのビルド可否を確認している
26
C++のバージョンのように、Visual Studioのバージョンもガンガン上げたい、というところですが、
タイトル側からすればビルド結果を安定させたい、ということがあるため、Visual Studioのバージョンについてはある程度固定しています。
ここでは、Visual Studioのバージョン変更時のトラブル事例を紹介しておきます。
Visual Studio 2022では、Clang-CLのメジャーバージョンが観測した範囲では17から19まで変化しています。
Clang-CLのメジャーバージョンが更新されると、新たに警告になる内容が増えて、ビルドエラーになることがありました。
また、後ほどお話するC#から⾃動⽣成したC++のコードが⾏数オーバーし、最適化時にクラッシュするようなことがありました。
他にも、17.10でSTLの破壊的変更が⼊っており、バージョンを混ぜるとクラッシュするケースもありました。
IDEやコンパイラーはマイナーバージョンアップでもビルドに影響することが多々あるため、
エンジン側で先⾏して各タイトルのビルド可否を確認した上で、バージョンアップを全体に告知しています。
26


# Page. 28

![Page Image](https://bcdn.docswell.com/page/4JQD8Z197P.jpg)

【C++】ビルドの維持
Clang-CLのサポート
 パッケージビルド時に⾃動⽣成コードの⾏数がCLの限界を超え、
最適化時にクラッシュする
•
•
Clang-CLでのビルドフローを準備していたので、
切り替えて対応してもらう
Microsoftには報告済みでVisual Studio 2022 17.12で修正済み
 Clang-CLでもパッケージビルドに失敗するケースが発⽣
•
修正済みのCLであればビルドできたので、切り替えて回避してもらう
•
⾃動⽣成コードのローカル変数の数が多すぎてクラッシュしていた
CL, Clang-CLのどちらでも
コンパイラー内部のエラーでビルドできないケースがあるため、
両対応しておくことで緊急時の回避ができる
27
さて、先ほどから何度か出てきているClang-CLのサポートについてもお話します。
実は、あるタイトルの開発中に⾃動⽣成コードの⾏数がCLの限界を超え、最適化時にクラッシュする、という問題が発⽣しました。
こんなこともあろうかと、Clang-CLでのビルドフローを準備していたので、切り替えてもらうことで危機は回避できました。
この不具合については、Visual Studio 2022 17.12で修正済みです。
ただ、Clang-CLでもパッケージビルドに失敗するケースが出てきました。
修正済みのCLであればビルドできたので、これまた切り替えてもらうことで回避してもらいました。
⾃動⽣成コードのローカル変数が多すぎてクラッシュしたりしていました。
なかなか、⼤量にコードが⽣成されるようなケースはテストできていないのか、RE ENGINEの開発では頻繁にコンパイラーのインターナルエラーにも遭遇します。
コンパイラーを切り替えられるようにしておくことで、コンパイラーの修正を待っていられない、コードの書き換えでも回避できないというケースも何とか回避できたりします。
27


# Page. 29

![Page Image](https://bcdn.docswell.com/page/K74Z236RE1.jpg)

【C++】
まとめ
 実⾏環境の互換性を維持することは利益につながる
 C++のバージョンを上げることは、
⾼速化だけでなくコードの整理にも効果がある
 安定したビルドのためには、
IDEやコンパイラーのバージョンの差も知る必要がある
28
ここまでで、実⾏環境の互換性の維持がゲームの売り上げに影響すること、
C++のバージョンを上げることが、⾼速化だけでなくコードの整理にも効果があることをお話しました。
また、安定したビルドのためには、IDEやコンパイラーのバージョンを細かく把握しておく必要があるというお話でした。
28


# Page. 30

![Page Image](https://bcdn.docswell.com/page/LJ1RM1VVJG.jpg)

RE ENGINEの
runtime
RE ENGINEの
スクリプトシステム
 RE ENGINE runtimeの今
 スクリプトシステム概要
 C++20の活⽤事例
 開発時︓イテレーションの⾼速化
 C++20への道
 製品時︓独⾃のIL2CPP
 ビルドの維持
 製品時︓IL2CPPによる最適化
29
ここからは、共同発表者である平塚によるRE ENGINEのC#スクリプトに関するお話ですが、私が代わりに読み上げさせていただきます。
29


# Page. 31

![Page Image](https://bcdn.docswell.com/page/GJW138L3E2.jpg)

30
では、RE ENGINEのスクリプトシステムについてお話させていただきます。
30


# Page. 32

![Page Image](https://bcdn.docswell.com/page/4EZPV8MGJ3.jpg)

31
RE ENGINEでは、C#をスクリプトとして利⽤しているため、ここではC#スクリプトと呼ばせていただきます。
31


# Page. 33

![Page Image](https://bcdn.docswell.com/page/Y76M5PNQEV.jpg)

【C#】C#スクリプトシステム概要
全ゲームロジックはC#で記述（1/2）
 タイトル固有のC++コードは存在せず、
unsafeコードは禁⽌
タイトル側ではクラッシュの危険があるコードは書けない
クラッシュ
原因は原則エンジン側
エンジン側での不具合調査になる
例外のthrow
原因はタイトル側
タイトル側での不具合調査になる
 dotnet/runtime から必要なC#コードをインポート
32
まず、C#スクリプトの動作環境について説明します。
RE ENGINEで開発される全てのゲームロジックは、C#で記述されています。
タイトル固有のC++コードは存在せず、unsafeコードは禁⽌しています。
こうすることで、タイトル側ではクラッシュの危険があるコードは書けないようになっています。
そのため、クラッシュした場合は基本的にエンジン側に原因があり、例外がthrowされている場合はタイトル側に原因がある、とはっきり区別することができます。
OSSであるdotnet/runtime から必要なC#コードをインポートしています。
32


# Page. 34

![Page Image](https://bcdn.docswell.com/page/G75ZYK52J4.jpg)

【C#】C#スクリプトシステム概要
全ゲームロジックはC#で記述（2/2）
 独⾃の仮想マシン(REVM)で動作
•
スクリプトデバッガーやプロファイラーも独⾃実装
関連講演
•
『技術の⼒でより多くのゲーマー達へタイトルを届ける︕
RE ENGINEのマルチプラットフォーム展開』
⾼速化のために例外機能を無効にするモードが存在
 独⾃のガベージコレクション(FrameGC)で動作
• ラピッドイテレーションを実現するRE ENGINEの設計
関連資料
https://www.docswell.com/s/CAPCOM_RandD/KQQWMK-202207-15-133419#p77
33
更に、独⾃の仮想マシン『REVM』上で動作しています。
そのため、スクリプトデバッガーやプロファイラーも独⾃実装しており、
⾼速化のために例外機能を無効にするモードも存在しています。
また、FrameGCという独⾃のガベージコレクションを実装しています。
FrameGCについては、Game Creators Conference ʼ17での
弊社⽯⽥による「ラピッドイテレーションを実現するRE ENGINEの設計」をご参照ください。
https://www.docswell.com/s/CAPCOM_RandD/KQQWMK-2022-07-15-133419#p77
33


# Page. 35

![Page Image](https://bcdn.docswell.com/page/9J2RGWN17R.jpg)

【C#】C#スクリプトシステム概要
JITコンパイル⾮サポート
C#コードをILに変換し独⾃AOTコンパイル。
Generic等を事前展開し静的にリンクすることで実⾏速度を⾼速化。
C#コンパイル
（Roslyn）
C#
AOT
コンパイル
IL
開発時
MicroCode
製品時
C++
イテレーション速度を
優先し、
MicroCodeを出⼒
実⾏パフォーマンスを
優先し、
C++コードを出⼒
(IL2CPP)
34
REVMではJITコンパイルは⾮サポートです。
その代わりにC#コードをILに変換した後
独⾃のAOT(Ahead of Time)コンパイルを実⾏し、Genericなどを事前展開し、静的リンクをすることで実⾏速度を⾼速化しています。
開発時はイテレーション速度を優先し、独⾃のMicroCodeを出⼒しインタープリター上で実⾏します。
製品時は実⾏パフォーマンスを優先し、C++コードを出⼒しビルド後に実⾏します。
34


# Page. 36

![Page Image](https://bcdn.docswell.com/page/DEYDVLP4EM.jpg)

RE ENGINEの
runtime
RE ENGINEの
スクリプトシステム
 RE ENGINE runtimeの今
 スクリプトシステム概要
 C++20の活⽤事例
 開発時︓イテレーションの⾼速化
 C++20への道
 製品時︓独⾃のIL2CPP
 ビルドの維持
 製品時︓IL2CPPによる最適化
35
ここまでは、RE ENGINEのスクリプトシステムの概要でした。次はこちらです。
35


# Page. 37

![Page Image](https://bcdn.docswell.com/page/VJN6M456J8.jpg)

36
ここからは、開発中のイテレーション速度を⾼めるための⼯夫についてお話します。
36


# Page. 38

![Page Image](https://bcdn.docswell.com/page/YE9LNQYR73.jpg)

【C#】開発時︓イテレーションの⾼速化
イテレーション速度を優先（1/2）
ホットパッチ
 ゲームの実⾏を中断せずにプログラムの変更を適⽤することが可能
 インタープリター実⾏
不要なBoxingの削除、ILの実⾏時の型に対する分岐の削除 など
ILをそのまま使うと速度が出ない部分を⾼速化したMicroCodeを
実⾏する
37
開発中はイテレーション速度を優先したいため、ホットパッチができるようにしています。
これにより、ゲームの実⾏を中断せずにプログラムの変更を適⽤することができます。
ホットパッチを実現するために、開発時はインタープリター実⾏をしています。
不要なboxingの削除、ILの実⾏時の型に対する分岐の削除など、ILをそのまま使ってしまうと速度が出せない部分を⾼速化した、
独⾃のMicroCodeを実⾏します。
37


# Page. 39

![Page Image](https://bcdn.docswell.com/page/GE8XKG6GJD.jpg)

【C#】開発時︓イテレーションの⾼速化
イテレーション速度を優先（2/2）
ホットパッチの実例
38
実際にホットパッチを適⽤しているところを⾒てみましょう。
※ 映像についてはDocswell「スライド概要」へ記載のYouTube講演映像からご確認ください。
最初はダメージを与えていても、そのまま攻撃をしてきます。
ダメージアクションを追加して保存すると、右上に⻘いバーが出て、ホットパッチのためのビルドが始まります。
ビルドが完了してゲームを再開すると、ダメージでのけ反るようになるため、攻撃し続けられるようになっています。
38


# Page. 40

![Page Image](https://bcdn.docswell.com/page/LEL8ZG9X7R.jpg)

【C#】開発時︓イテレーションの⾼速化
C#コンパイラーの最適化を局所的なものにすることでコンパイル速度を⾼めている。
※開発効率を優先し進化してきた⾔語であり、JITやNativeAOTでは⾼速化されるため問題無い
static string Test1()
{
return (1 + 1).ToString();
}
static string Test2()
{
var temp = 1;
return (temp + temp).ToString();
}
2を読み込む(=1+1が計算済み)
IL_0000: ldc.i4.2
IL_0001: stloc.0
IL_0002: ldloca.s 0
IL_0004: call instance string
[System.Runtime]System.Int32::ToString()
IL_0009: ret
int型定数1を読み込む
IL_0000: ldc.i4.1
最後に読み込んだ値を複製
IL_0001: dup
最後に読み込んだものから
IL_0002: add
2つで加算(=1+1を計算)
IL_0003: stloc.0
IL_0004: ldloca.s 0
IL_0006: call instance string
[System.Runtime]System.Int32::ToString()
IL_000b: ret
39
C#のコンパイル速度の速さもイテレーション速度を⾼める上で重要な要素となっています。
C#のコンパイラーは最適化を局所的にのみ⾏うことでコンパイル速度を⾼めています。
ただし、JITやNativeAOTにより実⾏時には⼗分な速度が出るような仕組みになっています。
ここでは簡単な例として、定数の演算を⾒てみましょう。C++でもC#でも定数同⼠の演算はコンパイル時に計算されます。
Test1の右側のILを⾒ると、最初に1+1は計算済みで、直接2をロードする命令が実⾏されています。
⼀⽅、Test2のように⼀度でも変数に⼊れると、ILはこのようになり
1を読み込み、複製して、加算する、というような3命令に分割されてしまいます。
C++であれば、定数だなと判定して計算してしまうことでしょう。
39


# Page. 41

![Page Image](https://bcdn.docswell.com/page/4JM6VQZ3EW.jpg)

【C#】開発時︓イテレーションの⾼速化
プロジェクト規模とビルド時間 2019年時点
関連資料
【CAPCOM RE:2019】複数のAAAタイトル開発に耐える汎⽤ゲームエンジンの設計と運⽤
https://www.youtube.com/watch?v=fc3avwM-oTE
40
C#のコンパイル速度が如何に早いかの例として、まずは過去に紹介したものをお⾒せします。
ここは過去の情報ですのでさらっと流しますが、数千ファイルで数⼗万⾏のコードが、10秒以内にビルドできています。
40


# Page. 42

![Page Image](https://bcdn.docswell.com/page/PJRP286RE9.jpg)

【C#】開発時︓イテレーションの⾼速化
プロジェクト規模とビルド時間 最新状況
タイトル
CSファイル数
コード⾏数
C#コンパイル時間
『バイオハザード レクイエム』
7,877
778,527
20.7秒
『モンスターハンター
ストーリーズ3 〜運命の双⻯〜』
7,466
777,527
22.0秒
『プラグマタ』
4,296
501,895
17.3秒
『⻤武者 Way of the Sword』
9,275
1,029,816
24.8秒
※コード⾏数にコメントなどは含まない
41
そして、今の状況についてお話をします。
先ほどの資料から7年、多くのタイトルではファイル数が倍ほどになり、コード⾏数も⼤幅に増えていますが、
それでも30秒以内に全てのファイルをコンパイルすることができています。
注⽬ポイントとしては、プラグマタについてはコード規模については過去資料と同等にも関わらず、コンパイル時間が延びているという点です。
この部分は、コンパイラーが進化してきた結果、最適化も増えてきて、若⼲コンパイル時間が延びてしまったからです。
41


# Page. 43

![Page Image](https://bcdn.docswell.com/page/PEX3D8MYJX.jpg)

【C#】開発時︓イテレーションの⾼速化
C#差分コンパイラーを開発
Roslyn APIを⽤いて純正C#コンパイラーと完全互換を持つように設計。
Studio上にコンパイラーのインスタンスを常駐。
初回ビルド時
CSファイル、参照dll、アナライザーdll など
コンパイルに必要なファイルを全てSyntaxTree、MetadataReference、
AnalyzerFileReference などRoslyn⽤データに変換し、
タイムスタンプとセットでオンメモリで管理
⼆回⽬
ビルド以降
コンパイルに必要なデータを全て渡し、
内部でタイムスタンプが変わったものやファイルの増減した部分のみ
再度変換し置き換え
※CSharpParseOptionsが変化していた時は初回ビルドのフローに流す
42
ゲームの規模の拡⼤に伴い、コンパイル時間の増⼤は避けられない問題でした。
そこで、Roslyn APIを⽤いたC#差分コンパイラーを開発しました。
Roslyn APIを⽤いることで、純正C#コンパイラーと完全互換を持つように設計しています。
まず、RE ENGINEのエディターであるStudio上にコンパイラーのインスタンスを常駐させます。
初回ビルド時は、コンパイルに必要なCSファイル、参照dll、アナライザーdllなどを渡し、
SyntaxTree、MetadataReference、AnalyzerFileReferenceなどRoslyn⽤データに変換し、タイムスタンプとセットでオンメモリで管理します。
2回⽬以降のビルド時は、オンメモリのデータを流⽤し、
コンパイルに必要なデータのうち、タイムスタンプが変わったものや、ファイルの増減した部分にのみRoslyn APIでの更新を⾏います。
なお、CSharpParseOptionsが変化していた場合は、初回のビルドフローに戻します。
42


# Page. 44

![Page Image](https://bcdn.docswell.com/page/3EKYXKG4JD.jpg)

【C#】開発時︓イテレーションの⾼速化
C#差分コンパイラーを導⼊
純正C#
コンパイラー
コンパイル
タイトル
C#差分
コンパイラー
コンパイル1回⽬
C#差分
コンパイラー
コンパイル2回⽬以降
バイオハザード レクイエム
20.7秒
23.2秒
9.3秒
モンスターハンター
ストーリーズ3 〜運命の双⻯〜
22.0秒
23.0秒
9.5秒
プラグマタ
17.3秒
18.5秒
6.1秒
⻤武者 Way of the Sword
24.8秒
27.3秒
11.3秒
C#コンパイル時間を50%以上改善
43
C#差分コンパイラーを導⼊した結果、1回⽬で遅くなる部分もありますが、
2回⽬以降は⼤幅にコンパイル時間が削減されていることが分かります。
おおむね50%以上の改善となっています。
初回も、基本的にエンジンの初期化と並列でコンパイルが⾏われるため気になることはありません。
また、同⼀プロセス内で動くように変更されるため
⼩規模なタイトルでもプロセス起動時間が無くなるため数秒は確定で速くなり
C#コンパイラー⾃体がJITコンパイラーの最適化の恩恵も受けやすくなります。
43


# Page. 45

![Page Image](https://bcdn.docswell.com/page/L7395ZND75.jpg)

RE ENGINEの
runtime
RE ENGINEの
スクリプトシステム
 RE ENGINE runtimeの今
 スクリプトシステム概要
 C++20の活⽤事例
 開発時︓イテレーションの⾼速化
 C++20への道
 製品時︓独⾃のIL2CPP
 ビルドの維持
 製品時︓IL2CPPによる最適化
44
ここまでが開発時のイテレーション速度の⾼速化でした。ここからは、製品時の挙動についてのお話となります。
44


# Page. 46

![Page Image](https://bcdn.docswell.com/page/87DGDRW27G.jpg)

45
まずは、製品向けにC#コードから⽣成したILをC++コードに変換する部分について説明します。
45


# Page. 47

![Page Image](https://bcdn.docswell.com/page/VJP3XW9LE8.jpg)

【C#】製品時︓独⾃のIL2CPP
IL2CPPとは
C#コンパイラーが出⼒する中間⾔語(IL)を
C++に変換する機能のこと。
Unityにも同名の機能が存在するが、独⾃実装の別物。
主な機能
1. メソッド単位でC++コードに変換
2. 型情報やILから変換コードの最適化
46
IL2CPPとは、
C#コンパイラーが出⼒する中間⾔語(Intermediate Language)をC++に変換する機能のことです。
IL2CPPというとUnityのものが⾮常に有名ですが、ここでお話しするIL2CPPは、RE ENGINEのために独⾃に実装したものです。
IL2CPPをしているというと、Unityも使ってるんですね、と勘違いされることもありますが、Unityのものは使っていませんのでご注意ください。
RE ENGINEでのIL2CPPの主な機能は、次の通りです。
メソッド単位でC++のコードに変換する機能と、型情報やILから変換コードを最適化する機能です。
46


# Page. 48

![Page Image](https://bcdn.docswell.com/page/2EV4L8M6JQ.jpg)

【C#】製品時︓独⾃のIL2CPP
メソッド単位でC++コードに変換（1/4）
C#コード
static string Test2()
{
var temp = 1;
return (temp + temp).ToString();
}
47
実際のIL2CPPの挙動を⾒るために、1つ簡単なC#コードを例にします。
これは、単純に変数に代⼊した1を⾜し合わせて2にしてから、⽂字列に変換して返す、というメソッドです。
47


# Page. 49

![Page Image](https://bcdn.docswell.com/page/57G1X5G2EL.jpg)

【C#】製品時︓独⾃のIL2CPP
メソッド単位でC++コードに変換（2/4）
IL2CPPで変換されたC++コード
System_String* app_NewBehavior::Test2(VMContext&amp; context)
{
s32 l0;
static string Test2()
{
s32 v1;
var temp = 1;
s32 v2;
return (temp + temp).ToString();
ObjRef v5;
}
v1 = 1;
v2 = v1;
l0 = (s32)(v1 + v2);
v5 = (ObjRef)System_Int32::ToString(context, (System_Int32_ValueType*)&amp;l0);
if (context.hasException()) {
return nullptr;
}
return (System_String*)v5;
}
48
このコードのILを機械的に変換するとこのようなC++コードになります。
変数に代⼊して、⾜し算をして、ToStringを呼び出しているだけですね。例外のチェックも⾏っています。
48


# Page. 50

![Page Image](https://bcdn.docswell.com/page/4EQD8ZX9JP.jpg)

【C#】製品時︓独⾃のIL2CPP
メソッド単位でC++コードに変換（3/4）
C++コンパイラーの最適化イメージコード
System_String* app_NewBehavior::Test2(VMContext&amp; context)
{
s32 l0;
static string Test2()
{
s32 v1;
var temp = 1;
s32 v2;
return (temp + temp).ToString();
ObjRef v5;
}
v1 = 1;
v2 = v1;
l0 = (s32)(v1 + v2);2;
v5 = (ObjRef)System_Int32::ToString(context, (System_Int32_ValueType*)&amp;l0);
if (context.hasException()) {
return nullptr;
}
return (System_String*)v5;
}
49
C++コンパイラーは定数伝搬と呼ばれる最適化を⾏うため、1+1がコンパイル時に計算され結果を取得するだけになります。
49


# Page. 51

![Page Image](https://bcdn.docswell.com/page/KJ4Z232R71.jpg)

【C#】製品時︓独⾃のIL2CPP
メソッド単位でC++コードに変換（4/4）
更に例外無効オプションを有効にしたときのイメージコード
System_String* app_NewBehavior::Test2(VMContext&amp; context)
{
s32 l0;
static string Test2()
{
s32 v1;
var temp = 1;
s32 v2;
return (temp + temp).ToString();
ObjRef v5;
}
v1 = 1;
v2 = v1;
l0 = (s32)(v1 + v2);2;
v5 = (ObjRef)System_Int32::ToString(context, (System_Int32_ValueType*)&amp;l0);
if (context.hasException()) {
return nullptr;
}
return (System_String*)v5;
}
50
更に例外無効オプションを有効にすると
C#のコードをまねてC++のコードを⼿動で書いた時とほぼ同じコードが出現します。
50


# Page. 52

![Page Image](https://bcdn.docswell.com/page/LE1RM1MVEG.jpg)

【C#】製品時︓独⾃のIL2CPP
メソッド単位でC++コードに変換（まとめ）
 例外無効などを組み合わせることで実⾏パフォーマンスを
両⽴出来る
 LTOやPGOなどC++コンパイラーの⼒を借りて
さらに最適化をすることも出来る
 ILを機械的に変換することで、
簡単なコードであればある程度
元のC#コードを汲み取ることが可能
51
ここまで⾒てきたように、例外無効などを組み合わせることで、JITをしていない状態のILであっても、パフォーマンスを⾼めることができます。
さらにはLink Time OptimizationやProfile Guided OptimizationなどC++コンパイラーでの最適化機能を活⽤することで、
実⾏時のパフォーマンスを向上することができます。
また、ILを機械的に変換することで、簡単なコードについてはある程度元のC#コードを読み取ることができ、製品での不具合の調査に役⽴ちます。
51


# Page. 53

![Page Image](https://bcdn.docswell.com/page/GEW1383372.jpg)

【C#】製品時︓独⾃のIL2CPP
Visual Studio拡張
元のC#コードを辿りやすくするためにVisual Studio拡張でデバッグをサポート。
C#コード
IL2CPPコード
コールスタックの確認
IL2CPPコード
C#コード
52
RE ENGINEでは、IL2CPP後のコードのデバッグサポート機能として、Visual Studio拡張で元のC#コードをたどりやすくするための機能を提供しています。
例として、配列の要素の合計を計算するループを⾒てみましょう。
IL2CPPをした結果は次のようになります。
Visual Studio拡張により、C#コードとIL2CPPのブレイクポイントが対応付けされています。
また、C++のダンプでコールスタックを⾒ているときに、対応するC#コードのコールスタックを確認することもできます。
この機能により、製品版でのクラッシュ調査をしている場合でも、関係するC#のコードを特定することができます。
52


# Page. 54

![Page Image](https://bcdn.docswell.com/page/47ZPV8VGE3.jpg)

RE ENGINEの
runtime
RE ENGINEの
スクリプトシステム
 RE ENGINE runtimeの今
 スクリプトシステム概要
 C++20の活⽤事例
 開発時︓イテレーションの⾼速化
 C++20への道
 製品時︓独⾃のIL2CPP
 ビルドの維持
 製品時︓IL2CPPによる最適化
53
ここまでが弊社で独⾃に実装したIL2CPPの概要でした。では、最後のトピックに進みます。
53


# Page. 55

![Page Image](https://bcdn.docswell.com/page/YJ6M5P5Q7V.jpg)

54
ここからは、弊社独⾃のIL2CPPに適⽤している最適化についてお話します。
54


# Page. 56

![Page Image](https://bcdn.docswell.com/page/GJ5ZYKY2E4.jpg)

【C#】製品時︓IL2CPPによる最適化
独⾃でILを解析し⽣成コードを最適化
C++コンパイラーに任せても最適化は出来ない部分を
独⾃でILを解析して⽣成コードを最適化している。
主な最適化
1. 型情報周りに対する最適化
2. Devirtualization
3. ObjectStackAllocation
4. Generic制約new()の呼び出し最適化
5. 配列、Listのforeachに対する最適化
55
IL2CPPでは、C++コンパイラーに任せるだけでは難しいため、独⾃にILを解析して、コード⽣成部分で最適化をしているため、その点について説明します。
主に採⽤しているのは次の5つです。
型情報に関する最適化
Devirtualization
ObjectStackAllocation
Generic制約newの呼び出し最適化
配列やListのforeachに対する最適化
55


# Page. 57

![Page Image](https://bcdn.docswell.com/page/9E2RGWG1JR.jpg)

【C#】製品時︓IL2CPPによる最適化
型情報周りに対する最適化
AOT前提で型が確定しているため、型が分かっていることでの最適化を多く⾏っている。
 is/as/キャストが型解析の結果 コード⽣成時に判定可能な場合、
結果を埋め込む
 インターフェース実装 実体型が1つも存在しない場合 失敗扱いで埋め込むなど
 is/as/キャスト対象の⼦クラスが存在しない場合親⼦関係を辿らず
型の⼀致チェックのみ⾏う
 sealedの付与は関係無い
 typeof(T0) == typeof(T1)やtypeof(T0).IsValueTypeなどを
コード⽣成時に判定しtrue/falseを埋め込む
 GetType()も⼦クラスが存在しないと確定できる場合 typeof()と同等に扱う
etc.
56
まずは、型情報周りに対しての最適化についてお話します。
REVMはAhead Of Time前提なため、IL2CPPを⾏うタイミングでは型を確定させることができます。
そのため、確定した型を利⽤して様々な最適化を⾏っています。
is/as/キャストが型解析の結果 コード⽣成時に判定可能な場合、結果を埋め込んでいます。
例えば、インターフェース型に対する型判定であれば実体型が⼀切存在しなければ確定で失敗するためその内容でコードを⽣成しています。
同じくis/as/キャスト対象の型に⼦クラスが存在しない場合は親⼦関係を辿らずに型の⼀致チェックのみ⾏うコードを⽣成しています。
型が確定しているためsealedが付いているかに関わらず最適化します。
ジェネリックで書かれることがあるtypeof(T)やtypeof(T).IsValueTypeなどもコードを⽣成時に判定を⾏い結果を埋め込みます。
他にも⼦クラスが存在しないGetType()も同等に扱っています。
など実⾏時に少しでも処理を⾏わないようにするための最適化が多数存在しています。
56


# Page. 58

![Page Image](https://bcdn.docswell.com/page/D7YDVLV47M.jpg)

【C#】製品時︓IL2CPPによる最適化
Devirtualization（1/2）
仮想メソッドやインターフェースメソッドを通常メソッド呼び出しに最適化を⾏う。
private List&lt;int&gt; _List;
public IReadOnlyList&lt;int&gt; List =&gt; _List;
int Test3()
{
int sum = 0;
for (int i = 0; i &lt; List.Count; i++)
{
sum += List[i];
}
return sum;
}
勝⼿に書き換えられると困るため
IReadOnlyList&lt;int&gt;にキャスト
インターフェース型で関数呼び出しをしているため
Countプロパティは仮想関数呼び出し
インターフェース型で関数呼び出しをしているため
要素アクセスは仮想関数呼び出し
57
2つ⽬はDevirtualizationです。
仮想メソッドやインターフェースメソッドを通常メソッド呼び出しに置き換える最適化を⾏います。
保持しているリストを勝⼿に外から書き換えられると困るため、インターフェース型のIReadOnlyListとしてプロパティを公開することはC#ではよくあると思います。
ただこの場合、ILをそのまま使うとIReadOnlyListのインターフェースメソッド呼び出しが発⽣してしまいます。
この例では、Countプロパティへのアクセスや、要素アクセスがインターフェース経由になります。
これはC++に変換した際に仮想関数呼び出しになってしまうため、C++コンパイラーでinline展開もされず、パフォーマンスに影響が出てしまいます。
57


# Page. 59

![Page Image](https://bcdn.docswell.com/page/VEN6M4M6E8.jpg)

【C#】製品時︓IL2CPPによる最適化
Devirtualization（2/2）
仮想メソッドやインターフェースメソッドを通常メソッド呼び出しに最適化を⾏う。
private List&lt;int&gt; _List;
public IReadOnlyList&lt;int&gt; List =&gt; _List;
int Test3()
{
int sum = 0;
for (int i = 0; i &lt; List.Count; i++)
{
sum += List[i];
}
return sum;
}
Listの実体型はList&lt;int&gt;しか有り得ない
List&lt;int&gt;.Countプロパティはoverrideされていないため
通常関数呼び出しでC++コードを出⼒
List&lt;int&gt;の要素アクセスはoverrideされていないため
通常関数呼び出しでC++コードを出⼒
1000万要素時のメソッド処理時間
(PlayStation 5 IL2CPP例外無効モード)
最適化実装前
40.93ms
最適化実装後
5.67ms
58
最初にお話ししたように、既にAOTで型を特定できているため、ILから型追跡を⾏い、実際の型を特定でき、
それによってこの問題を解決しています。
Listプロパティの返り値はList&lt;int&gt;型しか有り得ません。
この情報を⽤いて、通常関数呼び出しとしてC++コードを⽣成することで
C++コンパイラによってinline展開などの最適化がされやすい状態にしています。
実際に計測すると、同じ回数ループを回した時の実⾏速度が40.93msから5.67msほどと⼤きく改善されています。
58


# Page. 60

![Page Image](https://bcdn.docswell.com/page/Y79LNQNRJ3.jpg)

【C#】製品時︓IL2CPPによる最適化
ObjectStackAllocation（1/4）
C#のインスタンスは基本ヒープ領域からメモリ確保される
ただしメソッドの外に出ないことが確定出来れば、スタック領域からのメモリ確保に最適化可能。
static void StackTest()
{
var array = new object[10];
array[0] = new object();
}
arrayが外には出ないならスタック領域から
Test(array);
static void Test(object o) { }
メソッドの引数に渡しているが
Test()の中から出ないのでスタック領域から
StaticField = new object();
静的フィールドに⼊っているのでこれはヒープ領域から
59
3つ⽬はObjectStackAllocationです。
C#のインスタンスは基本ヒープ領域からメモリ確保されます。
ただし、そのインスタンスがメソッドの外に出ないことが確定出来れば、スタック領域からのメモリ確保に最適化可能です。
例として、いくつかのパターンを⾒てみます。
このローカル変数arrayは外に返していないので、スタック領域に確保しても問題ありません。
arrayをTestというメソッドに渡していますが、Testの中から外に出ることが無いので、スタックのままで問題ありません。
最後に、静的フィールドに代⼊しているケースは、ヒープからの確保が必要となります。
どれもILを解析することでスタック領域からのメモリ確保が可能かを判定しています。
59


# Page. 61

![Page Image](https://bcdn.docswell.com/page/G78XKGKGED.jpg)

【C#】製品時︓IL2CPPによる最適化
ObjectStackAllocation（2/4）
REVMのGCアルゴリズムのFrameGCでは、
スレッドローカルなオブジェクトは
ローカルテーブル管理で参照カウント無し。
このテーブルに登録せず、
スタック領域からの確保と
通常の破棄に任せるのみで対応可能。
関連資料
ラピッドイテレーションを実現するRE ENGINEの設計
https://www.docswell.com/s/CAPCOM_RandD/KQQWMK-2022-07-15-133419#p77
60
このObjectStackAllocationという最適化はRE ENGINE独⾃のガベージコレクションであるFrameGCと相性が良いです。
スレッドローカルなオブジェクトは元々参照カウント管理されていないため、
ローカルテーブルに登録せず、スタック領域から確保と通常の破棄に任せるのみで実装が完了しました。
先ほども触れましたが、FrameGCについては、Game Creators Conference ʼ17の資料をご参照ください。
60


# Page. 62

![Page Image](https://bcdn.docswell.com/page/L7L8ZGZXJR.jpg)

【C#】製品時︓IL2CPPによる最適化
ObjectStackAllocation（3/4）
計測場所（開発環境）
⾮IL2CPP時
IL2CPP時
『バイオハザード レクイエム』
レンウッド/⼤通り
『モンスターハンター ストーリーズ3
〜運命の双⻯〜』
アズラル城
61
こちらは、実際にObjectStackAllocationを適⽤した結果となります。
それぞれ、バイオハザードレクイエムのレンウッド⼤通りと、モンスターハンターストーリーズ3、運命の双⻯のアズラル城にて、開発時に計測したものとなります。
バイオハザードレクイエムでは、最適化前が約7,800回から、最適化後は約6,300回と1,500回ほどアロケーションが削減できています。
モンスターハンターストーリーズ3では、5,400回ほどから3,600回と1,800回ほどアロケーションが削減できています。
メモリアロケーションが重い、というのは皆さまご存知かと思いますが、これがタイトル側で何もしなくても削減できる、という点が嬉しいことは
理解していただけるかと思います。
61


# Page. 63

![Page Image](https://bcdn.docswell.com/page/4EM6VQV37W.jpg)

【C#】製品時︓IL2CPPによる最適化
ObjectStackAllocation（4/4）
⽂字列・配列・デリゲート含む 全てのオブジェクトが最適化対象。
 スタック領域が少なくなった際に、ヒープ領域からのメモリ確保に
切り替える安全装置付き
 タイトルへの変更なしで、
1フレーム内のヒープ領域メモリからの確保回数が
⼤幅削減
 ⻑時間プレイの天敵である断⽚化も
⾃動的に改善される
62
このObjectStackAllocationは、⽂字列・配列・デリゲート含む 全てのオブジェクトを最適化対象にしています。
スタック領域が少なくなった際には、動的にヒープ領域からのメモリ確保に切り替える安全装置付きで、
StackOverflowが発⽣したことは⼀度もありません。
タイトルへの変更なしで、ヒープ領域からのメモリ確保回数が⼤きく削減出来ており、
⻑時間プレイすることが前提なゲームの天敵である断⽚化も⾃動的に改善されます。
62


# Page. 64

![Page Image](https://bcdn.docswell.com/page/PERP282R79.jpg)

【C#】製品時︓IL2CPPによる最適化
Generic制約new()の呼び出し最適化
Generic制約されたnew()はActivator.CreateInstance&lt;T&gt;()呼び出しと等価なILになる。
そのためリフレクション情報にアクセスする必要があるため遅い。
static T GenericCreate&lt;T&gt;() where T : new() =&gt; new T();
IL的には上下2つのメソッドは等価
static T GenericCreate&lt;T&gt;() where T : new() =&gt; Activator.CreateInstance&lt;T&gt;();
⾮Genericメソッドで書いた場合と同等になるように最適化
static Data Create() =&gt; new Data();
10万回のメソッド呼び出し処理時間
(PlayStation 5 IL2CPP例外無効モード)
Create
GenericCreate&lt;Data&gt;
最適化実装前
GenericCreate&lt;Data&gt;
最適化実装後
1.64ms
2.22ms
1.62ms
このパターンでもメソッドの外に出ない場合はObjectStackAllocation最適化対象
63
4つ⽬はGeneric制約newの呼び出し最適化です。
Generic制約されたnewは、Activator.CreateInstance&lt;T&gt;を呼び出すのに等しいILになり、リフレクション情報にアクセスするため、遅くなります。
しかし、AOTにより型情報を特定しているため、⾮Genericメソッドで書いたのと同じようになるよう最適化し、リフレクション情報へのアクセスを不要にして、
⾼速化しています。
10万回ほどのメソッド呼び出しで、最適化によりGenericCreateのコードが通常のメソッドとほぼ同じ時間で呼び出せていることが分かります。
また、このパターンでもメソッドの外に出ないことが分かっていれば、ObjectStackAllocationの最適化対象になります。
63


# Page. 65

![Page Image](https://bcdn.docswell.com/page/P7X3D8DYEX.jpg)

【C#】製品時︓IL2CPPによる最適化
配列、Listのforeachに対する最適化（1/3）
T[]やSpan&lt;T&gt;, ReadOnlySpan&lt;T&gt;はforeach⽂で記述しても
C#コンパイラーがfor⽂とほぼ同等のILに最適化。
static int ForeachTest(int[] array)
{
int sum = 0;
foreach (var item in array)
{
sum += item;
}
return sum;
}
IL_0000: ldc.i4.0
IL_0001: stloc.0
IL_0002: ldarg.0
IL_0003: stloc.1
IL_0004: ldc.i4.0
IL_0005: stloc.2
IL_0006: br.s IL_0014
IL_0008: ldloc.1
IL_0009: ldloc.2
IL_000a: ldelem.i4
IL_000b: stloc.3
IL_000c: ldloc.0
IL_000d: ldloc.3
IL_000e: add
IL_000f: stloc.0
IL_0010: ldloc.2
IL_0011: ldc.i4.1
IL_0012: add
IL_0013: stloc.2
IL_0014: ldloc.2
IL_0015: ldloc.1
IL_0016: ldlen
IL_0017: conv.i4
IL_0018: blt.s IL_0008
IL_001a: ldloc.0
IL_001b: ret
GetEnumerator(), get_Current(), MoveNext(), Dispose()の
呼び出しが存在しない
64
最後は、配列、Listのforeachに対する最適化です。
T[]やSpan&lt;T&gt;, ReadOnlySpan&lt;T&gt;はforeach⽂で記述しても
C#コンパイラーがfor⽂とほぼ同等のILに最適化します。
例として、単純に配列の合計を計算するプログラムを⾒てみましょう。
ILを⾒てみると、配列に対してforeachしてもGetEnumerator()などのメソッド呼び出しが存在しないことが分かると思います。
64


# Page. 66

![Page Image](https://bcdn.docswell.com/page/37KYXKX4ED.jpg)

【C#】製品時︓IL2CPPによる最適化
配列、Listのforeachに対する最適化（2/3）
T[]やSpan&lt;T&gt;, ReadOnlySpan&lt;T&gt;はforeach⽂で記述しても
C#コンパイラーがfor⽂とほぼ同等のILに最適化。
static int ForeachTest(List&lt;int&gt; list)
{
int sum = 0;
foreach (var item in list)
{
sum += item;
}
return sum;
}
65
対して、Interface型やArray型に変換された配列やList&lt;T&gt;は最適化されません。
こちらは、先ほどのコードの配列をListに変えただけのコードです。
65


# Page. 67

![Page Image](https://bcdn.docswell.com/page/LJ395Z5DJ5.jpg)

【C#】製品時︓IL2CPPによる最適化
IL_0000: ldc.i4.0
IL_0001: stloc.0
IL_0002: ldarg.0
IL_0003: callvirt instance valuetype [System.Collections]System.Collections.Generic.List`1/Enumerator&lt;!0&gt; class
[System.Collections]System.Collections.Generic.List`1&lt;int32&gt;::GetEnumerator()
T[]やSpan&lt;T&gt;, ReadOnlySpan&lt;T&gt;はforeach⽂で記述しても
IL_0008: stloc.1
C#コンパイラーがfor⽂とほぼ同等のILに最適化。
IL_0009: br.s IL_0017
IL_000b: ldloca.s 1
IL_000d:
call instance !0 valuetype [System.Collections]System.Collections.Generic.List`1/Enumerator&lt;int32&gt;::get_Current()
static
int ForeachTest(List&lt;int&gt;
list)
IL_0012: stloc.2
{ IL_0013: ldloc.0
int
sumldloc.2
= 0;
IL_0014:
IL_0015: add
foreach
(var item in list)
IL_0016: stloc.0
{IL_0017: ldloca.s 1
sum call
+=instance
item; bool valuetype [System.Collections]System.Collections.Generic.List`1/Enumerator&lt;int32&gt;::MoveNext()
IL_0019:
}IL_001e: brtrue.s IL_000b
IL_0020: sum;
leave.s IL_0030
return
IL_0022: ldloca.s 1
} IL_0024: constrained. valuetype [System.Collections]System.Collections.Generic.List`1/Enumerator&lt;int32&gt;
IL_002a: callvirt instance void [System.Runtime]System.IDisposable::Dispose()
IL_002f: endfinally
IL_0030: ldloc.0
IL_0031: ret
配列、Listのforeachに対する最適化（2/3）
GetEnumerator(), get_Current(), MoveNext(), Dispose()の呼び出しが存在する︕
66
ILを⾒ると、GetEnumeratorなど⼤量のメソッド呼び出しが存在していることが分かると思います。
66


# Page. 68

![Page Image](https://bcdn.docswell.com/page/8JDGDRD2JG.jpg)

【C#】製品時︓IL2CPPによる最適化
配列、Listのforeachに対する最適化（3/3）
そのため独⾃で同様の最適化を⾏っている。
Devirtualization時の解析データを⽤いているためInterface型でも最適化される場合がある。
static int ForTest(List&lt;int&gt; list)
{
int sum = 0;
for (int i = 0; i &lt; list.Count; ++i)
{
sum += list[i];
}
return sum;
}
1000万要素時のメソッド処理時間
(PlayStation 5 IL2CPP例外無効モード)
static int ForeachTest(List&lt;int&gt; list)
{
int sum = 0;
foreach (var item in list)
{
sum += item;
}
return sum;
}
ForTest
5.06ms
ForeachTest
最適化実装前
ForeachTest
最適化実装後
50.45ms
5.23ms
67
そのため、独⾃に通常の配列と同じようになるよう同様の最適化を⾏い、タイトルでは気にせずパフォーマンスが出せるようになっています。
先程のDevirtualizationの解析データも⽤いているため
インターフェースで記述されていても同様の最適化が⾏われることがあります。
実際にこの最適化を適⽤することで、forとforeachの実⾏結果が同じように5msほどになっていることが確認できます。
67


# Page. 69

![Page Image](https://bcdn.docswell.com/page/VEP3XWXL78.jpg)

【C#】
まとめ
 新機能や新たな最適化を継続的に開発することで
⼤規模なタイトル開発をサポート
 C#を利⽤することで開発効率を⾼めつつ、
実⾏時パフォーマンスも実現
68
RE ENGINEのC#については、新機能や新たな最適化を継続的に開発することで、⼤規模なタイトル開発をサポートしています。
C#を利⽤することで開発効率を⾼めつつ、実⾏時パフォーマンスも実現しています。
68


# Page. 70

![Page Image](https://bcdn.docswell.com/page/27V4L8L6EQ.jpg)

ご清聴
ありがとうございました
69
69


