Unity 메모리 관리 및 가비지 컬렉션 최적화 🚀

안녕, 친구들! 오늘은 Unity 개발자라면 꼭 알아야 할 초중요 주제, 바로 메모리 관리와 가비지 컬렉션 최적화에 대해 재밌게 얘기해볼 거야. 🎮✨ 이 주제가 좀 어렵게 들릴 수도 있지만, 걱정 마! 내가 쉽고 재밌게 설명해줄 테니까.

우리가 Unity로 게임을 만들 때, 메모리 관리는 정말 중요해. 왜냐고? 메모리를 잘 관리하면 게임이 빠르고 부드럽게 돌아가거든! 반대로 메모리 관리를 소홀히 하면... 음, 상상해봐. 게임이 버벅거리고, 프레임이 떨어지고, 최악의 경우 크래시까지 날 수 있어. 😱

그래서 오늘은 Unity에서 메모리를 어떻게 관리하고, 가비지 컬렉션을 최적화하는지 자세히 알아볼 거야. 이 지식만 있으면 네가 만드는 게임이 훨씬 더 효율적으로 돌아갈 거라고!

💡 Pro Tip: 메모리 관리는 게임 개발에서 정말 중요한 스킬이야. 이걸 마스터하면, 너의 게임 개발 실력이 한층 더 업그레이드될 거야!

자, 그럼 이제부터 Unity의 메모리 관리와 가비지 컬렉션의 세계로 빠져볼까? 준비됐어? Let's go! 🚀

1. Unity의 메모리 구조 이해하기 🧠

Unity 게임 엔진에서 메모리 관리를 제대로 하려면, 먼저 Unity의 메모리 구조를 이해해야 해. 그래야 어떤 부분에서 메모리 문제가 발생할 수 있는지, 어떻게 최적화할 수 있는지 알 수 있거든.

1.1 Unity의 메모리 영역

Unity의 메모리는 크게 세 가지 영역으로 나눌 수 있어:

Managed Heap (관리되는 힙)
Native Memory (네이티브 메모리)
Graphics Memory (그래픽 메모리)

각 영역에 대해 자세히 알아보자!

1.1.1 Managed Heap (관리되는 힙) 🏠

Managed Heap은 C# 스크립트에서 생성하는 대부분의 객체들이 저장되는 곳이야. 예를 들어, 너가 new 키워드로 생성하는 객체들이 여기에 저장돼. 이 영역은 .NET의 가비지 컬렉터(GC)에 의해 관리되지.

🎈 예시:


    Vector3 position = new Vector3(0, 1, 0);
    List<GameObject> enemies = new List<GameObject>();

이런 코드에서 생성되는 Vector3 객체나 List 객체는 Managed Heap에 저장돼.

Managed Heap의 특징:

자동으로 메모리 관리가 이루어짐 (GC가 담당)
객체의 생성과 소멸이 자주 일어남
메모리 단편화가 발생할 수 있음

1.1.2 Native Memory (네이티브 메모리) 🏭

Native Memory는 C++로 작성된 Unity 엔진 내부 코드나 플러그인에서 사용하는 메모리 영역이야. 이 영역은 GC의 관리를 받지 않아서 개발자가 직접 관리해야 해.

🔧 Native Memory 사용 예:

Unity의 내부 시스템 (렌더링 엔진, 물리 엔진 등)
네이티브 플러그인
Asset Bundles

Native Memory의 특징:

수동으로 메모리 관리가 필요함
GC의 영향을 받지 않아 성능상 이점이 있을 수 있음
메모리 누수의 위험이 있음 (잘못 관리하면)

1.1.3 Graphics Memory (그래픽 메모리) 🎨

Graphics Memory는 텍스처, 메시, 셰이더 등 그래픽 관련 데이터를 저장하는 영역이야. 이 메모리는 GPU에 의해 관리되고 사용돼.

🖼️ Graphics Memory 사용 예:

텍스처와 스프라이트
3D 모델의 메시 데이터
셰이더와 머티리얼
렌더 텍스처

