[Unity Document Study] 1주차 :: Unity Analysis - Memory in Unity

Unity 는 Memory 성능을 위해 3가지 Memory 를 사용한다.

 

1. Managed memory: Heap 과 Garbage Collector 로 메모리를 자동으로 할당&해제 하는 메모리

2. C# unmanaged memory: C# Collections package 데이터 구조로 구현 및 관리 가능.

3. Native memory: Unity Engine 을 실행하는데 사용하는 C++ 메모리. 사용자가 직접 Access 할 수는 없으나 알고는 있어야 하는 부분.

 

---

 

* Managed memory

Mono 와  IL2CPP 의 scripting virtual machines(VMs)은 Managed memory 를 실행한다.

 

1) The managed heap: VMs 가 Garbage Collector 로 자동으로 컨트롤하는 메모리 부분.

그래서 managed heap 에 할당된 메모리를 GC Allocation 이라고 부릅니다. GC Allocation 은 Profiler 가 기록한다.

A 는 이용가능 영역

빈공간은 해제된 부분, A 는 새로 추가될 데이터

 

회색 점선과 같은 메모리 단편화가 발생했을 때, GC 는 1) 빈공간에 먼저 넣기를 시도하고, 안될 경우 2) 힙을 확장합니다.

* 이 때, 힙은 이전 메모리의 2배 만큼 확장 됩니다. <- 이게 문제

ex) reference 타입, boxing 된 값형식 object.

Built-in reference types - C# reference - C#

Boxing and Unboxing - C# Programming Guide - C#

 

2) The scripting stack: 코드 범위 { } 안에서 할당되고 해제되는 부분.

 

3) Native VM memory:  Unity Scripting Layer 와 관련된 메모리가 포함된다. Generics 사용과 관련된 메모리, reflection이 사용하는 메타 데이터, VMs 을 실행하는데 필요한 메모리가 포함되어 있다는 건 알고 있자.

 

- Managed memory의 장점: 메모리 관리를 자동으로 해줌.

- Managed memory의 단점: 메모리 해제/할당 방식을 예측할 수 없어서 불안정한 성능 문제가 발생할 수 있다. 예측 가능해야만 하는 부분은 C# unmanaged memory 를 사용해야 한다.

 

 

* C# unmanaged memory

job system, burst 등 메모리 예측이 가능해야할 경우 C# Collection package 데이터 구조와 Allocator를 로 C# unmanaged memory 를 사용할 수 있다.

NativeArray<int> nums = new NativeArray<int>(10, Allocator.TempJob);

// Create and schedule a job that uses the array.
ExampleJob job = new ExampleJob { Nums = nums };
JobHandle handle = job.Schedule();

// Create and schedule a job that will dispose the array after the ExampleJob has run.
// Returns the handle of the new job.
handle = nums.Dispose(handle);

Collections package | Collections | 2.4.0

 

 

* Native memory

Unity 엔진 내부의 C/C++ 코어에 있는 Native Memory. Unity 자체 메모리 관리 시스템이다. 직접 접근은 불가능하나 Profiler Marker 로 이 메모리가 애플리케이션에 어떤 영향을 미치는지 확인할 수 있다.

Unity - Manual: Common Profiler markers

 

---

The managed heap 에서 나왔던 Garbage Collector 개념을 자세히 살펴보자.

 

*Garbage Collector: Unity 가 더이상 사용하지 않는 객체에서 메모리를 회수 함.

Heap 에 할당을 시도했는데 Heap에 할당을 수요할 여유가 없을 경우 Garbage Collector 를 실행 함.

Garbage Collector 가 더 이상 참조하지 않는 모든 객체를 삭제하여 메모리를 확보함. 

 

- Garbage Collector 속성 2가지

1) Incremental garbage collector: Garbage Collector 프로세스를 한번에 실행하는것이 아니라 여러 프레임에 걸쳐 실행한다.

2) Incremental garbage collector disabled: Incremental GC 를 비활성화하면 GC가 Heap 의 객체를 검사하고 처리하기 위해 Application 실행을 중지해버린다.

=> GC 를 쪼개서 실행하는 것이 나은 곳과 GC 를 한번에 실행하는 것이 나은 부분이 있기에 Incremental GC 를 실행시켜서 프레임을 떨어트릴 건지 프레임이 살짝 멈추더라도 한번에 정리하는게 나을 것인지 고민이 필요하다.

3) Disable automatic garbage collector: 자동 GC 사용 안함. 아래와 같은 코드로 GC 를 실행하는 시기를 완전히 제어할 수 있다.

// GC 활성화
GarbageCollector.GCMode = GarbageCollector.Mode.Enabled;
// GC 비활성화
GarbageCollector.GCMode = GarbageCollector.Mode.Disabled;

// 점진적 GC 주기 설정
GarbageCollector.CollectIncremental(ulong nanoseconds);

 

* GC 의 Allocation 을 추적할 수 있는 방법

: Unity Profiler 의 CPU Usage module, Unity Profiler 의 Memory Module, The Memory Profiler package: 

