[sglang] [VLM] 멀티모달 임베딩 최적화: 청크 인식 인코딩과 이미지별 캐싱 도입

2026년 4월 4일수정: 2026년 4월 4일

PR 링크: sgl-project/sglang#22038 상태: Merged | 변경: +None / -None

들어가며

최근 SGLang 프로젝트의 GitHub 저장소에는 시각 언어 모델(VLM)의 추론 성능을 획기적으로 개선하기 위한 중요한 Pull Request(PR)가 제출되었습니다. 이 PR은 특히 멀티모달 데이터 처리 방식에 대한 근본적인 최적화를 포함하고 있으며, 주요 목표는 다음과 같습니다:

Per-image embedding cache: 기존의 요청 단위 캐시 대신 이미지별로 임베딩을 캐싱하여 캐시 재사용률을 높이고, 특정 이미지의 캐시 누락 시 전체 재계산을 방지합니다.
Chunk-aware ViT encoding: 비전 트랜스포머(ViT) 인코딩 시 현재 처리 중인 청크(chunk)와 겹치는 이미지들만 인코딩하도록 하여, 멀티 이미지 요청 시 GPU 메모리 사용량과 ViT 연산량을 줄입니다.
Lazy device transfer: 모든 이미지 특징(feature)을 미리 CPU에서 GPU로 옮기는 대신, 실제 임베딩 파이프라인에서 필요한 시점에 필요한 데이터만 GPU로 전송하도록 지연시킵니다.

이 PR은 이러한 개선을 통해 VLM 추론의 속도를 높이고 메모리 효율성을 극대화하는 것을 목표로 합니다. 본 글에서는 이 PR의 코드 변경 사항을 상세히 분석하고, 각 최적화가 왜 효과적인지, 그리고 실제 성능 향상 결과는 어떠한지에 대해 기술 블로그 형식으로 풀어내고자 합니다.

코드 분석

이 PR의 핵심 변경 사항은 python/sglang/srt/managers/mm_utils.py 파일에 집중되어 있습니다. 기존의 멀티모달 데이터 처리 로직을 더 효율적으로 만들기 위해 여러 함수가 수정되거나 새로 도입되었습니다.

1. 캐싱 및 장치 전송 로직 개선 (`mm_utils.py`)

가장 눈에 띄는 변화는 _get_chunked_prefill_embedding 함수가 _get_chunked_embedding_full과 _get_chunked_embedding_by_item으로 분리되고, _move_items_to_device 함수가 새로 도입된 것입니다. 또한, 기존의 get_embedding_items_per_chunk_with_extra_padding 함수는 제거되었습니다.

기존 코드 (일부 발췌, 제거된 부분):

--- a/python/sglang/srt/managers/mm_utils.py
+++ b/python/sglang/srt/managers/mm_utils.py
@@ -44,9 +44,6 @@
 _GPU_FEATURE_BUFFER: Optional[torch.Tensor] = None
 _BUFFER_OFFSET = 0
 
-_EXTRA_PRE_TOKENS = 0  # pre chunk extra token (0 for the moment)
-_EXTRA_POST_TOKENS = 0  # post chunk extra token (0 for the moment)
-
 _is_default_tensor_transport = None
 
 
@@ -462,269 +459,150 @@ def _get_precomputed_embedding(
 ]
 
 