Graphics Memory의 특징:

GPU에 의해 관리됨
그래픽 퀄리티와 직접적인 연관이 있음
최적화가 게임의 시각적 성능에 큰 영향을 미침

1.2 메모리 할당과 해제 프로세스

이제 Unity에서 메모리가 어떻게 할당되고 해제되는지 알아보자. 이 과정을 이해하면 메모리 관리를 더 효율적으로 할 수 있어!

1.2.1 Managed Heap에서의 메모리 할당

Managed Heap에서 메모리 할당은 다음과 같은 과정으로 이루어져:

객체 생성 요청: 코드에서 new 키워드를 사용해 새로운 객체를 생성하면, CLR(Common Language Runtime)에 메모리 할당을 요청해.
메모리 할당: CLR은 Managed Heap에서 적절한 크기의 연속된 메모리 공간을 찾아 할당해.
객체 초기화: 할당된 메모리에 객체의 데이터를 초기화해.
참조 반환: 생성된 객체의 메모리 주소(참조)를 반환해.

💡 알아두면 좋은 점: Managed Heap은 "세대별 가비지 컬렉션" 방식을 사용해. 이는 객체를 생존 기간에 따라 다른 "세대"로 분류하고, 각 세대마다 다른 빈도로 가비지 컬렉션을 수행하는 방식이야. 이에 대해서는 나중에 더 자세히 설명할게!

1.2.2 Native Memory에서의 메모리 할당

Native Memory의 할당 과정은 조금 다르지:

메모리 할당 요청: C++ 코드에서 malloc(), new 등의 함수를 사용해 메모리 할당을 요청해.
운영체제의 메모리 할당: 운영체제가 요청된 크기의 메모리를 할당해.
포인터 반환: 할당된 메모리의 시작 주소(포인터)를 반환해.

Native Memory는 개발자가 직접 관리해야 해. 즉, 사용이 끝난 메모리는 개발자가 직접 해제해야 한다는 거지.

1.2.3 Graphics Memory에서의 메모리 할당

Graphics Memory의 할당은 주로 Unity 엔진에 의해 자동으로 이루어져:

리소스 로드: 텍스처, 메시 등의 그래픽 리소스를 로드하면, Unity가 자동으로 Graphics Memory 할당을 처리해.
GPU 메모리 할당: 필요한 크기의 GPU 메모리가 할당돼.
데이터 전송: CPU 메모리에서 GPU 메모리로 데이터가 전송돼.

Graphics Memory의 관리는 주로 Unity 엔진과 GPU 드라이버에 의해 이루어지지만, 개발자도 리소스의 로드와 언로드 타이밍을 잘 제어해야 해.

1.3 메모리 해제 프로세스

메모리 해제는 할당만큼이나 중요해. 제대로 해제하지 않으면 메모리 누수가 발생할 수 있거든. 각 메모리 영역별로 해제 과정을 살펴보자.

1.3.1 Managed Heap의 메모리 해제

Managed Heap의 메모리 해제는 가비지 컬렉터(GC)에 의해 자동으로 이루어져:

참조 추적: GC는 루트(스택, 정적 변수 등)에서 시작해 모든 살아있는 객체를 추적해.
마킹: 살아있는 객체들을 표시해.
스위핑: 표시되지 않은 객체들의 메모리를 해제해.
압축: 필요에 따라 살아남은 객체들을 모아 메모리 단편화를 줄여.

🌟 Unity의 특별한 점: Unity는 자체적인 Incremental GC를 사용해. 이는 GC 작업을 여러 프레임에 걸쳐 나누어 수행함으로써, GC로 인한 프레임 드롭을 최소화하려고 노력해.

1.3.2 Native Memory의 메모리 해제

Native Memory의 해제는 개발자의 책임이야:

해제 함수 호출: free(), delete 등의 함수를 사용해 메모리를 해제해야 해.
메모리 반환: 해제된 메모리는 운영체제에 반환돼.

주의할 점은, 메모리를 해제하지 않거나 잘못 해제하면 메모리 누수나 댕글링 포인터 같은 심각한 문제가 발생할 수 있어.

