perf: ArrayPool 기반 LOH 최적화로 음성 데이터 메모리 효율성 개선

ProjectVG.Application/Models/Chat/ChatProcessResultMessage.cs

@@ -1,4 +1,6 @@
 using System.Text.Json.Serialization;
+using System.Buffers;
+using System.Buffers.Text;
 
 namespace ProjectVG.Application.Models.Chat
 {
@@ -42,9 +44,9 @@ public record ChatProcessResultMessage
 
         public static ChatProcessResultMessage FromSegment(ChatSegment segment, string? requestId = null)
         {
-            var audioData = segment.HasAudio ? Convert.ToBase64String(segment.AudioData!) : null;
+            var audioData = segment.HasAudio ? ConvertToBase64Optimized(segment.GetAudioSpan()) : null;
             var audioFormat = segment.HasAudio ? segment.AudioContentType ?? "wav" : null;
-            
+
             return new ChatProcessResultMessage
             {
                 RequestId = requestId,
@@ -64,13 +66,43 @@ public ChatProcessResultMessage WithAudioData(byte[]? audioBytes)
         {
             if (audioBytes != null && audioBytes.Length > 0)
             {
-                return this with { AudioData = Convert.ToBase64String(audioBytes) };
+                return this with { AudioData = ConvertToBase64Optimized(new ReadOnlySpan<byte>(audioBytes)) };
             }
             else
             {
                 return this with { AudioData = null };
             }
         }
+
+        /// <summary>
+        /// ArrayPool을 사용한 메모리 효율적인 Base64 인코딩 (LOH 방지)
+        /// </summary>
+        private static string? ConvertToBase64Optimized(ReadOnlySpan<byte> data)
+        {
+            if (data.IsEmpty) return null;
+
+            var arrayPool = ArrayPool<byte>.Shared;
+            var base64Length = Base64.GetMaxEncodedToUtf8Length(data.Length);
+            var buffer = arrayPool.Rent(base64Length);
+
+            try
+            {
+                if (Base64.EncodeToUtf8(data, buffer, out _, out var bytesWritten) == OperationStatus.Done)
+                {
+                    // UTF8 바이트를 문자열로 변환
+                    return System.Text.Encoding.UTF8.GetString(buffer, 0, bytesWritten);
+                }
+                else
+                {
+                    // 폴백: 기존 방법 사용
+                    return Convert.ToBase64String(data);
+                }
+            }
+            finally
+            {
+                arrayPool.Return(buffer);
+            }
+        }
 
         public ChatProcessResultMessage WithCreditInfo(decimal? creditsUsed, decimal? creditsRemaining)
         {

ProjectVG.Application/Models/Chat/ChatSegment.cs

@@ -1,29 +1,50 @@
 using System.Collections.Generic;
+using System.Buffers;
 
 namespace ProjectVG.Application.Models.Chat
 {
     public record ChatSegment
     {
-        
+
         public string Content { get; init; } = string.Empty;
-        
+
         public int Order { get; init; }
-        
+
         public string? Emotion { get; init; }
-        
+
         public List<string>? Actions { get; init; }
-        
+
         public byte[]? AudioData { get; init; }
         public string? AudioContentType { get; init; }
         public float? AudioLength { get; init; }
 
+        // 스트림 기반 음성 데이터 처리를 위한 새로운 프로퍼티
+        public IMemoryOwner<byte>? AudioMemoryOwner { get; init; }
+        public int AudioDataSize { get; init; }
+
 
 
         public bool HasContent => !string.IsNullOrEmpty(Content);
-        public bool HasAudio => AudioData != null && AudioData.Length > 0;
+        public bool HasAudio => (AudioData != null && AudioData.Length > 0) || (AudioMemoryOwner != null && AudioDataSize > 0);
         public bool IsEmpty => !HasContent && !HasActions;
         public bool HasEmotion => !string.IsNullOrEmpty(Emotion);
         public bool HasActions => Actions != null && Actions.Any();
+
+        /// <summary>
+        /// 메모리 효율적인 방식으로 음성 데이터에 접근합니다
+        /// </summary>
+        public ReadOnlySpan<byte> GetAudioSpan()
+        {
+            if (AudioMemoryOwner != null && AudioDataSize > 0)
+            {
+                return AudioMemoryOwner.Memory.Span.Slice(0, AudioDataSize);
+            }
+            if (AudioData != null)
+            {
+                return new ReadOnlySpan<byte>(AudioData);
+            }
+            return ReadOnlySpan<byte>.Empty;
+        }
 
 
 
@@ -51,12 +72,55 @@ public static ChatSegment CreateAction(string action, int order = 0)
         // Method to add audio data (returns new record instance)
         public ChatSegment WithAudioData(byte[] audioData, string audioContentType, float audioLength)
         {
-            return this with 
-            { 
-                AudioData = audioData, 
-                AudioContentType = audioContentType, 
-                AudioLength = audioLength 
+            return this with
+            {
+                AudioData = audioData,
+                AudioContentType = audioContentType,
+                AudioLength = audioLength
+            };
+        }
+
+        /// <summary>
+        /// 메모리 효율적인 방식으로 음성 데이터를 추가합니다 (LOH 방지)
+        /// </summary>
+        public ChatSegment WithAudioMemory(IMemoryOwner<byte> audioMemoryOwner, int audioDataSize, string audioContentType, float audioLength)
+        {
+            return this with
+            {
+                AudioMemoryOwner = audioMemoryOwner,
+                AudioDataSize = audioDataSize,
+                AudioContentType = audioContentType,
+                AudioLength = audioLength,
+                // 기존 AudioData는 null로 설정하여 중복 저장 방지
+                AudioData = null
             };
         }
+
+        /// <summary>
+        /// 음성 데이터를 배열로 변환합니다 (필요한 경우에만 사용)
+        /// </summary>
+        public byte[]? GetAudioDataAsArray()
+        {
+            if (AudioData != null)
+            {
+                return AudioData;
+            }
+
+            if (AudioMemoryOwner != null && AudioDataSize > 0)
+            {
+                var span = AudioMemoryOwner.Memory.Span.Slice(0, AudioDataSize);
+                return span.ToArray();
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// 리소스 해제 (IMemoryOwner 해제)
+        /// </summary>
+        public void Dispose()
+        {
+            AudioMemoryOwner?.Dispose();
+        }
     }
 }

ProjectVG.Infrastructure/Integrations/TextToSpeechClient/TextToSpeechClient.cs

@@ -1,3 +1,4 @@
+using System.Buffers;
 using System.Text;
 using System.Text.Json;
 using Microsoft.Extensions.Logging;
@@ -9,6 +10,8 @@ public class TextToSpeechClient : ITextToSpeechClient
     {
         private readonly HttpClient _httpClient;
         private readonly ILogger<TextToSpeechClient> _logger;
+        private static readonly ArrayPool<byte> _arrayPool = ArrayPool<byte>.Shared;
+        private const int MaxPoolSize = 1024 * 1024; // 1MB max pooled size
 
         public TextToSpeechClient(HttpClient httpClient, ILogger<TextToSpeechClient> logger)
         {
@@ -47,7 +50,8 @@ public async Task<TextToSpeechResponse> TextToSpeechAsync(TextToSpeechRequest re
                     return voiceResponse;
                 }
 
-                voiceResponse.AudioData = await response.Content.ReadAsByteArrayAsync();
+                // 스트림 기반으로 음성 데이터 읽기 (LOH 방지)
+                voiceResponse.AudioData = await ReadAudioDataWithPoolAsync(response.Content);
                 voiceResponse.ContentType = response.Content.Headers.ContentType?.ToString();
 
                 if (response.Headers.Contains("X-Audio-Length"))
@@ -75,6 +79,50 @@ public async Task<TextToSpeechResponse> TextToSpeechAsync(TextToSpeechRequest re
             }
         }
 
+        /// <summary>
+        /// ArrayPool을 사용하여 스트림 기반으로 음성 데이터를 읽습니다 (LOH 할당 방지)
+        /// </summary>
+        private async Task<byte[]?> ReadAudioDataWithPoolAsync(HttpContent content)
+        {
+            const int chunkSize = 32768; // 32KB 청크 크기
+            byte[]? buffer = null;
+            MemoryStream? memoryStream = null;
+
+            try
+            {
+                buffer = _arrayPool.Rent(chunkSize);
+                memoryStream = new MemoryStream();
+
+                using var stream = await content.ReadAsStreamAsync();
+                int bytesRead;
+
+                // 청크 단위로 데이터 읽어서 MemoryStream에 복사
+                while ((bytesRead = await stream.ReadAsync(buffer, 0, chunkSize)) > 0)
+                {
+                    await memoryStream.WriteAsync(buffer, 0, bytesRead);
+                }
+
+                var result = memoryStream.ToArray();
+                _logger.LogDebug("[TTS][ArrayPool] 음성 데이터 읽기 완료: {Size} bytes, 청크 크기: {ChunkSize}",
+                    result.Length, chunkSize);
+
+                return result;
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "[TTS][ArrayPool] 음성 데이터 읽기 실패");
+                return null;
+            }
+            finally
+            {
+                if (buffer != null)
+                {
+                    _arrayPool.Return(buffer);
+                }
+                memoryStream?.Dispose();
+            }
+        }
+
         private string GetErrorMessageForStatusCode(int statusCode, string reasonPhrase)
         {
             return $"HTTP {statusCode}: {reasonPhrase}";

ProjectVG.Infrastructure/Realtime/WebSocketConnection/WebSocketClientConnection.cs

@@ -1,4 +1,5 @@
 using ProjectVG.Common.Models.Session;
+using System.Buffers;
 using System.Text;
 using System.Net.WebSockets;
 
@@ -9,6 +10,9 @@ namespace ProjectVG.Infrastructure.Realtime.WebSocketConnection
 	/// </summary>
 	public class WebSocketClientConnection : IClientConnection
 	{
+		private static readonly ArrayPool<byte> _arrayPool = ArrayPool<byte>.Shared;
+		private static readonly Encoding _utf8Encoding = Encoding.UTF8;
+
 		public string UserId { get; set; } = string.Empty;
 		public DateTime ConnectedAt { get; set; } = DateTime.UtcNow;
 		public System.Net.WebSockets.WebSocket WebSocket { get; set; } = null!;
@@ -21,20 +25,61 @@ public WebSocketClientConnection(string userId, WebSocket socket)
 		}
 
 		/// <summary>
-		/// 텍스트 메시지를 전송합니다
+		/// 텍스트 메시지를 전송합니다 (ArrayPool 사용으로 LOH 할당 방지)
 		/// </summary>
-		public Task SendTextAsync(string message)
+		public async Task SendTextAsync(string message)
 		{
-			var buffer = Encoding.UTF8.GetBytes(message);
-			return WebSocket.SendAsync(new ArraySegment<byte>(buffer), System.Net.WebSockets.WebSocketMessageType.Text, true, CancellationToken.None);
+			byte[]? rentedBuffer = null;
+			try
+			{
+				// UTF8 인코딩에 필요한 최대 바이트 수 계산
+				var maxByteCount = _utf8Encoding.GetMaxByteCount(message.Length);
+				rentedBuffer = _arrayPool.Rent(maxByteCount);
+
+				// 실제 인코딩된 바이트 수
+				var actualByteCount = _utf8Encoding.GetBytes(message, 0, message.Length, rentedBuffer, 0);
+
+				// ArraySegment 생성하여 실제 사용된 부분만 전송
+				var segment = new ArraySegment<byte>(rentedBuffer, 0, actualByteCount);
+				await WebSocket.SendAsync(segment, WebSocketMessageType.Text, true, CancellationToken.None);
+			}
+			finally
+			{
+				if (rentedBuffer != null)
+				{
+					_arrayPool.Return(rentedBuffer);
+				}
+			}
 		}
 
 		/// <summary>
 		/// 바이너리 메시지를 전송합니다
 		/// </summary>
 		public Task SendBinaryAsync(byte[] data)
 		{
-			return WebSocket.SendAsync(new ArraySegment<byte>(data), System.Net.WebSockets.WebSocketMessageType.Binary, true, CancellationToken.None);
+			return WebSocket.SendAsync(new ArraySegment<byte>(data), WebSocketMessageType.Binary, true, CancellationToken.None);
+		}
+
+		/// <summary>
+		/// 청크 방식으로 대용량 바이너리 데이터를 전송합니다 (LOH 방지)
+		/// </summary>
+		public async Task SendLargeBinaryAsync(byte[] data)
+		{
+			const int chunkSize = 32768; // 32KB 청크
+			var totalLength = data.Length;
+			var offset = 0;
+
+			while (offset < totalLength)
+			{
+				var remainingBytes = totalLength - offset;
+				var currentChunkSize = Math.Min(chunkSize, remainingBytes);
+				var isLastChunk = offset + currentChunkSize >= totalLength;
+
+				var segment = new ArraySegment<byte>(data, offset, currentChunkSize);
+				await WebSocket.SendAsync(segment, WebSocketMessageType.Binary, isLastChunk, CancellationToken.None);
+
+				offset += currentChunkSize;
+			}
 		}
 	}
 }