Perf : LOH 최적화

ProjectVG.Application/Models/Chat/ChatSegment.cs

@@ -3,7 +3,7 @@
 
 namespace ProjectVG.Application.Models.Chat
 {
-    public record ChatSegment
+    public record ChatSegment : IDisposable
     {
 
         public string Content { get; init; } = string.Empty;
@@ -37,7 +37,9 @@ public ReadOnlySpan<byte> GetAudioSpan()
         {
             if (AudioMemoryOwner != null && AudioDataSize > 0)
             {
-                return AudioMemoryOwner.Memory.Span.Slice(0, AudioDataSize);
+                var memory = AudioMemoryOwner.Memory;
+                var safeSize = Math.Min(AudioDataSize, memory.Length);
+                return memory.Span.Slice(0, safeSize);
             }
             if (AudioData != null)
             {
@@ -82,9 +84,26 @@ public ChatSegment WithAudioData(byte[] audioData, string audioContentType, floa
 
         /// <summary>
         /// 메모리 효율적인 방식으로 음성 데이터를 추가합니다 (LOH 방지)
+        /// 소유권이 이전되므로 호출자는 더 이상 audioMemoryOwner를 해제하지 않아야 합니다.
         /// </summary>
+        /// <param name="audioMemoryOwner">소유권이 이전될 메모리 소유자</param>
+        /// <param name="audioDataSize">실제 오디오 데이터 크기 (메모리 크기 이하여야 함)</param>
+        /// <param name="audioContentType">오디오 컨텐츠 타입</param>
+        /// <param name="audioLength">오디오 길이 (초)</param>
+        /// <returns>새로운 ChatSegment 인스턴스</returns>
+        /// <exception cref="ArgumentNullException">audioMemoryOwner가 null인 경우</exception>
+        /// <exception cref="ArgumentOutOfRangeException">audioDataSize가 유효하지 않은 경우</exception>
         public ChatSegment WithAudioMemory(IMemoryOwner<byte> audioMemoryOwner, int audioDataSize, string audioContentType, float audioLength)
         {
+            if (audioMemoryOwner is null)
+                throw new ArgumentNullException(nameof(audioMemoryOwner));
+
+            if (audioDataSize < 0 || audioDataSize > audioMemoryOwner.Memory.Length)
+                throw new ArgumentOutOfRangeException(
+                    nameof(audioDataSize),
+                    audioDataSize,
+                    $"audioDataSize는 0 이상 {audioMemoryOwner.Memory.Length} 이하여야 합니다.");
+
             return this with
             {
                 AudioMemoryOwner = audioMemoryOwner,
@@ -120,7 +139,28 @@ public ChatSegment WithAudioMemory(IMemoryOwner<byte> audioMemoryOwner, int audi
         /// </summary>
         public void Dispose()
         {
-            AudioMemoryOwner?.Dispose();
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        /// <summary>
+        /// 보호된 Dispose 패턴 구현
+        /// </summary>
+        /// <param name="disposing">관리되는 리소스를 해제할지 여부</param>
+        protected virtual void Dispose(bool disposing)
+        {
+            if (disposing && AudioMemoryOwner != null)
+            {
+                AudioMemoryOwner.Dispose();
+            }
+        }
+
+        /// <summary>
+        /// Finalizer - 관리되지 않는 리소스 정리 (최후 안전장치)
+        /// </summary>
+        ~ChatSegment()
+        {
+            Dispose(false);
         }
     }
 }

ProjectVG.Tests/Infrastructure/Integrations/MemoryPoolingPerformanceTests.cs

@@ -85,6 +85,103 @@ public void ChatSegment_MemoryOwner_vs_ByteArray_Test()
             _output.WriteLine($"최적화 방식 - HasAudio: {segment2.HasAudio}, 데이터 크기: {segment2.AudioDataSize}");
         }
 
+        [Fact]
+        public void ChatSegment_GetAudioSpan_SafetyBoundaryTest()
+        {
+            // 경계 조건 테스트: 유효한 범위 내에서의 메모리 접근 안전성 검증
+            var testData = GenerateTestAudioData(1000);
+            using var memoryOwner = MemoryPool<byte>.Shared.Rent(500); // 더 작은 메모리 할당
+            var actualMemorySize = memoryOwner.Memory.Length; // 실제 할당된 메모리 크기
+            var copySize = Math.Min(500, actualMemorySize);
+            testData.AsSpan(0, copySize).CopyTo(memoryOwner.Memory.Span);
+
+            // 유효한 크기로 설정 (실제 메모리 크기 이하)
+            var validSize = actualMemorySize - 10; // 안전한 크기
+            var segment = ChatSegment.CreateText("Test content")
+                .WithAudioMemory(memoryOwner, validSize, "audio/wav", 5.0f);
+
+            // GetAudioSpan이 정확한 크기를 반환해야 함
+            var span = segment.GetAudioSpan();
+
+            // 요청한 크기만큼 반환되어야 함
+            Assert.Equal(validSize, span.Length);
+            _output.WriteLine($"요청 크기: {validSize}, 실제 메모리: {actualMemorySize}, 반환된 span 크기: {span.Length}");
+        }
+
+        [Fact]
+        public void ChatSegment_GetAudioSpan_EmptyAndNullSafetyTest()
+        {
+            // null AudioMemoryOwner는 이제 예외가 발생해야 함 (ArgumentNullException)
+            var nullException = Assert.Throws<ArgumentNullException>(() =>
+                ChatSegment.CreateText("Test").WithAudioMemory(null!, 100, "audio/wav", 1.0f));
+            Assert.Equal("audioMemoryOwner", nullException.ParamName);
+
+            // AudioDataSize가 0인 경우는 여전히 정상 작동해야 함
+            using var memoryOwner = MemoryPool<byte>.Shared.Rent(100);
+            var segment2 = ChatSegment.CreateText("Test").WithAudioMemory(memoryOwner, 0, "audio/wav", 1.0f);
+            var span2 = segment2.GetAudioSpan();
+            Assert.True(span2.IsEmpty);
+
+            // 기존 AudioData 방식 (null 허용)
+            var segment3 = ChatSegment.CreateText("Test").WithAudioData(null!, "audio/wav", 1.0f);
+            var span3 = segment3.GetAudioSpan();
+            Assert.True(span3.IsEmpty);
+
+            _output.WriteLine("null 검증과 빈 케이스가 모두 안전하게 처리됨");
+        }
+
+        [Fact]
+        public void ChatSegment_WithAudioMemory_ValidationTest()
+        {
+            var testData = GenerateTestAudioData(100);
+            using var memoryOwner = MemoryPool<byte>.Shared.Rent(100);
+            testData.CopyTo(memoryOwner.Memory.Span);
+
+            // 정상 케이스
+            var validSegment = ChatSegment.CreateText("Test")
+                .WithAudioMemory(memoryOwner, 50, "audio/wav", 1.0f);
+            Assert.Equal(50, validSegment.AudioDataSize);
+
+            // null audioMemoryOwner 테스트
+            var nullException = Assert.Throws<ArgumentNullException>(() =>
+                ChatSegment.CreateText("Test").WithAudioMemory(null!, 100, "audio/wav", 1.0f));
+            Assert.Equal("audioMemoryOwner", nullException.ParamName);
+
+            // audioDataSize < 0 테스트
+            var negativeException = Assert.Throws<ArgumentOutOfRangeException>(() =>
+                ChatSegment.CreateText("Test").WithAudioMemory(memoryOwner, -1, "audio/wav", 1.0f));
+            Assert.Equal("audioDataSize", negativeException.ParamName);
+
+            // audioDataSize > memory.Length 테스트
+            var oversizeException = Assert.Throws<ArgumentOutOfRangeException>(() =>
+                ChatSegment.CreateText("Test").WithAudioMemory(memoryOwner, memoryOwner.Memory.Length + 1, "audio/wav", 1.0f));
+            Assert.Equal("audioDataSize", oversizeException.ParamName);
+
+            _output.WriteLine("모든 소유권 이전 검증 테스트 통과");
+        }
+
+        [Fact]
+        public void ChatSegment_Dispose_MemoryOwnerReleaseTest()
+        {
+            var testData = GenerateTestAudioData(100);
+            using var memoryOwner = MemoryPool<byte>.Shared.Rent(100);
+            testData.CopyTo(memoryOwner.Memory.Span);
+
+            var segment = ChatSegment.CreateText("Test")
+                .WithAudioMemory(memoryOwner, 100, "audio/wav", 1.0f);
+
+            // Dispose 호출 전에는 정상 접근 가능
+            Assert.True(segment.HasAudio);
+            Assert.Equal(100, segment.GetAudioSpan().Length);
+
+            // Dispose 호출
+            segment.Dispose();
+
+            // 메모리가 해제되었으므로 ObjectDisposedException 발생할 수 있음
+            // (실제 구현에 따라 다를 수 있음)
+            _output.WriteLine("Dispose 호출 완료 - 메모리 소유자 해제됨");
+        }
+
         private byte[] GenerateTestAudioData(int size)
         {
             var random = new Random(12345); // 고정 시드로 일관된 테스트