1.3.3 Graphics Memory의 메모리 해제

Graphics Memory의 해제는 주로 Unity 엔진에 의해 관리되지만, 개발자도 일부 관여할 수 있어:

리소스 언로드: Resources.UnloadAsset(), Destroy() 등의 함수를 사용해 그래픽 리소스를 언로드할 수 있어.
자동 해제: 씬 전환 시 많은 그래픽 리소스가 자동으로 해제돼.
가비지 컬렉션: Unity의 AssetBundle 시스템은 자체적인 가비지 컬렉션 메커니즘을 가지고 있어, 사용되지 않는 에셋을 자동으로 언로드해.

그래픽 메모리를 효율적으로 관리하려면, 필요 없는 텍스처나 메시를 적절히 언로드하고, 메모리 사용량이 큰 에셋들의 라이프사이클을 잘 관리해야 해.

1.4 메모리 단편화

메모리 단편화는 메모리 관리에서 피하기 어려운 문제 중 하나야. 이게 뭔지, 왜 문제가 되는지 알아보자.

1.4.1 메모리 단편화란?

메모리 단편화는 메모리 공간이 작은 조각들로 나뉘어 있어 큰 객체를 할당하기 어려운 상태를 말해. 마치 퍼즐 조각들이 흩어져 있는 것처럼, 사용 가능한 메모리가 연속되지 않고 흩어져 있는 거지.

🧩 비유로 이해하기: 메모리 단편화는 마치 책장에 책을 꽂는 것과 비슷해. 작은 책들을 여기저기 꽂다 보면, 나중에 큰 책을 꽂을 자리가 없어지는 것처럼 말이야!

1.4.2 메모리 단편화의 종류

메모리 단편화는 크게 두 가지로 나눌 수 있어:

외부 단편화: 메모리 블록 사이에 작은 빈 공간들이 생기는 현상. 이 빈 공간들의 총합은 크지만, 연속되지 않아 큰 객체를 할당하기 어려워.
내부 단편화: 할당된 메모리 블록 내부에 사용되지 않는 공간이 생기는 현상. 예를 들어, 100바이트가 필요한데 128바이트 블록을 할당받으면 28바이트가 낭비돼.

1.4.3 Unity에서의 메모리 단편화

Unity에서 메모리 단편화는 주로 Managed Heap에서 발생해. 객체들이 생성되고 소멸되는 과정에서 메모리 공간이 조각조각 나뉘게 되는 거지.

Unity의 GC는 이런 단편화를 줄이기 위해 "압축" 과정을 수행해. 하지만 이 과정이 자주 일어나면 성능에 영향을 줄 수 있어.

🛠️ 단편화 줄이기 팁:

객체 풀링을 사용해 객체의 생성과 소멸을 줄이기
큰 객체는 Native Memory에 할당하기
자주 변경되는 데이터는 구조체(struct)로 관리하기

1.5 메모리 누수

메모리 누수는 프로그램이 더 이상 필요하지 않은 메모리를 계속 점유하고 있는 현상을 말해. 이는 프로그램의 성능을 저하시키고, 최악의 경우 시스템 크래시를 일으킬 수 있어.

1.5.1 Managed Heap에서의 메모리 누수

Managed Heap에서의 메모리 누수는 주로 다음과 같은 경우에 발생해:

정적 참조: 정적 변수나 싱글톤 패턴에서 객체를 계속 참조하고 있는 경우
이벤트 구독 해제 실패: 이벤트에 등록된 핸들러를 제거하지 않은 경우
순환 참조: 객체들이 서로를 참조하여 GC가 해제하지 못하는 경우

🚰 메모리 누수 예시:


    public class LeakyManager : MonoBehaviour
    {
        private static List<GameObject> allObjects = new List<GameObject>();

        void Start()
        {
            // 이 리스트는 계속 커지기만 하고 비워지지 않아!
            allObjects.Add(gameObject);
        }
    }

1.5.2 Native Memory에서의 메모리 누수