-def get_embedding_items_per_chunk_with_extra_padding(
-    embedding_items_per_req: List["MultimodalDataItem"],
-    extend_prefix_len: int,
-    extend_seq_len: int,
-    items_offset: List[Tuple[int, int]]
-):
-    """
-    From all multimodal items of a request, select the subset that is "relevant to
-    this prefill chunk", and allow a small amount of extra padding on both sides
-    of the chunk boundary (for easier caching or cross-chunk reuse).
-    """
-    assert len(embedding_items_per_req) == len(items_offset), f"items_per_req({len(embedding_items_per_req)}) vs items_offset({len(items_offset)}) mismatch"
-
-    if extend_seq_len <= 0:
-        return []
-
-    # Current chunk's token range
-    chunk_start = extend_prefix_len
-    chunk_end = extend_prefix_len + extend_seq_len
-
-    # Current chunk's token range with extra padding
-    window_start = max(0, chunk_start - _EXTRA_PRE_TOKENS)
-    window_end = chunk_end + _EXTRA_POST_TOKENS
-
-    selected_items: List["MultimodalDataItem"] = []
-
-    for item, (start, end) in zip(embedding_items_per_req, items_offset):
-        if start >= end:
-            continue
-
-        # Check whether this item has overlap with [window_start, window_end)
-        # If has overlap, add the item into selected_item.
-        if end > window_start and start < window_end:
-            selected_items.append(item)
-
-    return selected_items
-
-
-# TODO: To be obsoleted.
def _get_chunked_prefill_embedding(
    data_embedding_func: DataEmbeddingFunc,
    embedding_items: List[MultimodalDataItem],
    items_size: List[int],
    prefix_length: List[int],
    extend_length: List[int],
    items_offset_list: List[List[Tuple[int, int]]],
    input_ids: torch.Tensor,
-) -> tuple[torch.Tensor | None, torch.Tensor]:
-    # Calculate embedding for each request, try to get it from cache to avoid repeated calculation
-    embedding_list = []
-    # FIXME(Xinyuan): temporary workaround for eagle3, which may have len(items_size) > len(prefix_length)
-    max_iterations = min(len(items_size) - 1, len(prefix_length))
-    for i in range(max_iterations):
-        if items_size[i] == items_size[i + 1]:
-            continue
-        embedding_items_per_req = embedding_items[items_size[i] : items_size[i + 1]]
-        items_offset = items_offset_list[i]
-        assert items_offset is not None, items_offset
-        # if all items has been prefixed, we do not need to calculate embedding
-        if all([offset_end < prefix_length[i] for _, offset_end in items_offset]):
-            continue
-        item_hashes = [item.hash for item in embedding_items_per_req]
-        embedding_items_hash = MultiModalStaticCache.combine_hashes(item_hashes)
-        embedding_per_req = embedding_cache.get(item_hashes)
-        if embedding_per_req is None:
-            embedding = data_embedding_func(embedding_items_per_req)
-            embedding_per_req = (
-                EmbeddingResult(embedding=embedding)
-                if isinstance(embedding, torch.Tensor)
-                else embedding
-            )
-            if not embedding_cache.set(embedding_items_hash, embedding_per_req):
-                print_warning_once(
-                    "Multimodal embedding cache is full. This typically occurs when a single "
-                    "embedding exceeds the cache size limit. Consider increasing the "
-                    "`SGLANG_VLM_CACHE_SIZE_MB` environment variable or reducing the input "
-                    "embedding size."
-                )
-
-        extend_prefix_len = prefix_length[i]
-        extend_seq_len = extend_length[i] if i < len(extend_length) else 0
-
-        if isinstance(embedding_per_req, EVSEmbeddingResult):
-            item = embedding_items_per_req[0]
-            input_ids, items_offset = (
-                embedding_per_req.redistribute_pruned_frames_placeholders(
-                    input_ids,
-                    items_offset,
-                    item=item,
-                    extend_prefix_len=extend_prefix_len,
-                    extend_seq_len=extend_seq_len,
-                )
-            )
-
-        embedding_per_req_chunk, _, _ = get_embedding_chunk(
-            embedding=embedding_per_req.embedding,
-            extend_prefix_len=extend_prefix_len,
-            extend_seq_len=extend_seq_len,
-            items_offset=items_offset,
-        )
-        embedding_list.append(embedding_per_req_chunk)
-    if len(embedding_list) == 0:
-        return None, input_ids
-    return torch.concat(embedding_list, dim=0), input_ids
-
-
-def get_embedding_chunk_remove_extra_padding(
-    embedding: torch.Tensor,
-    extend_prefix_len: int,
-    extend_seq_len: int,
-    items_offset: List[Tuple[int, int]],
-) -> Tuple[Optional[torch.Tensor], int, int]:
-    """
-    From the embedding computed on "items related to this chunk + extra padding",
-    trim out the token embeddings that are not needed for the current chunk, and
-    keep only those mm tokens covered by
-    [extend_prefix_len, extend_prefix_len + extend_seq_len).
-    """
-    if embedding is None or embedding.numel() == 0:
-        return None, 0, 0
-
-    chunk_start = extend_prefix_len
-    chunk_end = extend_prefix_len + extend_seq_len
-
-    if extend_seq_len <= 0 or chunk_start >= chunk_end:
-        return None, 0, 0
-
-    # The window with extra padding
-    window_start = max(0, chunk_start - _EXTRA_PRE_TOKENS)
-    window_end = chunk_end + _EXTRA_POST_TOKENS
-
-    # Iterate item_offset to choose item.
-    # We need to forward an embedding_idx to locate the item start-end position in embedding.
-    embedding_idx = 0
-    kept_slices: List[torch.Tensor] = []
-
-    num_tokens_before = 0
-    num_tokens_after = 0
-
-    for start, end in items_offset:
-        if start >= end:
-            continue
-
-        seg_len = end - start
-
-        # Check whether this item has been chosen into embedding_items_per_chunk or not.
-        selected = end > window_start and start < window_end
-
-        if selected:
-            # Extract the slice corresponding to this item from the embedding tensor
-            item_embedding = embedding[embedding_idx : embedding_idx + seg_len]
-
-            # Determine the relevant part of the slice for the current chunk
-            # The item's tokens are [start, end) in the global sequence.
-            # The chunk's tokens are [chunk_start, chunk_end) in the global sequence.
-            # We need the intersection of [start, end) and [chunk_start, chunk_end).
-            overlap_start = max(start, chunk_start)
-            overlap_end = min(end, chunk_end)
-
-            if overlap_start < overlap_end:
-                # Calculate the start and end indices within the item's embedding slice
-                slice_start_idx = overlap_start - start
-                slice_end_idx = overlap_end - start
-
-                kept_slices.append(item_embedding[slice_start_idx:slice_end_idx])
-            
-            # Count tokens before and after the chunk, within the item's range
-            num_tokens_before += max(0, min(end, chunk_start) - start)
-            num_tokens_after += max(0, end - max(end, chunk_end))
-        else:
-            # If the item was not selected for encoding (outside window), but it has tokens
-            # before or after the chunk, we need to account for them for padding calculations.
-            num_tokens_before += max(0, min(end, chunk_start) - start)
-            num_tokens_after += max(0, end - max(end, chunk_end))
-
-        embedding_idx += seg_len
-
-    if not kept_slices:
-        return None, num_tokens_before, num_tokens_after
-
-    trimmed_embedding = torch.cat(kept_slices, dim=0)
-    return trimmed_embedding, num_tokens_before, num_tokens_after
+
+def _move_items_to_device(
+    items: List[MultimodalDataItem], device: torch.device
+) -> None:
+    """Move item features to the target device (in-place, non-blocking)."""
+    for item in items:
+        if isinstance(item.feature, torch.Tensor) and item.feature.device != device:
+            item.feature = item.feature.to(device, non_blocking=True)
+
 
