perf: TTS 파이프라인 ArrayPool 완전 적용으로 LOH 제거

TextToSpeechResponse에 IMemoryOwner 필드 추가
TextToSpeechClient에서 MemoryPool.Shared.Rent 사용
ChatTTSProcessor에서 WithAudioMemory로 변경
이중/삼중 LOH 할당 제거로 GC 압박 대폭 감소

Author: ImGdevel

ProjectVG.Application/Services/Chat/Processors/ChatTTSProcessor.cs

@@ -46,10 +46,14 @@ public async Task ProcessAsync(ChatProcessContext context)
             var processedCount = 0;
 
             foreach (var (idx, ttsResult) in ttsResults.OrderBy(x => x.idx)) {
-                if (ttsResult.Success == true && ttsResult.AudioData != null) {
+                if (ttsResult.Success == true && ttsResult.AudioMemoryOwner != null) {
                     var segment = context.Segments?[idx];
                     if (segment != null && context.Segments != null) {
-                        context.Segments[idx] = segment.WithAudioData(ttsResult.AudioData, ttsResult.ContentType!, ttsResult.AudioLength ?? 0f);
+                        context.Segments[idx] = segment.WithAudioMemory(
+                            ttsResult.AudioMemoryOwner,
+                            ttsResult.AudioDataSize,
+                            ttsResult.ContentType!,
+                            ttsResult.AudioLength ?? 0f);
                     }
 
                     if (ttsResult.AudioLength.HasValue) {

ProjectVG.Infrastructure/Integrations/TextToSpeechClient/Models/TextToSpeechResponse.cs

@@ -1,4 +1,5 @@
 using System.Text.Json.Serialization;
+using System.Buffers;
 
 namespace ProjectVG.Infrastructure.Integrations.TextToSpeechClient.Models
 {
@@ -17,11 +18,23 @@ public class TextToSpeechResponse
         public string? ErrorMessage { get; set; }
 
         /// <summary>
-        /// 오디오 데이터 (바이트 배열)
+        /// 오디오 데이터 (바이트 배열) - 레거시 호환성용
         /// </summary>
         [JsonIgnore]
         public byte[]? AudioData { get; set; }
 
+        /// <summary>
+        /// ArrayPool 기반 오디오 메모리 소유자 (LOH 방지)
+        /// </summary>
+        [JsonIgnore]
+        public IMemoryOwner<byte>? AudioMemoryOwner { get; set; }
+
+        /// <summary>
+        /// 실제 오디오 데이터 크기
+        /// </summary>
+        [JsonIgnore]
+        public int AudioDataSize { get; set; }
+
         /// <summary>
         /// 오디오 길이 (초)
         /// </summary>

ProjectVG.Infrastructure/Integrations/TextToSpeechClient/TextToSpeechClient.cs

@@ -50,8 +50,10 @@ public async Task<TextToSpeechResponse> TextToSpeechAsync(TextToSpeechRequest re
                     return voiceResponse;
                 }
 
-                // 스트림 기반으로 음성 데이터 읽기 (LOH 방지)
-                voiceResponse.AudioData = await ReadAudioDataWithPoolAsync(response.Content);
+                // ArrayPool 기반으로 음성 데이터 읽기 (LOH 방지)
+                var (memoryOwner, dataSize) = await ReadAudioDataWithPoolAsync(response.Content);
+                voiceResponse.AudioMemoryOwner = memoryOwner;
+                voiceResponse.AudioDataSize = dataSize;
                 voiceResponse.ContentType = response.Content.Headers.ContentType?.ToString();
 
                 if (response.Headers.Contains("X-Audio-Length"))
@@ -64,7 +66,7 @@ public async Task<TextToSpeechResponse> TextToSpeechAsync(TextToSpeechRequest re
                 }
 
                 _logger.LogDebug("[TTS][Response] 오디오 길이: {AudioLength:F2}초, ContentType: {ContentType}, 바이트: {Length}, 소요시간: {Elapsed}ms",
-                    voiceResponse.AudioLength, voiceResponse.ContentType, voiceResponse.AudioData?.Length ?? 0, elapsed);
+                    voiceResponse.AudioLength, voiceResponse.ContentType, voiceResponse.AudioDataSize, elapsed);
 
                 return voiceResponse;
             }
@@ -82,42 +84,50 @@ public async Task<TextToSpeechResponse> TextToSpeechAsync(TextToSpeechRequest re
         /// <summary>
         /// ArrayPool을 사용하여 스트림 기반으로 음성 데이터를 읽습니다 (LOH 할당 방지)
         /// </summary>
-        private async Task<byte[]?> ReadAudioDataWithPoolAsync(HttpContent content)
+        private async Task<(IMemoryOwner<byte>?, int)> ReadAudioDataWithPoolAsync(HttpContent content)
         {
             const int chunkSize = 32768; // 32KB 청크 크기
-            byte[]? buffer = null;
+            byte[]? readBuffer = null;
             MemoryStream? memoryStream = null;
 
             try
             {
-                buffer = _arrayPool.Rent(chunkSize);
+                readBuffer = _arrayPool.Rent(chunkSize);
                 memoryStream = new MemoryStream();
 
                 using var stream = await content.ReadAsStreamAsync();
                 int bytesRead;
 
                 // 청크 단위로 데이터 읽어서 MemoryStream에 복사
-                while ((bytesRead = await stream.ReadAsync(buffer, 0, chunkSize)) > 0)
+                while ((bytesRead = await stream.ReadAsync(readBuffer, 0, chunkSize)) > 0)
                 {
-                    await memoryStream.WriteAsync(buffer, 0, bytesRead);
+                    await memoryStream.WriteAsync(readBuffer, 0, bytesRead);
                 }
 
-                var result = memoryStream.ToArray();
+                var totalSize = (int)memoryStream.Length;
+
+                // ArrayPool에서 최종 데이터 크기만큼 메모리 할당
+                var resultMemoryOwner = MemoryPool<byte>.Shared.Rent(totalSize);
+
+                // MemoryStream에서 최종 메모리로 복사
+                memoryStream.Position = 0;
+                await memoryStream.ReadAsync(resultMemoryOwner.Memory.Slice(0, totalSize));
+
                 _logger.LogDebug("[TTS][ArrayPool] 음성 데이터 읽기 완료: {Size} bytes, 청크 크기: {ChunkSize}",
-                    result.Length, chunkSize);
+                    totalSize, chunkSize);
 
-                return result;
+                return (resultMemoryOwner, totalSize);
             }
             catch (Exception ex)
             {
                 _logger.LogError(ex, "[TTS][ArrayPool] 음성 데이터 읽기 실패");
-                return null;
+                return (null, 0);
             }
             finally
             {
-                if (buffer != null)
+                if (readBuffer != null)
                 {
-                    _arrayPool.Return(buffer);
+                    _arrayPool.Return(readBuffer);
                 }
                 memoryStream?.Dispose();
             }