Native Memory에서의 메모리 누수는 더 위험할 수 있어. 왜냐하면 GC가 관리하지 않기 때문이지. 주로 다음과 같은 경우에 발생해:

메모리 해제 실패: malloc()으로 할당한 메모리를 free()하지 않은 경우
리소스 해제 실패: 파일 핸들, 네트워크 소켓 등을 닫지 않은 경우
잘못된 메모리 관리: 포인터를 잃어버리거나 잘못 관리하는 경우

1.5.3 Unity에서 메모리 누수 방지하기

Unity에서 메모리 누수를 방지하기 위해 다음과 같은 방법을 사용할 수 있어:

객체 해제 확인: OnDestroy() 메서드에서 모든 참조를 정리하고, 이벤트 구독을 해제해.
약한 참조 사용: WeakReference를 사용해 객체가 필요 없어졌을 때 GC가 수집할 수 있게 해.
프로파일링 도구 사용: Unity Profiler를 사용해 메모리 사용량을 모니터링하고 누수를 찾아내.
코루틴 관리: 사용이 끝난 코루틴은 반드시 StopCoroutine()을 호출해 정지시켜.

💡 Pro Tip: Unity의 Memory Profiler 패키지를 사용하면 더 자세한 메모리 분석이 가능해. 이를 통해 메모리 누수의 원인을 더 쉽게 찾을 수 있지!

이렇게 Unity의 메모리 구조에 대해 자세히 알아봤어. 이해하기 좀 어려웠을 수도 있지만, 이 지식은 앞으로 네가 Unity로 게임을 개발할 때 정말 큰 도움이 될 거야. 메모리를 효율적으로 관리하면, 게임의 성능이 훨씬 좋아지고 안정성도 높아진다는 걸 잊지 마!

다음 섹션에서는 가비지 컬렉션에 대해 더 자세히 알아볼 거야. 가비지 컬렉션이 어떻게 작동하는지, 그리고 어떻게 최적화할 수 있는지 배워보자고!

2. Unity의 가비지 컬렉션 이해하기 🗑️

자, 이제 Unity의 가비지 컬렉션(Garbage Collection, GC)에 대해 자세히 알아볼 차례야. GC는 메모리 관리의 핵심이라고 할 수 있어. 잘 이해하고 활용하면 게임의 성능을 크게 향상시킬 수 있지!

2.1 가비지 컬렉션이란?

가비지 컬렉션은 프로그램에서 더 이상 사용하지 않는 메모리를 자동으로 찾아내 해제하는 메모리 관리 기법이야. C#과 같은 관리형 언어에서는 개발자가 직접 메모리를 해제할 필요 없이 GC가 이 작업을 대신 해주지.

🚮 GC의 역할:

더 이상 사용되지 않는 객체 식별
해당 객체가 사용하던 메모리 해제
메모리 단편화 해결

2.2 Unity의 가비지 컬렉션 특징

Unity는 Mono나 IL2CPP 런타임을 사용하는데, 이들은 각각 조금씩 다른 GC 구현을 가지고 있어. 하지만 기본적인 원리는 비슷해:

2.2.1 세대별 가비지 컬렉션

Unity의 GC는 "세대별 가비지 컬렉션" 방식을 사용해. 이 방식은 객체를 수명에 따라 여러 세대로 나누고, 각 세대마다 다른 빈도로 GC를 수행해.

0세대 (Gen 0): 새로 생성된 객체들. 가장 자주 GC가 수행돼.
1세대 (Gen 1): 0세대 GC에서 살아남은 객체들. 중간 정도의 빈도로 GC가 수행돼.
2세대 (Gen 2): 오래 살아남은 객체들. 가장 드물게 GC가 수행돼.

💡 왜 세대별로 나눌까? 대부분의 객체는 생성 직후 곧 사용이 끝나기 때문이야. 세대별로 나누면 자주 사용되는 객체들은 덜 자주 검사하게 되어 GC의 효율성이 높아져.

2.2.2 Incremental GC