-def _get_chunked_prefill_embedding(
+def _get_chunked_embedding_full(
     data_embedding_func: DataEmbeddingFunc,
-    embedding_items: List[MultimodalDataItem],
-    items_size: List[int],
-    prefix_length: List[int],
-    extend_length: List[int],
-    items_offset_list: List[List[Tuple[int, int]]],
+    embedding_items_per_req: List[MultimodalDataItem],
+    items_offset: List[Tuple[int, int]],
+    extend_prefix_len: int,
+    extend_seq_len: int,
     input_ids: torch.Tensor,
-) -> tuple[torch.Tensor | None, torch.Tensor]:
-    # Calculate embedding for each request, try to get it from cache to avoid repeated calculation
-    embedding_list = []
-    # FIXME(Xinyuan): temporary workaround for eagle3, which may have len(items_size) > len(prefix_length)
-    max_iterations = min(len(items_size) - 1, len(prefix_length))
-    for i in range(max_iterations):
-        if items_size[i] == items_size[i + 1]:
-            continue
-        embedding_items_per_req = embedding_items[items_size[i] : items_size[i + 1]]
-        items_offset = items_offset_list[i]
-        assert items_offset is not None, items_offset
-        # if all items has been prefixed, we do not need to calculate embedding
-        if all([offset_end < prefix_length[i] for _, offset_end in items_offset]):
-            continue
-        item_hashes = [item.hash for item in embedding_items_per_req]
-        embedding_items_hash = MultiModalStaticCache.combine_hashes(item_hashes)
-        embedding_per_req = embedding_cache.get(item_hashes)
-        if embedding_per_req is None:
-            embedding = data_embedding_func(embedding_items_per_req)
-            embedding_per_req = (
-                EmbeddingResult(embedding=embedding)
-                if isinstance(embedding, torch.Tensor)
-                else embedding
-            )
-            if not embedding_cache.set(embedding_items_hash, embedding_per_req):
-                print_warning_once(
-                    "Multimodal embedding cache is full. This typically occurs when a single "
-                    "embedding exceeds the cache size limit. Consider increasing the "
-                    "`SGLANG_VLM_CACHE_SIZE_MB` environment variable or reducing the input "
-                    "embedding size."
-                )
-
-        extend_prefix_len = prefix_length[i]
-        extend_seq_len = extend_length[i] if i < len(extend_length) else 0
-
-        if isinstance(embedding_per_req, EVSEmbeddingResult):
-            item = embedding_items_per_req[0]
-            input_ids, items_offset = (
-                embedding_per_req.redistribute_pruned_frames_placeholders(
-                    input_ids,
-                    items_offset,
-                    item=item,
-                    extend_prefix_len=extend_prefix_len,
-                    extend_seq_len=extend_seq_len,
-                )
-            )
-
-        embedding_per_req_chunk, _, _ = get_embedding_chunk(
-            embedding=embedding_per_req.embedding,
-            extend_prefix_len=extend_prefix_len,
-            extend_seq_len=extend_seq_len,
-            items_offset=items_offset,
-        )
-        embedding_list.append(embedding_per_req_chunk)
-    if len(embedding_list) == 0:
-        return None, input_ids
-    return torch.concat(embedding_list, dim=0), input_ids
+
+    device: torch.device,
+) -> Tuple[Optional[torch.Tensor], torch.Tensor]:
+    """
+    Fallback: encode all items at once, cache combined result, extract chunk.
+    Used for non-bundled items or EVS results.
+    """
+    item_hashes = [item.hash for item in embedding_items_per_req]
+    embedding_items_hash = MultiModalStaticCache.combine_hashes(item_hashes)
+    embedding_per_req = embedding_cache.get(item_hashes)
+
+    if embedding_per_req is None:
+        _move_items_to_device(embedding_items_per_req, device)
+        embedding = data_embedding_func(embedding_items_per_req)
+        embedding_per_req = (
+            EmbeddingResult(embedding=embedding)
+            if isinstance(embedding, torch.Tensor)
+            else embedding
+        )
+        embedding_cache.set(embedding_items_hash, embedding_per_req)
+
+    if isinstance(embedding_per_req, EVSEmbeddingResult):
+        item = embedding_items_per_req[0]
+        input_ids, items_offset = (
+            embedding_per_req.redistribute_pruned_frames_placeholders(
+                input_ids,
+                items_offset,
+                item=item,
+                extend_prefix_len=extend_prefix_len,
+                extend_seq_len=extend_seq_len,
+            )
+        )
+
+    embedding_per_req_chunk, _, _ = get_embedding_chunk(
+        embedding=embedding_per_req.embedding,
+        extend_prefix_len=extend_prefix_len,
+        extend_seq_len=extend_seq_len,
+        items_offset=items_offset,
+    )
+    return embedding_per_req_chunk, input_ids
+
+
def _get_chunked_embedding_by_item(
+    data_embedding_func: DataEmbeddingFunc,
+    embedding_items_per_req: List[MultimodalDataItem],
+    items_offset: List[Tuple[int, int]],
+    extend_prefix_len: int,
+    extend_seq_len: int,
+    device: torch.device,
+) -> Optional[torch.Tensor]:
+    """
+    Per-image chunk-aware encoding: only encode images overlapping with the
+    current chunk, cache each image individually.
+    Items must already be split per-image (each item has exactly one offset).
+    """
+    chunk_start = extend_prefix_len
+    chunk_end = extend_prefix_len + extend_seq_len  # exclusive
+
+    if extend_seq_len <= 0:
+        return None
+
+    # 1. Find items overlapping with current chunk
+    # offsets are (start, end) inclusive on both ends
+    overlapping = []
+    for idx, (item, offset) in enumerate(zip(embedding_items_per_req, items_offset)):
+        start, end = offset
+        if end >= chunk_start and start < chunk_end:
+            overlapping.append((idx, item, start, end))
+
+    if not overlapping:
+        return None
+
+    # 2. Check per-image cache for each overlapping item
+    cached_embeddings = {}  # idx -> tensor
+    miss_items = []  # (idx, item, start, end)
+    for idx, item, start, end in overlapping:
+        cached = embedding_cache.get_single(item.hash)
+        if cac

