mirror of
https://github.com/PaddlePaddle/FastDeploy.git
synced 2026-04-23 00:17:25 +08:00
kevin
299 lines
11 KiB
Python
299 lines
11 KiB
Python
"""
|
|
# Copyright (c) 2025 PaddlePaddle Authors. All Rights Reserved.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
"""
|
|
|
|
import concurrent.futures
|
|
import pickle
|
|
import unittest
|
|
from dataclasses import asdict
|
|
from types import SimpleNamespace
|
|
from unittest.mock import MagicMock, patch
|
|
|
|
import numpy as np
|
|
|
|
from fastdeploy.config import CacheConfig, FDConfig, ParallelConfig, SchedulerConfig
|
|
from fastdeploy.engine.args_utils import EngineArgs
|
|
from fastdeploy.engine.request import ImagePosition, Request
|
|
from fastdeploy.engine.sched.resource_manager_v1 import ResourceManagerV1
|
|
|
|
|
|
class TestResourceManagerV1(unittest.TestCase):
|
|
def setUp(self):
|
|
max_num_seqs = 2
|
|
engine_args = EngineArgs(
|
|
max_num_seqs=max_num_seqs,
|
|
num_gpu_blocks_override=102,
|
|
max_num_batched_tokens=3200,
|
|
)
|
|
args = asdict(engine_args)
|
|
|
|
cache_cfg = CacheConfig(args)
|
|
model_cfg = SimpleNamespace(enable_mm=True) # Enable multimodal for feature testing
|
|
speculative_cfg = SimpleNamespace(method=None)
|
|
model_cfg.print = print
|
|
model_cfg.max_model_len = 5120
|
|
model_cfg.architectures = ["test_model"]
|
|
cache_cfg.bytes_per_layer_per_block = 1
|
|
parallel_cfg = ParallelConfig(args)
|
|
scheduler_cfg = SchedulerConfig(args)
|
|
graph_opt_cfg = engine_args.create_graph_optimization_config()
|
|
|
|
fd_config = FDConfig(
|
|
model_config=model_cfg,
|
|
cache_config=cache_cfg,
|
|
parallel_config=parallel_cfg,
|
|
graph_opt_config=graph_opt_cfg,
|
|
speculative_config=speculative_cfg,
|
|
scheduler_config=scheduler_cfg,
|
|
)
|
|
self.manager = ResourceManagerV1(
|
|
max_num_seqs=max_num_seqs, config=fd_config, tensor_parallel_size=8, splitwise_role="mixed"
|
|
)
|
|
req_dict = {
|
|
"request_id": "test_request",
|
|
"multimodal_inputs": {},
|
|
}
|
|
self.request = Request.from_dict(req_dict)
|
|
self.request.async_process_futures = []
|
|
self.request.multimodal_inputs = {}
|
|
|
|
def test_waiting_async_process_no_futures(self):
|
|
"""Test when there are no async process futures"""
|
|
result = self.manager.waiting_async_process(self.request)
|
|
self.assertFalse(result)
|
|
|
|
def test_waiting_async_process_future_done_no_error(self):
|
|
"""Test when future is done with no error"""
|
|
future = concurrent.futures.Future()
|
|
future.set_result(True)
|
|
self.request.async_process_futures = [future]
|
|
|
|
result = self.manager.waiting_async_process(self.request)
|
|
self.assertFalse(result)
|
|
self.assertEqual(len(self.request.async_process_futures), 0)
|
|
|
|
def test_waiting_async_process_future_done_with_error(self):
|
|
"""Test when future is done with error"""
|
|
future = concurrent.futures.Future()
|
|
future.set_result(True)
|
|
self.request.async_process_futures = [future]
|
|
self.request.error_message = "Download failed"
|
|
|
|
result = self.manager.waiting_async_process(self.request)
|
|
self.assertIsNone(result)
|
|
|
|
def test_waiting_async_process_future_not_done(self):
|
|
"""Test when future is not done"""
|
|
future = concurrent.futures.Future()
|
|
self.request.async_process_futures = [future]
|
|
|
|
result = self.manager.waiting_async_process(self.request)
|
|
self.assertTrue(result)
|
|
self.assertEqual(len(self.request.async_process_futures), 1)
|
|
|
|
def test_apply_async_preprocess(self):
|
|
"""Test applying async preprocess"""
|
|
with patch.object(self.manager.async_preprocess_pool, "submit") as mock_submit:
|
|
mock_submit.return_value = "mock_future"
|
|
self.manager.apply_async_preprocess(self.request)
|
|
|
|
mock_submit.assert_called_once_with(self.manager._download_features, self.request)
|
|
self.assertEqual(len(self.request.async_process_futures), 1)
|
|
self.assertEqual(self.request.async_process_futures[0], "mock_future")
|
|
|
|
@patch("fastdeploy.utils.init_bos_client")
|
|
@patch("fastdeploy.utils.download_from_bos")
|
|
def test_download_features_no_features(self, mock_download, mock_init):
|
|
"""Test when no features to download"""
|
|
self.request.multimodal_inputs = {}
|
|
result = self.manager._download_features(self.request)
|
|
self.assertIsNone(result)
|
|
mock_download.assert_not_called()
|
|
mock_init.assert_not_called()
|
|
|
|
def test_download_features_video_success(self):
|
|
"""Test successful video feature download"""
|
|
mock_client = MagicMock()
|
|
mock_client.get_object_as_string.return_value = pickle.dumps(np.array([[1, 2, 3]], dtype=np.float32))
|
|
|
|
self.request.multimodal_inputs = {"video_feature_urls": ["bos://bucket-name/path/to/object1"]}
|
|
|
|
self.manager.bos_client = mock_client
|
|
result = self.manager._download_features(self.request)
|
|
self.assertIsNone(result)
|
|
self.assertIn("video_features", self.request.multimodal_inputs)
|
|
self.assertIsInstance(self.request.multimodal_inputs["video_features"][0], np.ndarray)
|
|
|
|
def test_download_features_image_error(self):
|
|
"""Test image feature download with error"""
|
|
mock_client = MagicMock()
|
|
mock_client.get_object_as_string.side_effect = Exception("network error")
|
|
|
|
self.request.multimodal_inputs = {"image_feature_urls": ["bos://bucket-name/path/to/object1"]}
|
|
|
|
self.manager.bos_client = mock_client
|
|
result = self.manager._download_features(self.request)
|
|
self.assertIsNone(result)
|
|
self.assertIn(
|
|
"request test_request download features error",
|
|
self.request.error_message,
|
|
)
|
|
self.assertEqual(self.request.error_code, 530)
|
|
|
|
def test_download_features_audio_mixed(self):
|
|
"""Test mixed success/error in audio feature download"""
|
|
mock_client = MagicMock()
|
|
mock_client.get_object_as_string.side_effect = [
|
|
pickle.dumps(np.array([[1, 2, 3]], dtype=np.float32)),
|
|
Exception("timeout"),
|
|
]
|
|
|
|
self.request.multimodal_inputs = {
|
|
"audio_feature_urls": ["bos://bucket-name/path/to/object1", "bos://bucket-name/path/to/object2"]
|
|
}
|
|
|
|
self.manager.bos_client = mock_client
|
|
result = self.manager._download_features(self.request)
|
|
self.assertIsNone(result)
|
|
self.assertIn(
|
|
"request test_request download features error",
|
|
self.request.error_message,
|
|
)
|
|
self.assertEqual(self.request.error_code, 530)
|
|
|
|
def test_download_features_retry(self):
|
|
"""Test image feature download with error"""
|
|
mock_client = MagicMock()
|
|
mock_client.get_object_as_string.side_effect = Exception(
|
|
"Your request rate is too high. We have put limits on your bucket."
|
|
)
|
|
|
|
self.request.multimodal_inputs = {"image_feature_urls": ["bos://bucket-name/path/to/object1"]}
|
|
|
|
self.manager.bos_client = mock_client
|
|
result = self.manager._download_features(self.request)
|
|
self.assertIsNone(result)
|
|
self.assertIn("Failed after 1 retries for bos://bucket-name/path/to/object1", self.request.error_message)
|
|
self.assertEqual(self.request.error_code, 530)
|
|
|
|
|
|
class TestRevertChunkedMMInput(unittest.TestCase):
|
|
def setUp(self):
|
|
max_num_seqs = 2
|
|
engine_args = EngineArgs(
|
|
max_num_seqs=max_num_seqs,
|
|
num_gpu_blocks_override=102,
|
|
max_num_batched_tokens=3200,
|
|
)
|
|
args = asdict(engine_args)
|
|
|
|
cache_cfg = CacheConfig(args)
|
|
model_cfg = SimpleNamespace(enable_mm=True) # Enable multimodal for feature testing
|
|
speculative_cfg = SimpleNamespace(method=None)
|
|
model_cfg.print = print
|
|
model_cfg.max_model_len = 5120
|
|
model_cfg.architectures = ["test_model"]
|
|
cache_cfg.bytes_per_layer_per_block = 1
|
|
cache_cfg.block_size = 64
|
|
parallel_cfg = ParallelConfig(args)
|
|
scheduler_cfg = SchedulerConfig(args)
|
|
graph_opt_cfg = engine_args.create_graph_optimization_config()
|
|
|
|
fd_config = FDConfig(
|
|
model_config=model_cfg,
|
|
cache_config=cache_cfg,
|
|
parallel_config=parallel_cfg,
|
|
graph_opt_config=graph_opt_cfg,
|
|
speculative_config=speculative_cfg,
|
|
scheduler_config=scheduler_cfg,
|
|
)
|
|
self.manager = ResourceManagerV1(
|
|
max_num_seqs=max_num_seqs, config=fd_config, tensor_parallel_size=8, splitwise_role="mixed"
|
|
)
|
|
req_dict = {
|
|
"request_id": "test_request",
|
|
"multimodal_inputs": {},
|
|
}
|
|
self.request = Request.from_dict(req_dict)
|
|
self.request.async_process_futures = []
|
|
self.request.multimodal_inputs = {}
|
|
|
|
def test_revert_chunked_mm_input_none_input(self):
|
|
result = self.manager.revert_chunked_mm_input(None, 64)
|
|
self.assertEqual(result, 64)
|
|
|
|
def test_revert_chunked_mm_input_no_mm_positions(self):
|
|
mm_inputs = {"other_field": "value"}
|
|
result = self.manager.revert_chunked_mm_input(mm_inputs, 128)
|
|
self.assertEqual(result, 128)
|
|
|
|
def test_revert_chunked_mm_input_empty_positions(self):
|
|
mm_inputs = {"mm_positions": []}
|
|
result = self.manager.revert_chunked_mm_input(mm_inputs, 128)
|
|
self.assertEqual(result, 128)
|
|
|
|
def test_revert_chunked_mm_input_matched_in_chunk(self):
|
|
mm_inputs = {
|
|
"mm_positions": [
|
|
ImagePosition(offset=40, length=100),
|
|
ImagePosition(offset=200, length=80),
|
|
]
|
|
}
|
|
result = self.manager.revert_chunked_mm_input(mm_inputs, 256)
|
|
self.assertEqual(result, 192)
|
|
|
|
def test_revert_chunked_mm_input_matched_in_second_chunk(self):
|
|
mm_inputs = {
|
|
"mm_positions": [
|
|
ImagePosition(offset=100, length=100),
|
|
ImagePosition(offset=200, length=80),
|
|
]
|
|
}
|
|
result = self.manager.revert_chunked_mm_input(mm_inputs, 256)
|
|
self.assertEqual(result, 64)
|
|
|
|
def test_revert_chunked_mm_input_before_first_chunk(self):
|
|
mm_inputs = {
|
|
"mm_positions": [
|
|
ImagePosition(offset=60, length=100),
|
|
ImagePosition(offset=180, length=100),
|
|
]
|
|
}
|
|
result = self.manager.revert_chunked_mm_input(mm_inputs, 256)
|
|
self.assertEqual(result, 0)
|
|
|
|
def test_revert_chunked_mm_input_after_last_chunk(self):
|
|
mm_inputs = {
|
|
"mm_positions": [
|
|
ImagePosition(offset=5, length=10),
|
|
ImagePosition(offset=200, length=56),
|
|
]
|
|
}
|
|
result = self.manager.revert_chunked_mm_input(mm_inputs, 256)
|
|
self.assertEqual(result, 256)
|
|
|
|
def test_revert_chunked_mm_input_match_image_offset(self):
|
|
mm_inputs = {
|
|
"mm_positions": [
|
|
ImagePosition(offset=64, length=21),
|
|
]
|
|
}
|
|
result = self.manager.revert_chunked_mm_input(mm_inputs, 64)
|
|
self.assertEqual(result, 64)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|