Unity는 Incremental GC라는 특별한 방식을 사용해. 이는 GC 작업을 여러 프레임에 걸쳐 나누어 수행하는 방식이야.

장점: GC로 인한 프레임 드롭을 줄일 수 있어.
단점: 전체 GC 시간은 조금 더 길어질 수 있어.

2.3 GC가 성능에 미치는 영향

GC는 자동으로 메모리를 관리해주는 편리한 기능이지만, 잘못 사용하면 게임 성능에 심각한 영향을 줄 수 있어.

2.3.1 GC의 부정적 영향

프레임 드롭: GC가 실행되는 동안 게임이 잠시 멈출 수 있어.
CPU 사용량 증가: GC 작업은 CPU 리소스를 소모해.
메모리 단편화: 반복적인 GC로 인해 메모리 단편화가 발생할 수 있어.

2.3.2 GC 모니터링

Unity Profiler를 사용하면 GC의 동작을 모니터링할 수 있어:

Profiler 창을 열고 (Window > Analysis > Profiler)
CPU Usage 섹션에서 "GC.Alloc" 항목을 확인해
Memory 섹션에서 전체 메모리 사용량과 GC 동작을 확인할 수 있어

🔍 주의 깊게 봐야 할 점: GC.Alloc이 자주 발생하거나, 메모리 사용량이 급격히 증가했다가 감소하는 패턴이 반복된다면 GC 최적화가 필요할 수 있어!

2.4 GC 최적화 전략

GC로 인한 성능 저하를 최소화하기 위해 다음과 같은 전략을 사용할 수 있어:

2.4.1 객체 생성 최소화

객체 풀링: 자주 생성/삭제되는 객체는 미리 만들어두고 재사용해.
구조체 사용: 작은 데이터는 클래스 대신 구조체를 사용해 스택에 할당해.
문자열 연산 최적화: StringBuilder를 사용해 문자열 연산을 최적화해.

2.4.2 메모리 할당 패턴 개선


  // 나쁜 예
  void Update() {
      Vector3 position = new Vector3(1, 2, 3); // 매 프레임마다 새 객체 생성
  }

  // 좋은 예
  private Vector3 position;
  void Start() {
      position = new Vector3(1, 2, 3); // 한 번만 생성
  }
  void Update() {
      position.Set(1, 2, 3); // 기존 객체 재사용
  }

2.4.3 LINQ 사용 주의

LINQ는 편리하지만, 많은 임시 객체를 생성할 수 있어. 성능이 중요한 부분에서는 전통적인 for 루프를 사용하는 것이 좋아.


  // 나쁜 예 (LINQ 사용)
  var result = myList.Where(x => x > 10).Select(x => x * 2).ToList();

  // 좋은 예 (전통적인 for 루프)
  var result = new List<int>();
  for (int i = 0; i < myList.Count; i++) {
      if (myList[i] > 10) {
          result.Add(myList[i] * 2);
      }
  }

2.4.4 코루틴 최적화

코루틴은 편리하지만, 잘못 사용하면 많은 가비지를 생성할 수 있어. 다음과 같이 최적화할 수 있어:

코루틴의 반환값으로 null을 사용하지 말고, WaitForSeconds 객체를 캐싱해서 재사용해.
가능하면 코루틴 대신 InvokeRepeating이나 커스텀 업데이트 매니저를 사용해.


  // 나쁜 예
  IEnumerator BadCoroutine() {
      while (true) {
          yield return new WaitForSeconds(1f); // 매번 새 객체 생성
      }
  }

  // 좋은 예
  private readonly WaitForSeconds wait = new WaitForSeconds(1f);
  IEnumerator GoodCoroutine() {
      while (true) {
          yield return wait; // 캐싱된 객체 재사용
      }
  }

2.4.5 값 타입 사용

작은 크기의 데이터 구조는 클래스 대신 구조체를 사용해. 구조체는 스택에 할당되어 GC의 대상이 되지 않아.


  // 클래스 (참조 타입)
  public class Position {
      public float x, y, z;
  }

  // 구조체 (값 타입)
  public struct Position {
      public float x, y, z;
  }