주요 변경점:

_move_items_to_device 함수 도입: 이 함수는 지정된 items 리스트의 각 MultimodalDataItem의 feature를 주어진 device로 비동기(non_blocking=True) 전송합니다. 이는 기존의 prepare_for_extend 함수에서 모든 이미지 특징을 미리 GPU로 옮기던 방식과 달리, 필요한 시점에 필요한 데이터만 옮기도록 하는 'Lazy Device Transfer'의 핵심입니다.
_get_chunked_embedding_full 함수: 이 함수는 기존 _get_chunked_prefill_embedding의 역할을 일부 계승하지만, 주로 모든 아이템을 한 번에 인코딩하고 캐싱하는 폴백(fallback) 시나리오를 다룹니다. EVS(Event-based Vision) 결과 처리 등 특정 상황에서 사용됩니다.
_get_chunked_embedding_by_item 함수: 이 함수가 이번 PR의 핵심 로직 중 하나입니다. 각 이미지를 개별적으로 처리하며, 현재 청크와 겹치는 이미지들만 선별하여 인코딩합니다. 또한, 각 이미지별로 캐싱을 시도하여 캐시 히트율을 높입니다.
```
# ... (중략) ...
# 2. Check per-image cache for each overlapping item
cached_embeddings = {}  # idx -> tensor
miss_items = []  # (idx, item, start, end)
for idx, item, start, end in overlapping:
    cached = embedding_cache.get_single(item.hash)
    if cac
```
위 코드에서 볼 수 있듯이, embedding_cache.get_single(item.hash)를 통해 각 이미지의 해시값으로 개별 캐시를 조회합니다. 캐시 미스(miss_items) 발생 시에만 해당 이미지를 GPU로 옮기고(_move_items_to_device), ViT 인코딩을 수행합니다.
기존 함수 제거: get_embedding_items_per_chunk_with_extra_padding과 같이 청크 경계 주변의 추가 패딩을 고려하던 함수들은 제거되었습니다. 이는 청크 인식 인코딩 로직이 더 정교해졌음을 시사합니다. 또한, _EXTRA_PRE_TOKENS, _EXTRA_POST_TOKENS와 같은 하드코딩된 패딩 관련 변수들도 사라졌습니다.
모델별 .to(device) 제거: PR 설명에 따르면, Qwen, Deepseek, Phi 등 여러 모델에서 수동으로 .to(device)를 호출하던 코드가 제거되었습니다. 이는 mm_utils.py의 _move_items_to_device와 같은 통합된 방식으로 처리되도록 변경되었음을 의미합니다. 이는 코드 중복을 줄이고 일관성을 높이는 좋은 개선입니다.