* GC 트리거를 줄이는 방법

1) Managed Heap 사용량을 줄이자.

2) 재사용가능한 Object Pool 을 사용하자

3) 문자열을 연결할 때 System.Text.StringBuilder 를 사용하자.

: C# 의 문자열은 불변참조 유형이다. 따라서 문자열 변수가 일단 생성되면 수정할 때 완전히 새로운 문자열이 생성되어 Heap 에 저장된다. 따라서 문자열을 연결해야 한다면 System.Text.StringBuilder 사용하자.

using UnityEngine;

public class ExampleScript : MonoBehaviour {
    string ConcatExample(string[] stringArray) {
        string result = "";
        for (int i = 0; i < stringArray.Length; i++) {
            result += stringArray[i];
        }
        return result;
    }

}

"A", "AB", "ABC", "ABCD", "ABCDE" 가 heap 에 저장된다. "ABCDE" 만 있으면 되는데 나머지 것들이 중복 할당 되는 것.

 

// Good C# script example: StringBuilder avoids creating temporary strings,
// and only allocates heap memory for the final result string.
using UnityEngine;
using System.Text;

public class ExampleScript : MonoBehaviour {
    private StringBuilder _sb = new StringBuilder(16);

    string ConcatExample(string[] stringArray) {
        _sb.Clear();
        for (int i = 0; i < stringArray.Length; i++) {
            _sb.Append(stringArray[i]);
        }
        return _sb.ToString();
    }
}

 

4) 배열 값을 반환하는 메소드는 배열이 reference type 이라는 것을 이용하자.

using UnityEngine;
using System.Collections;

public class ExampleScript : MonoBehaviour {
    float[] RandomList(int numElements) {
        var result = new float[numElements];
        for (int i = 0; i < numElements; i++) {
            result[i] = Random.value;
        }
        return result;
    }
}

RandomList 함수를 호출할 때 마다 배열이 생성되어 heap 에 할당되고 result 를 반환한 후에도 result 값이 heap 에 남아 있는다. 

 

using UnityEngine;
using System.Collections;

public class ExampleScript : MonoBehaviour {
    void RandomList(float[] arrayToFill) {
        for (int i = 0; i < arrayToFill.Length; i++) {
            arrayToFill[i] = Random.value;
        }
    }
}

위와 같이 인자로 보내면 reference type 이므로 배열을 재사용하여 heap 에 새롭게 할당되지 않는다.

 

5) Collection 과 Array 를 재사용하자.

void Update() {
    List<float> nearestNeighbors = new List<float>();

    findDistancesToNearestNeighbors(nearestNeighbors);
    nearestNeighbors.Sort();

    // … use the sorted list somehow …
}

위 코드는 Update 문이 호출될 때 마다 List 를 계속 생성하여 Heap 에 할당한다.

 

List<float> m_NearestNeighbors = new List<float>();

void Update() {
    m_NearestNeighbors.Clear();
    findDistancesToNearestNeighbors(NearestNeighbors);
    m_NearestNeighbors.Sort();

    // … use the sorted list somehow …
}

한번 생성한 List 를 재사용하여 사용하면 Heap 에 새로 할당하지 않는다.

 

6) Boxing 을 피하자.

: Boxing 은 임시 메모리 할당의 일반적인 원인 중에 하나다. Value 유형의 변수가 Reference 유형으로 변환될 때 발생한다.

int x = 1;
object y = new object();
y.Equals(x);

 

7) Array-valued Unity APIs를 사용할 때 single array allocation 을 이용하자.

void Update() {
    for(int i = 0; i < mesh.vertices.Length; i++) {
        float x, y, z;

        x = mesh.vertices[i].x;
        y = mesh.vertices[i].y;
        z = mesh.vertices[i].z;

        // ...

        DoSomething(x, y, z);   
    }
}

Loop 안에 mesh.vertices.Length를 호출하게 되면 Loop 가 1회 동작할 때마다 4개의 정점 배열 복사본을 불필요하게 만든다. 할당은 .vertices 속성에 접근할 때마다 이루어진다.

 

void Update() {
    var vertices = mesh.vertices;

    for(int i = 0; i < vertices.Length; i++) {

        float x, y, z;

        x = vertices[i].x;
        y = vertices[i].y;
        z = vertices[i].z;

        // ...

        DoSomething(x, y, z);   
    }
}

Loop 구문 전에 vertices 를 저장하여 single array 할당으로 만들 수 있다.

 

List<Vector3> m_vertices = new List<Vector3>();

void Update() {
    mesh.GetVertices(m_vertices);

    for(int i = 0; i < m_vertices.Length; i++) {

        float x, y, z;

        x = m_vertices[i].x;
        y = m_vertices[i].y;
        z = m_vertices[i].z;

        // ...

        DoSomething(x, y, z);   
    }
}

가장 베스트는 위의 코드 이다. Update 구문 밖에서 vertice 들을 갖고 있는 것.

 

그 외 할당되는 API와 할당되지 않는 API 는 아래와 같다. 가능하면 Non-allocating API 를 사용하는 것도 방법이다.