2.5 Unity의 GC 관련 API

Unity는 GC를 제어할 수 있는 몇 가지 API를 제공해:

System.GC.Collect(): 명시적으로 GC를 실행해. 하지만 주의해서 사용해야 해!
GarbageCollector.GCMode: GC 모드를 설정할 수 있어 (Disabled, Enabled, Manual).
GarbageCollector.incrementalTimeSliceNanoseconds: Incremental GC의 시간 슬라이스를 설정할 수 있어.

⚠️ 주의: System.GC.Collect()를 무분별하게 사용하면 오히려 성능이 저하될 수 있어. 정말 필요한 경우에만 사용하고, 대부분의 경우 Unity의 자동 GC에 맡기는 것이 좋아.

2.6 GC 최적화의 실제 사례

실제 게임 개발에서 GC 최적화가 어떻게 이루어지는지 간단한 예를 통해 살펴보자:

2.6.1 총알 시스템 최적화


  // 최적화 전
  public class BulletManager : MonoBehaviour {
      public GameObject bulletPrefab;

      void FireBullet() {
          GameObject bullet = Instantiate(bulletPrefab);
          Destroy(bullet, 5f);
      }
  }

  // 최적화 후
  public class BulletManager : MonoBehaviour {
      public GameObject bulletPrefab;
      private List<GameObject> bulletPool = new List<GameObject>();
      private int poolSize = 20;

      void Start() {
          // 미리 총알 풀 생성
          for (int i = 0; i < poolSize; i++) {
              GameObject bullet = Instantiate(bulletPrefab);
              bullet.SetActive(false);
              bulletPool.Add(bullet);
          }
      }

      void FireBullet() {
          GameObject bullet = GetBulletFromPool();
          bullet.SetActive(true);
          StartCoroutine(DeactivateBulletAfterDelay(bullet, 5f));
      }

      GameObject GetBulletFromPool() {
          foreach (GameObject bullet in bulletPool) {
              if (!bullet.activeInHierarchy) {
                  return bullet;
              }
          }
          // 풀이 부족하면 새로 생성
          GameObject newBullet = Instantiate(bulletPrefab);
          bulletPool.Add(newBullet);
          return newBullet;
      }

      IEnumerator DeactivateBulletAfterDelay(GameObject bullet, float delay) {
          yield return new WaitForSeconds(delay);
          bullet.SetActive(false);
      }
  }

이 예제에서는 총알을 매번 생성하고 삭제하는 대신, 미리 풀을 만들어두고 재사용하는 방식으로 변경했어. 이렇게 하면 GC의 부담을 크게 줄일 수 있지!

2.7 결론

가비지 컬렉션은 Unity 개발에서 매우 중요한 개념이야. GC를 잘 이해하고 최적화하면 게임의 성능을 크게 향상시킬 수 있어. 하지만 과도한 최적화는 코드의 가독성과 유지보수성을 해칠 수 있으니, 항상 균형을 잘 맞추는 것이 중요해.

기억해야 할 핵심 포인트는 다음과 같아:

불필요한 객체 생성을 최소화하기
객체 풀링을 적극 활용하기
값 타입과 구조체를 적절히 사용하기
Unity Profiler를 통해 GC 동작을 모니터링하기
최적화와 코드 가독성 사이의 균형 유지하기

이러한 원칙들을 잘 적용하면, GC로 인한 성능 저하를 최소화하고 더 부드럽고 효율적인 게임을 만들 수 있을 거야!

3. Unity 메모리 프로파일링 및 디버깅 🔍

메모리 관리와 GC 최적화에 대해 배웠으니, 이제 실제로 어떻게 메모리 문제를 찾아내고 해결하는지 알아보자. Unity에서 제공하는 강력한 프로파일링 도구들을 활용하면 메모리 문제를 효과적으로 진단하고 해결할 수 있어.

3.1 Unity Profiler 사용하기

Unity Profiler는 게임의 성능을 분석하는 가장 기본적이면서도 강력한 도구야. 메모리 사용량, GC 호출, CPU 사용량 등 다양한 정보를 제공해.