2. 제거된 코드

PR 설명에 따르면 약 240줄의 불필요한 코드가 제거되었습니다. 여기에는 사용되지 않는 청크 패딩 함수와 Qwen3_vl 모델의 내부 ViT 배치 로직 등이 포함됩니다. 코드 정리는 유지보수성을 높이고 잠재적인 버그를 줄이는 데 기여합니다.

왜 이게 좋은가?

이 PR의 변경 사항들은 VLM 추론의 여러 병목 지점을 효과적으로 해결하여 성능을 크게 향상시킵니다. 주요 이점은 다음과 같습니다:

향상된 캐시 재사용 및 메모리 효율성:
- Per-image cache: 기존에는 여러 이미지를 포함하는 요청의 경우, 단 하나의 이미지라도 캐시에서 누락되면 전체 이미지 세트에 대한 임베딩을 다시 계산해야 했습니다. 이는 combine_hashes(all_items)와 같은 방식으로 캐시 키를 관리했기 때문입니다. 이 PR에서는 각 이미지마다 고유한 해시를 사용하여 캐시를 관리합니다 (embedding_cache.get_single(item.hash)). 따라서, 여러 이미지가 포함된 요청에서 일부 이미지가 캐시에서 누락되더라도, 이전에 계산된 다른 이미지들의 임베딩은 재사용될 수 있습니다. 이는 특히 긴 비디오나 여러 이미지가 포함된 대화에서 반복적인 계산을 줄여줍니다.
- Chunk-aware ViT encoding: ViT 인코딩 시 현재 처리 중인 텍스트 청크와 겹치는 이미지 부분만 인코딩하도록 변경되었습니다. 이전에는 청크 1에서 모든 이미지를 인코딩해야 했지만, 이제는 해당 청크에 실제로 필요한 이미지 부분만 처리합니다. 이는 특히 여러 이미지가 포함된 요청에서 ViT 연산량과 피크 GPU 메모리 사용량을 크게 줄여줍니다. 리뷰어 yhyang201의 벤치마크 결과에 따르면, 2K 해상도에서 8개의 이미지를 처리할 때 ViT 인코딩 시간이 698ms에서 88ms로 약 87% 단축되었습니다.
지연 장치 전송 (Lazy Device Transfer):
- 기존에는 prepare_for_extend() 함수에서 모든 이미지 특징을 CPU에서 GPU로 미리 전송했습니다. 이 PR에서는 이 과정을 embedding pipeline으로 옮기고, 실제로 캐시 미스가 발생하여 인코딩이 필요한 아이템만 GPU로 전송하도록 변경했습니다. 이는 불필요한 데이터 전송을 줄여 GPU 활용률을 높이고 메모리 대역폭 사용을 최적화합니다.
성능 향상:
- TTFT (Time To First Token) 개선: 리뷰어 yhyang201이 제공한 벤치마크 결과는 이러한 최적화의 효과를 명확히 보여줍니다. 예를 들어, 1080p 해상도에서 8개의 이미지를 처리하는 멀티턴 시나리오에서 TTFT가 1555ms에서 1223ms로 약 21% 단축되었습니다. 특히 2K 해상도에서는 8개 이미지 처리 시 TTFT가 2993ms에서 2172ms로 약 27% 향상되었습니다.
- 최대 이미지 처리 개수 증가: probe 벤치마크 결과에 따르면, 1080p 해상도에서 처리 가능한 최대 이미지 수가 32개에서 64개로 두 배 증가했으며, 2K 해상도에서는 20개에서 51개로 155% 증가했습니다. 이는 메모리 사용량 감소 덕분에 더 많은 이미지를 효율적으로 처리할 수 있게 되었음을 의미합니다. 특히 2K 해상도에서 20개 이미지 처리 시 TTFT가 29275ms에서 15042ms로 거의 절반 가까이 단축되었습니다.
- OCRBench 정확도 유지 및 속도 향상: OCRBench 데이터셋을 사용한 정확도 테스트 결과, PR 브랜치는 기존 main 브랜치 대비 정확도 하락 없이 15% 더 빠르게 완료되었습니다. 이는 최적화가 정확성을 해치지 않으면서 성능을 개선했음을 보여줍니다.
코드 품질 향상:
- 불필요한 코드 제거 및 중복 로직 통합은 코드베이스를 더 깔끔하고 유지보수하기 쉽게 만듭니다.

