第10章　Tuning Practice - Script (C#)

リスト10.1: 毎フレームGC.Allocするコード

 1: private void Update()
 2: {
 3:     const int listCapacity = 100;
 4:     // List<int>のnewでGC.Alloc
 5:     var list = new List<int>(listCapacity);
 6:     for (var index = 0; index < listCapacity; index++)
 7:     {
 8:         // 特に意味はないがindexをListに詰める
 9:         list.Add(index);
10:     }
11:     // listから値をランダムに取り出す
12:     var random = UnityEngine.Random.Range(0, listCapacity);
13:     var randomValue = list[random];
14:     // ... ランダムな値から何かする ...
15: }

リスト10.2: 毎フレームのGC.Allocを無くしたコード

 1: private static readonly int listCapacity = 100;
 2: // 事前にListを生成しておく
 3: private readonly List<int> _list = new List<int>(listCapacity);
 4: 
 5: private void Update()
 6: {
 7:     _list.Clear();
 8:     for (var index = 0; index < listCapacity; index++)
 9:     {
10:         // 特に意味はないけどindexをListに詰めていく
11:         _list.Add(index);
12:     }
13:     // listから値をランダムに取り出す
14:     var random = UnityEngine.Random.Range(0, listCapacity);
15:     var randomValue = _list[random];
16:     // ... ランダムな値から何かする ...
17: }

リスト10.4: ラムダ式サンプルの前提コード

 1: // メンバー変数
 2: private int _memberCount = 0;
 3: 
 4: // static変数
 5: private static int _staticCount = 0;
 6: 
 7: // メンバーメソッド
 8: private void IncrementMemberCount()
 9: {
10:     _memberCount++;
11: }
12: 
13: // staticメソッド
14: private static void IncrementStaticCount()
15: {
16:     _staticCount++;
17: }
18: 
19: // 受け取ったActionをInvokeするだけのメンバーメソッド
20: private void InvokeActionMethod(System.Action action)
21: {
22:     action.Invoke();
23: }

リスト10.5: ラムダ式内で変数を参照してGC.Allocするケース

 1: // メンバー変数を参照した場合、Delegate Allocationが発生
 2: InvokeActionMethod(() => { _memberCount++; });
 3: 
 4: // ローカル変数を参照した場合、Closure Allocationが発生
 5: int count = 0;
 6: // 上記と同じDelegate Allocationも発生
 7: InvokeActionMethod(() => { count++; });

リスト10.6: ラムダ式内でstatic変数を参照してGC.Allocしないケース

 1: // static変数を参照した場合、GC Allocは発生せず
 2: InvokeActionMethod(() => { _staticCount++; });

リスト10.7: ラムダ式内でメソッドを参照してGC.Allocするケース

 1: // メンバーメソッドを参照した場合、Delegate Allocationが発生
 2: InvokeActionMethod(() => { IncrementMemberCount(); });
 3: 
 4: // メンバーメソッドを直接指定した場合、Delegate Allocationが発生
 5: InvokeActionMethod(IncrementMemberCount);
 6: 
 7: // staticメソッドを直接指定した場合、Delegate Allocationが発生
 8: InvokeActionMethod(IncrementStaticCount);

リスト10.8: ラムダ式内でメソッドを参照してGC.Allocしないケース

 1: // ラムダ式内でstaticメソッドを参照した場合は、Non Allocとなる
 2: InvokeActionMethod(() => { IncrementStaticCount(); });

リスト10.9: ジェネリックを使用してボックス化する可能性がある例

 1: public readonly struct GenericStruct<T> : IEquatable<T>
 2: {
 3:     private readonly T _value;
 4: 
 5:     public GenericStruct(T value)
 6:     {
 7:         _value = value;
 8:     }
 9: 
10:     public bool Equals(T other)
11:     {
12:         var result = _value.Equals(other);
13:         return result;
14:     }
15: }

リスト10.10: Object.cs

 1: public virtual bool Equals(object obj);

リスト10.11: ボックス化しないように制限をかけた例

 1: public readonly struct GenericOnlyStruct<T> : IEquatable<T>
 2:     where T : IEquatable<T>
 3: {
 4:     private readonly T _value;
 5: 
 6:     public GenericOnlyStruct(T value)
 7:     {
 8:         _value = value;
 9:     }
10: 
11:     public bool Equals(T other)
12:     {
13:         var result = _value.Equals(other);
14:         return result;
15:     }
16: }

リスト10.12: Listをforeachで回す例

 1: var list = new List<int>(128);
 2: foreach (var val in list)
 3: {
 4: }

リスト10.13: Listをforeachで回す例のデコンパイル結果

 1: List<int>.Enumerator enumerator = new List<int>(128).GetEnumerator();
 2: try
 3: {
 4:     while (enumerator.MoveNext())
 5:     {
 6:         int current = enumerator.Current;
 7:     }
 8: }
 9: finally
10: {
11:     ((IDisposable)enumerator).Dispose();
12: }

リスト10.14: Listをforで回す例

 1: var list = new List<int>(128);
 2: for (var i = 0; i < list.Count; i++)
 3: {
 4:     var val = list[i];
 5: }

リスト10.15: Listをforで回した際のデコンパイル結果

 1: List<int> list = new List<int>(128);
 2: int num = 0;
 3: while (num < list.Count)
 4: {
 5:     int num2 = list[num];
 6:     num++;
 7: }

リスト10.16: Listをforで回す例: 改良版

 1: var count = list.Count;
 2: for (var i = 0; i < count; i++)
 3: {
 4:     var val = list[i];
 5: }

リスト10.17: Listをforで回す例: 改良版のデコンパイル結果

 1: List<int> list = new List<int>(128);
 2: int count = list.Count;
 3: int num = 0;
 4: while (num < count)
 5: {
 6:     int num2 = list[num];
 7:     num++;
 8: }

リスト10.18: 配列をforeachで回す例

 1: var array = new int[128];
 2: foreach (var val in array)
 3: {
 4: }

リスト10.19: 配列をforeachで回す例のデコンパイル結果

 1: int[] array = new int[128];
 2: int num = 0;
 3: while (num < array.Length)
 4: {
 5:     int num2 = array[num];
 6:     num++;
 7: }

リスト10.20: 文字列結合でstringを作る場合

 1: private string CreatePath()
 2: {
 3:     var path = "root";
 4:     path += "/";
 5:     path += "Hoge";
 6:     path += "/";
 7:     path += "Fuga";
 8:     return path;
 9: }

リスト10.21: StringBuilderでstringを作る場合

 1: private readonly StringBuilder _stringBuilder = new StringBuilder(16);
 2: private string CreatePathFromStringBuilder()
 3: {
 4:     _stringBuilder.Clear();
 5:     _stringBuilder.Append("root");
 6:     _stringBuilder.Append("/");
 7:     _stringBuilder.Append("Hoge");
 8:     _stringBuilder.Append("/");
 9:     _stringBuilder.Append("Fuga");
10:     return _stringBuilder.ToString();
11: }

リスト10.22: GC.Allocが発生する例

 1: var oneToTen = Enumerable.Range(1, 11).ToArray();
 2: var query = oneToTen.Where(i => i % 2 == 0).Select(i => i * i);

リスト10.23: 型ごとの実行速度検証

 1: private int[] array;
 2: private List<int> list;
 3: private IEnumerable<int> ienumerable;
 4: 
 5: public void GlobalSetup()
 6: {
 7:     array = Enumerable.Range(0, 1000).ToArray();
 8:     list = Enumerable.Range(0, 1000).ToList();
 9:     ienumerable = Enumerable.Range(0, 1000);
10: }
11: 
12: public void RunAsArray()
13: {
14:     var query = array.Where(i => i % 2 == 0);
15:     foreach (var i in query){}
16: }
17: 
18: public void RunAsList()
19: {
20:     var query = list.Where(i => i % 2 == 0);
21:     foreach (var i in query){}
22: }
23: 
24: public void RunAsIEnumerable()
25: {
26:     var query = ienumerable.Where(i => i % 2 == 0);
27:     foreach (var i in query){}
28: }

リスト10.24: 即時評価を挟んだメソッド

 1: private static void LazyExpression()
 2: {
 3:     var array = Enumerable.Range(0, 5).ToArray();
 4:     var sw = Stopwatch.StartNew();
 5:     var query = array.Where(i => i % 2 == 0).Select(HeavyProcess).ToArray();
 6:     Console.WriteLine($"Query: {sw.ElapsedMilliseconds}");
 7: 
 8:     foreach (var i in query)
 9:     {
10:         Console.WriteLine($"diff: {sw.ElapsedMilliseconds}");
11:     }
12: }
13: 
14: private static int HeavyProcess(int x)
15: {
16:     Thread.Sleep(1000);
17:     return x;
18: }

リスト10.25: 即時評価のメソッドを追加した結果

 1: Query: 3013
 2: diff: 3032
 3: diff: 3032
 4: diff: 3032

リスト10.26: LINQの使用有無によるパフォーマンス比較

 1: private int[] array;
 2: 
 3: public void GlobalSetup()
 4: {
 5:     array = Enumerable.Range(0, 100_000_000).ToArray();
 6: }
 7: 
 8: public void Pure()
 9: {
10:     foreach (var i in array)
11:     {
12:         if (i % 2 == 0)
13:         {
14:             var _ = i * i;
15:         }
16:     }
17: }
18: 
19: public void UseLinq()
20: {
21:     var query = array.Where(i => i % 2 == 0).Select(i => i * i);
22:     foreach (var i in query)
23:     {
24:     }
25: }

リスト10.27: 同期的に完了する可能性のある非同期処理

 1: using System;
 2: using System.Threading.Tasks;
 3: 
 4: namespace A {
 5:     public class B {
 6:         public async Task HogeAsync(int i) {
 7:             if (i == 0) {
 8:                 Console.WriteLine("i is 0");
 9:                 return;
10:             }
11:             await Task.Delay(TimeSpan.FromSeconds(1));
12:         }
13: 
14:         public void Main() {
15:             int i = int.Parse(Console.ReadLine());
16:             Task.Run(() => HogeAsync(i));
17:         }
18:     }
19: }

リスト10.28: 同期処理と非同期処理を分割した実装

 1: using System;
 2: using System.Threading.Tasks;
 3: 
 4: namespace A {
 5:     public class B {
 6:         public async Task HogeAsync(int i) {
 7:             await Task.Delay(TimeSpan.FromSeconds(1));
 8:         }
 9: 
10:         public void Main() {
11:             int i = int.Parse(Console.ReadLine());
12:             if (i == 0) {
13:                 Console.WriteLine("i is 0");
14:             } else {
15:                 Task.Run(() => HogeAsync(i));
16:             }
17:         }
18:     }
19: }

リスト10.29: stackallocを用いたスタック上への配列確保

 1: // stackallocはunsafe限定
 2: unsafe
 3: {
 4:     // スタック上にintの配列を確保
 5:     byte* buffer = stackalloc byte[BufferSize];
 6: }

リスト10.30: Span<T>構造体を併用したスタック上への配列確保

 1: Span<byte> buffer = stackalloc byte[BufferSize];

リスト10.31: stackallocを用いたスタック上への配列確保

 1: unsafe void Hoge()
 2: {
 3:     for (int i = 0; i < 10000; i++)
 4:     {
 5:         // ループ数分配列が蓄積される
 6:         byte* buffer = stackalloc byte[10000];
 7:     }
 8: }

リスト10.32: IL2CPPが生成するメソッド呼び出しに関するC++コード

 1: struct VirtActionInvoker0
 2: {
 3:     typedef void (*Action)(void*, const RuntimeMethod*);
 4: 
 5:     static inline void Invoke (
 6:         Il2CppMethodSlot slot, RuntimeObject* obj)
 7:     {
 8:         const VirtualInvokeData& invokeData =
 9:             il2cpp_codegen_get_virtual_invoke_data(slot, obj);
10:         ((Action)invokeData.methodPtr)(obj, invokeData.method);
11:     }
12: };

リスト10.33: sealedを用いないクラス定義とメソッド呼び出し

 1: public abstract class Animal
 2: {
 3:     public abstract string Speak();
 4: }
 5: 
 6: public class Cow : Animal
 7: {
 8:     public override string Speak() {
 9:         return "Moo";
10:     }
11: }
12: 
13: var cow = new Cow();
14: // Speakメソッドを呼び出す
15: Debug.LogFormat("The cow says '{0}'", cow.Speak());

リスト10.34: リスト10.33のメソッド呼び出しに対応するC++コード

 1: // var cow = new Cow();
 2: Cow_t1312235562 * L_14 =
 3:     (Cow_t1312235562 *)il2cpp_codegen_object_new(
 4:         Cow_t1312235562_il2cpp_TypeInfo_var);
 5: Cow__ctor_m2285919473(L_14, /*hidden argument*/NULL);
 6: V_4 = L_14;
 7: Cow_t1312235562 * L_16 = V_4;
 8: 
 9: // cow.Speak()
10: String_t* L_17 = VirtFuncInvoker0< String_t* >::Invoke(
11:     4 /* System.String AssemblyCSharp.Cow::Speak() */, L_16);

リスト10.35: sealedを用いたクラス定義とメソッド呼び出し

 1: public sealed class Cow : Animal
 2: {
 3:     public override string Speak() {
 4:         return "Moo";
 5:     }
 6: }
 7: 
 8: var cow = new Cow();
 9: // Speakメソッドを呼び出す
10: Debug.LogFormat("The cow says '{0}'", cow.Speak());

リスト10.36: リスト10.35のメソッド呼び出しに対応するC++コード

 1: // var cow = new Cow();
 2: Cow_t1312235562 * L_14 =
 3:     (Cow_t1312235562 *)il2cpp_codegen_object_new(
 4:         Cow_t1312235562_il2cpp_TypeInfo_var);
 5: Cow__ctor_m2285919473(L_14, /*hidden argument*/NULL);
 6: V_4 = L_14;
 7: Cow_t1312235562 * L_16 = V_4;
 8: 
 9: // cow.Speak()
10: String_t* L_17 = Cow_Speak_m1607867742(L_16, /*hidden argument*/NULL);

リスト10.37: インライン化前のコード

 1: int F(int a, int b, int c)
 2: {
 3:     var d = Add(a, b);
 4:     var e = Add(b, c);
 5:     var f = Add(d, e);
 6: 
 7:     return f;
 8: }
 9: 
10: int Add(int a, int b) => a + b;

リスト10.38: リスト10.37に対してインライン化を行ったコード

 1: int F(int a, int b, int c)
 2: {
 3:     var d = a + b;
 4:     var e = b + c;
 5:     var f = d + e;
 6: 
 7:     return f;
 8: }