3.1.1 Profiler 창 열기

Unity 메뉴에서 Window > Analysis > Profiler를 선택해.
게임을 실행하고 Profiler 창에서 "Record" 버튼을 클릭해.

3.1.2 메모리 프로파일링

Profiler 창의 "Memory" 탭을 선택하면 다음과 같은 정보를 볼 수 있어:

Total Allocated: 전체 할당된 메모리 양
Total Reserved: 예약된 메모리 양
GC Allocated: GC에 의해 관리되는 메모리 양
GC Reserved: GC를 위해 예약된 메모리 양

💡 Tip: 메모리 사용량이 급격히 증가하거나, GC Allocated 값이 자주 변동한다면 메모리 누수나 과도한 가비지 생성을 의심해볼 수 있어.

3.1.3 GC 모니터링

Profiler의 "CPU Usage" 탭에서 "GC.Alloc"과 "GC.Collect" 항목을 확인할 수 있어. 이 값들이 자주 나타나거나 높은 값을 보인다면, GC 최적화가 필요할 수 있어.

3.2 Memory Profiler 패키지 사용하기

Unity의 Memory Profiler 패키지는 더 상세한 메모리 분석을 제공해. 이 도구를 사용하면 객체별 메모리 사용량, 참조 관계 등을 시각적으로 확인할 수 있어.

3.2.1 Memory Profiler 설치

Window > Package Manager를 열어.
검색창에 "Memory Profiler"를 입력하고 패키지를 설치해.

3.2.2 메모리 스냅샷 생성

Window > Analysis > Memory Profiler를 선택해 Memory Profiler 창을 열어.
"Capture" 버튼을 클릭해 현재 메모리 상태의 스냅샷을 생성해.

3.2.3 메모리 스냅샷 분석

Memory Profiler에서 제공하는 다양한 뷰를 활용해 메모리 사용 현황을 분석할 수 있어:

Tree Map: 객체 유형별 메모리 사용량을 시각적으로 보여줘.
References: 객체 간의 참조 관계를 보여줘. 순환 참조 등을 찾는 데 유용해.
Table: 상세한 메모리 사용 정보를 표 형태로 보여줘.

🔍 주목해야 할 점: 예상보다 많은 메모리를 차지하는 객체들, 비정상적으로 많은 인스턴스를 가진 객체들, 해제되지 않은 큰 에셋들을 찾아보세요.

3.3 메모리 누수 디버깅

메모리 누수는 찾기 어려울 수 있지만, 다음과 같은 방법으로 접근할 수 있어:

3.3.1 증상 식별

시간이 지날수록 메모리 사용량이 계속 증가함
특정 동작을 반복할 때마다 메모리가 증가하고 돌아오지 않음
GC가 자주 발생하지만 메모리가 해제되지 않음

3.3.2 디버깅 전략

메모리 스냅샷 비교: 게임 실행 전후의 메모리 스냅샷을 비교해 증가한 객체를 찾아.
코드 리뷰: 이벤트 구독, 코루틴, 싱글톤 등에서 메모리 누수가 발생하지 않는지 확인해.
점진적 테스트: 기능을 하나씩 추가하면서 어느 지점에서 메모리 누수가 시작되는지 파악해.

3.3.3 일반적인 메모리 누수 원인


  // 이벤트 구독 후 해제하지 않음
  public class LeakyClass : MonoBehaviour {
      void OnEnable() {
          EventManager.OnSomeEvent += HandleEvent;
      }

      // 이벤트 해제를 하지 않음!
      // void OnDisable() {
      //     EventManager.OnSomeEvent -= HandleEvent;
      // }

      void HandleEvent() {
          // 이벤트 처리
      }
  }

  // 정적 참조로 인한 메모리 누수
  public class StaticLeakyClass {
      public static List<GameObject> allObjects = new List<GameObject>();

      public static void AddObject(GameObject obj) {
          allObjects.Add(obj);
          // 객체를 제거하는 로직이 없음!
      }
  }