일반적인 교훈

이 PR은 VLM 추론 최적화에 대한 몇 가지 중요한 교훈을 제공합니다:

캐시 전략의 중요성: 멀티모달 데이터의 경우, 요청 전체를 하나의 키로 캐싱하는 것보다 개별 구성 요소(예: 이미지)별로 캐싱하는 것이 훨씬 효과적일 수 있습니다. 이는 캐시 히트율을 높이고 불필요한 재계산을 방지합니다.
지연 연산(Lazy Evaluation)의 힘: 모든 데이터를 미리 처리하고 GPU로 옮기는 대신, 실제로 필요한 시점까지 연산을 지연시키는 것은 메모리 사용량과 계산량을 줄이는 데 매우 효과적입니다. 이는 특히 GPU 메모리가 제한적인 환경에서 중요합니다.
청크 기반 처리: 긴 시퀀스나 대량의 데이터를 처리할 때, 전체 데이터를 한 번에 처리하는 대신 작은 단위(청크)로 나누어 처리하고, 각 청크에 필요한 데이터만 효율적으로 관리하는 것이 성능 향상의 핵심입니다.
벤치마킹의 중요성: 실제 성능 향상을 입증하기 위해서는 다양한 시나리오(멀티턴, 다양한 해상도, 대량 이미지)에서의 상세한 벤치마킹이 필수적입니다. 리뷰어 yhyang201이 제공한 상세한 벤치마크 결과는 이 PR의 가치를 명확히 보여줍니다.

⚠️ 알림: 이 분석은 AI가 실제 코드 diff를 기반으로 작성했습니다.

PR Analysis 의 다른글

이전글 [sglang] SGLang에서 FA4(FlashAttention 4)와 Speculative Decoding의 완벽한 결합
현재글 : [sglang] [VLM] 멀티모달 임베딩 최적화: 청크 인식 인코딩과 이미지별 캐싱 도입
다음글 [sglang] SGLang Diffusion 모델의 NVFP4 추론 성능 최적화: CUTLASS 도입