Minimising memory churn With examples in C# by Christopher Myburgh Technical Director at Team Devil Games www.teamdevil.com

stack memory & heap memory Objects are always destroyed in the opposite order that they are created. Every thread has its own stack. Heap Objects have an indeterminate lifetime. In managed environments, a “garbage collector” must periodically run to free memory from unreferenced objects. The heap becomes fragmented as objects are destroyed. A severely fragmented heap might cause allocations to take longer.

“mark-and-sweep” garbage collector basics Traverses the object graph starting from static variables and the stack(s). Tags all the heap objects it encounters. All heap objects that remain untagged when traversal is completed are then destroyed, and the memory that they occupied is made available for re-use.

Memory churn Is the rate of creation and destruction of objects in heap memory. The higher the churn, the more severely the heap could become fragmented, the more often the garbage collector might be triggered and the more work the garbage collector may have to do. A tell-tale sign of severe memory churn in games is small but regular pauses in gameplay, caused by the garbage collector running very frequently and taking exceedingly long to complete (1 or more entire frames). Severe memory churn is caused by repeatedly creating heap objects with very short lifetimes.

Best practices to minimise memory churn Avoid creating heap objects inside loops that are forgotten at the end of each iteration. class Foo { void DoSomething() // ... } void DoStuff(int count) { for (int i = 0; i < count; ++i) // allocated within the loop Foo myHeapObject = new Foo(); myHeapObject.DoSomething(); } void DoStuff(int count) { // allocated outside the loop Foo myHeapObject = new Foo(); for (int i = 0; i < count; ++i) myHeapObject.DoSomething(); }

Best practices to minimise memory churn Avoid creating heap objects during every update that are forgotten at the end of the update. class Foo { void DoSomething() // ... } class MyScript { void Update() // allocated during the update Foo myHeapObject = new Foo(); myHeapObject.DoSomething(); } class MyScript { // allocated before any updates Foo myHeapObject = new Foo(); void Update() myHeapObject.DoSomething(); }

Best practices to minimise memory churn Pool game objects that occur frequently (eg. projectiles in a shoot-em-up). class Projectile { void Enable() // ... } void Disable() class ProjectileManager { Queue<Projectile> projectilePool = new Queue<Projectile>(); Projectile CreateProjectile() Projectile projectile; // Get an unused projectile from the pool, // or create a new one if there are none spare. if (projectilePool.Count > 0) projectile = projectilePool.Dequeue(); else projectile = new Projectile(); projectile.Enable(); return projectile; } void DestroyProjectile(Projectile projectile) // Return the unused projectile to the pool. projectile.Disable(); projectilePool.Enqueue(projectile);

reference types & value types in C# Objects are always allocated on the heap. Include classes, interfaces, arrays and delegates. Value types Objects are allocated on the stack when declared as local variables or as method parameters, or form part of the object on the heap when declared as class members or as the element type of an array. Include enums and structs.

Implicit heap allocations in C# string concatenation class Player { public string Name; public int Score; } // ... // ToString() is called on player.Score and concatenations generate new strings string hudText = "Name: " + player.Name + "; Score = " + player.Score; boxing int num = 0; object numObj = num; // creates a copy of num on the heap interface IMyInterface { // … } struct MyStruct : IMyInterface { // … } MyStruct myStruct = new MyStruct(); IMyInterface myInterface = myStruct; // creates a copy of myStruct on the heap

Implicit heap allocations in C# delegate creation bool LessThanZero(int x) { return x < 0; } List<int> myList = new List<int>(); // … // The first statement is just shorthand for the second. myList.RemoveAll(LessThanZero); myList.RemoveAll(new Predicate<int>(LessThanZero)); lambda expressions List<int> myList = new List<int>(); // … // A delegate is allocated for an anonymous method. myList.RemoveAll(x => x < 0); // Captured variables are implemented as members of an anonymous class which must also be allocated. int j = 0; myList.RemoveAll(x => x < j);

Implicit heap allocations in C# delegate chaining void DoSomething1() { // … } void DoSomething2() { // … } void DoSomething3() { // … } Action action1 = DoSomething1; Action action2 = DoSomething2; // New delegates are allocated when chained. // By default, events are implemented by chaining delegates. Action actionAll = action1 + action2; actionAll += DoSomething3;

Implicit heap allocations in C# foreach loops (in many but not all cases) foreach (T item in myEnumerableObject) { // … } // The above foreach loop is shorthand for the loop below, so check the return type of GetEnumerator(). // If the return type is a struct, the enumerator is allocated on the stack. // If the return type is a class, the enumerator is allocated on the heap. // If the return type is an interface, either a class is allocated on the heap or a struct is boxed. using (var anonymousEnumerator = myEnumerableObject.GetEnumerator()) { while (anonymousEnumerator.MoveNext()) { T item = (T)anonymousEnumerator.Current; // read-only // … } }

Implicit heap allocations in C# params method arguments int AddAll(params int[] nums) { // … } int num1 = 1, num2 = 2, num3 = 3; int sum; // The first statement is just shorthand for the second. sum = AddAll(num1, num2, num3); sum = AddAll(new int[] { num1, num2, num3 }); passing strings from an unmanaged context to a managed context

'k thanks bye.