xinference 0.16.3__py3-none-any.whl → 1.2.1__py3-none-any.whl

xinference/model/llm/vllm/xavier/test/test_xavier.py

@@ -0,0 +1,147 @@
+# Copyright 2022-2025 XProbe Inc.
+#
+# 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 os
+import sys
+
+import pytest
+import xoscar as xo
+
+from ..block_tracker import VLLMBlockTracker
+
+
+class ExtendedBlockTracker(VLLMBlockTracker):
+    def get_hash_to_rank_and_block_id(self):
+        return self._hash_to_rank_and_block_id
+
+    def get_rank_to_hash_and_block_id(self):
+        return self._rank_to_hash_and_block_id
+
+
+@pytest.fixture
+async def actor_pool_context():
+    start_method = (
+        os.environ.get("POOL_START_METHOD", "forkserver")
+        if sys.platform != "win32"
+        else None
+    )
+    pool = await xo.create_actor_pool(
+        "127.0.0.1", n_process=2, subprocess_start_method=start_method
+    )
+    async with pool:
+        yield pool
+
+
+@pytest.mark.asyncio
+async def test_block_tracker(actor_pool_context):
+    actor_pool = actor_pool_context
+    addr = actor_pool.external_address
+    tracker_ref: xo.ActorRefType[ExtendedBlockTracker] = await xo.create_actor(
+        ExtendedBlockTracker,
+        address=addr,
+        uid=VLLMBlockTracker.default_uid(),
+    )
+
+    virtual_engine = 0
+    rank = 0
+    block_infos = [(123, 0), (456, 1), (789, 2)]
+
+    # register blocks
+    await tracker_ref.register_blocks(virtual_engine, block_infos, rank)
+
+    # query blocks
+    res = await tracker_ref.query_blocks(virtual_engine, [(123, 4), (789, 5)])
+    assert len(res) == 1
+    assert rank in res
+    assert len(res[rank]) == 2
+    assert {x[0] for x in res[rank]} == {123, 789}
+    assert {x[1] for x in res[rank]} == {0, 2}
+    assert {x[2] for x in res[rank]} == {4, 5}
+
+    # query with extra info
+    res = await tracker_ref.query_blocks(virtual_engine, [(123, 4), (789, 5), (110, 6)])
+    assert len(res) == 1
+    assert rank in res
+    assert len(res[rank]) == 2
+    assert {x[0] for x in res[rank]} == {123, 789}
+    assert {x[1] for x in res[rank]} == {0, 2}
+    assert {x[2] for x in res[rank]} == {4, 5}
+
+    # unregister block
+    await tracker_ref.unregister_block(virtual_engine, rank, 1)
+    res = await tracker_ref.query_blocks(virtual_engine, [(123, 4), (456, 7)])
+    assert len(res) == 1
+    assert rank in res
+    assert len(res[rank]) == 1
+    assert {x[0] for x in res[rank]} == {123}
+    assert {x[1] for x in res[rank]} == {
+        0,
+    }
+    assert {x[2] for x in res[rank]} == {
+        4,
+    }
+    # nothing happens
+    await tracker_ref.unregister_block(virtual_engine, rank, 3)
+    res = await tracker_ref.query_blocks(virtual_engine, [(123, 4), (456, 7)])
+    assert len(res) == 1
+    assert rank in res
+    assert len(res[rank]) == 1
+    assert {x[0] for x in res[rank]} == {123}
+    assert {x[1] for x in res[rank]} == {
+        0,
+    }
+    assert {x[2] for x in res[rank]} == {
+        4,
+    }
+    # query returns empty
+    res = await tracker_ref.query_blocks(virtual_engine, [(456, 8)])
+    assert res == {}
+
+    # check internal data
+    hash_to_rank_and_block_id = await tracker_ref.get_hash_to_rank_and_block_id()
+    assert virtual_engine in hash_to_rank_and_block_id
+    assert hash_to_rank_and_block_id[virtual_engine] == {
+        123: {
+            (rank, 0),
+        },
+        456: set(),
+        789: {(rank, 2)},
+    }
+
+    rank_to_hash_and_block_id = await tracker_ref.get_rank_to_hash_and_block_id()
+    assert virtual_engine in rank_to_hash_and_block_id
+    assert rank_to_hash_and_block_id[virtual_engine] == {rank: {(123, 0), (789, 2)}}
+
+    # register blocks
+    new_rank = 1
+    block_infos = [(111, 7), (222, 8), (333, 9), (123, 10)]
+    await tracker_ref.register_blocks(virtual_engine, block_infos, new_rank)
+
+    # test unregister rank
+    await tracker_ref.unregister_rank(0)
+    res = await tracker_ref.query_blocks(virtual_engine, [(789, 5)])
+    assert len(res) == 0
+    res = await tracker_ref.query_blocks(virtual_engine, [(123, 6)])
+    assert len(res) == 1
+    assert new_rank in res
+
+    # check internal data
+    rank_to_hash_and_block_id = await tracker_ref.get_rank_to_hash_and_block_id()
+    assert rank in rank_to_hash_and_block_id[virtual_engine]
+    assert new_rank in rank_to_hash_and_block_id[virtual_engine]
+
+    # test register rank
+    await tracker_ref.register_rank(0)
+    rank_to_hash_and_block_id = await tracker_ref.get_rank_to_hash_and_block_id()
+    assert rank not in rank_to_hash_and_block_id[virtual_engine]
+    assert new_rank in rank_to_hash_and_block_id[virtual_engine]

xinference/model/llm/vllm/xavier/transfer.py

@@ -0,0 +1,319 @@
+# Copyright 2022-2025 XProbe Inc.
+#
+# 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 asyncio
+import logging
+from functools import lru_cache
+from queue import Queue
+from typing import Dict, List, Optional, no_type_check
+
+import torch
+import xoscar as xo
+from vllm.core.scheduler import Scheduler
+from vllm.utils import TORCH_DTYPE_TO_NUMPY_DTYPE, Device
+from vllm.worker.cache_engine import CacheEngine
+
+from .collective import CollectiveRank
+
+logger = logging.getLogger(__name__)
+
+
+class BufferTransferMixin:
+    def __init__(self):
+        self.num_buffer: int = 0
+        self.buffers: List[torch.Tensor] = []
+        self.buffer_queue: Optional[Queue] = None
+        self.transfer_block_num = 0
+        self.num_attn_layers = 0
+
+    def init_buffer(
+        self, num_buffer: int, buffer_shape, buffer_dtype, buffer_device, pin_memory
+    ):
+        # (transfer_block_num, num_attn_layers, 2, *kv_cache_shape[2:])
+
+        if buffer_dtype is torch.bfloat16:
+            buffer_dtype = torch.float16
+
+        self.num_buffer = num_buffer
+        self.transfer_block_num = buffer_shape[0]
+        self.num_attn_layers = buffer_shape[1]
+
+        self.buffers = [
+            torch.zeros(
+                size=buffer_shape,
+                dtype=buffer_dtype,
+                device=buffer_device,
+                pin_memory=pin_memory,
+            )
+            for _ in range(self.num_buffer)
+        ]
+
+        self.buffer_queue = Queue()
+        for i in range(self.num_buffer):
+            self.buffer_queue.put_nowait(i)
+        logger.debug(
+            f"Init buffer done. "
+            f"transfer_block_num: {self.transfer_block_num}, "
+            f"num_buffer: {self.num_buffer}, "
+            f"buffer_dtype: {buffer_dtype}, "
+            f"buffer_shape: {buffer_shape}"
+        )
+
+    @no_type_check
+    def get_buffer_index(self) -> int:
+        return self.buffer_queue.get()
+
+    @no_type_check
+    def free_buffer_index(self, index: int) -> None:
+        self.buffer_queue.put_nowait(index)
+
+    def get_swap_buffer(self, index: int, num_blocks: int) -> torch.Tensor:
+        buf = self.buffers[index]
+        buffer = buf[:num_blocks].view(
+            self.num_attn_layers, 2, num_blocks, *buf.shape[3:]
+        )
+        return buffer
+
+    @lru_cache(maxsize=None)
+    def get_gloo_dtype(self, input_dtype: torch.dtype):
+        from xoscar.collective.common import TypeMappingGloo
+
+        return TypeMappingGloo[TORCH_DTYPE_TO_NUMPY_DTYPE[input_dtype]]
+
+
+class TransferActor(xo.StatelessActor, BufferTransferMixin, CollectiveRank):
+    @classmethod
+    def default_uid(cls):
+        return f"vllm-transfer-actor"
+
+    def __init__(
+        self,
+        rank: int,
+        world_size: int,
+        rank_address: str,
+        store_address: str,
+        store_port: int,
+        world_addresses: List[str],
+    ):
+        super().__init__()
+        CollectiveRank.__init__(
+            self,
+            rank,
+            world_size,
+            rank_address,
+            store_address,
+            store_port,
+            world_addresses,
+        )
+        self._cache_engine: Optional[List[CacheEngine]] = None
+        self._scheduler: Optional[List[Scheduler]] = None
+        self._swap_stream = torch.cuda.Stream()
+
+    async def __post_create__(self):
+        self.init_rank()
+
+    def setup(
+        self,
+        cache_engine: List[CacheEngine],
+        scheduler: List[Scheduler],
+        num_buffer: int,
+        buffer_shape,
+        buffer_dtype,
+        buffer_device,
+        pin_memory: bool,
+    ):
+        self._cache_engine = cache_engine
+        self._scheduler = scheduler
+        self.init_buffer(
+            num_buffer, buffer_shape, buffer_dtype, buffer_device, pin_memory
+        )
+
+    async def __pre_destroy__(self):
+        self._context.closeConnections()
+
+    def _get_cache_engine(self, virtual_engine: int) -> CacheEngine:
+        return self._cache_engine[virtual_engine]  # type: ignore
+
+    @staticmethod
+    def _get_swap_block_ids(src_to_dst: Dict[int, int], is_sender: bool) -> List[int]:
+        return list(sorted([r if is_sender else l for r, l in src_to_dst.items()]))
+
+    def _swap_out_to_buffer(
+        self, cache_engine: CacheEngine, cpu_buf_index: int, block_ids: List[int]
+    ) -> torch.Tensor:
+        num_blocks = len(block_ids)
+        src_to_dst = torch.tensor(
+            [(block_num, idx) for idx, block_num in enumerate(block_ids)],
+            device="cpu",
+            dtype=torch.int64,
+        ).view(-1, 2)
+        cpu_buf = self.get_swap_buffer(cpu_buf_index, num_blocks)
+        with torch.cuda.stream(self._swap_stream):
+            for i in range(self.num_attn_layers):
+                cache_engine.attn_backend.swap_blocks(
+                    cache_engine.gpu_cache[i], cpu_buf[i], src_to_dst
+                )
+        torch.cuda.Stream.synchronize(self._swap_stream)
+        return cpu_buf
+
+    def _swap_in_from_buffer(
+        self, cache_engine: CacheEngine, cpu_buf: torch.Tensor, block_ids: List[int]
+    ) -> None:
+        src_to_dst = torch.tensor(
+            [(idx, block_num) for idx, block_num in enumerate(block_ids)],
+            device="cpu",
+            dtype=torch.int64,
+        ).view(-1, 2)
+        with torch.cuda.stream(self._swap_stream):
+            for i in range(self.num_attn_layers):
+                cache_engine.attn_backend.swap_blocks(
+                    cpu_buf[i], cache_engine.gpu_cache[i], src_to_dst
+                )
+        torch.cuda.Stream.synchronize(self._swap_stream)
+
+    def _incr_count_for_block_id(self, virtual_engine: int, block_ids: List[int]):
+        """
+        The reference count of the `block_id` involved in the transfer is incremented by 1
+        to ensure it is not reclaimed.
+        """
+        scheduler = self._scheduler[virtual_engine]  # type: ignore
+        gpu_allocator = scheduler.block_manager.block_allocator._allocators[Device.GPU]
+
+        for _id in block_ids:
+            gpu_allocator._refcounter.incr(_id)
+
+    def _decr_count_for_block_id(self, virtual_engine: int, block_ids: List[int]):
+        """
+        After the transfer, the reference count is decremented by 1.
+        """
+        scheduler = self._scheduler[virtual_engine]  # type: ignore
+        gpu_allocator = scheduler.block_manager.block_allocator._allocators[Device.GPU]
+
+        for _id in block_ids:
+            gpu_allocator._refcounter.decr(_id)
+
+    async def do_send(
+        self, virtual_engine: int, to_rank: int, src_to_dst: Dict[int, int]
+    ):
+        """
+        Sending logic: GPU -> Buffer -> Gloo send.
+        GPU -> Buffer is directly handled using the internal `swap_out` interface of vllm.
+        """
+        from xoscar.collective import xoscar_pygloo as xp
+
+        cache_engine = self._get_cache_engine(virtual_engine)
+
+        block_ids = self._get_swap_block_ids(src_to_dst, is_sender=True)
+        self._incr_count_for_block_id(virtual_engine, block_ids)
+        cpu_buf_index = self.get_buffer_index()
+        total_blocks: int = len(block_ids)
+
+        try:
+            for start_idx in range(0, total_blocks, self.transfer_block_num):
+                offset = min(self.transfer_block_num, total_blocks - start_idx)
+                send_block_ids = block_ids[start_idx : start_idx + offset]
+                sendbuf = self._swap_out_to_buffer(
+                    cache_engine, cpu_buf_index, send_block_ids
+                )
+                assert sendbuf.is_contiguous()
+                sendptr = sendbuf.numpy().ctypes.data
+                data_size = sendbuf.numel()
+                datatype = self.get_gloo_dtype(sendbuf.dtype)
+                peer = to_rank
+                xp.send(self._context, sendptr, data_size, datatype, peer)
+        finally:
+            self._decr_count_for_block_id(virtual_engine, block_ids)
+            self.free_buffer_index(cpu_buf_index)
+
+    async def do_recv(
+        self, virtual_engine: int, from_rank: int, src_to_dst: Dict[int, int]
+    ):
+        """
+        Receiving logic: Gloo recv -> Buffer -> GPU.
+        Buffer -> GPU is directly handled using the internal `swap_in` interface of vllm.
+        """
+        from xoscar.collective import xoscar_pygloo as xp
+
+        cache_engine = self._get_cache_engine(virtual_engine)
+
+        block_ids = self._get_swap_block_ids(src_to_dst, is_sender=False)
+        self._incr_count_for_block_id(virtual_engine, block_ids)
+        total_blocks = len(block_ids)
+        cpu_buf_index = self.get_buffer_index()
+
+        try:
+            for start_idx in range(0, total_blocks, self.transfer_block_num):
+                offset = min(self.transfer_block_num, total_blocks - start_idx)
+                recv_block_ids = block_ids[start_idx : start_idx + offset]
+                recvbuf = self.get_swap_buffer(cpu_buf_index, len(recv_block_ids))
+                assert recvbuf.is_contiguous()
+                recvptr = recvbuf.numpy().ctypes.data
+                data_size = recvbuf.numel()
+                datatype = self.get_gloo_dtype(recvbuf.dtype)
+                peer = from_rank
+                xp.recv(self._context, recvptr, data_size, datatype, peer)
+
+                self._swap_in_from_buffer(cache_engine, recvbuf, recv_block_ids)
+        finally:
+            self._decr_count_for_block_id(virtual_engine, block_ids)
+            self.free_buffer_index(cpu_buf_index)
+
+    async def recv(
+        self, virtual_engine: int, from_rank: int, src_to_dst: Dict[int, int]
+    ):
+        """
+        This is the external entry point for the call.
+        The transfer logic is as follows:
+        the receiver requests the sender to send the data directly to itself in a point-to-point manner.
+        """
+        from_address = self._world_addresses[from_rank]
+        sender_ref = await xo.actor_ref(
+            address=from_address, uid=f"{TransferActor.default_uid()}-{from_rank}"
+        )
+        await asyncio.gather(
+            sender_ref.do_send(virtual_engine, self._rank, src_to_dst),
+            self.do_recv(virtual_engine, from_rank, src_to_dst),
+        )
+
+
+class Rank0TransferActor(xo.StatelessActor, CollectiveRank):
+    """
+    The Rank 0 transfer actor is only used for constructing the collective communication world,
+    so it only needs to inherit the `CollectiveWorld` class.
+    """
+
+    @classmethod
+    def default_uid(cls):
+        return f"vllm-transfer-actor"
+
+    def __init__(
+        self,
+        rank: int,
+        world_size: int,
+        rank_address: str,
+        store_address: str,
+        store_port: int,
+        world_addresses: List[str],
+    ):
+        CollectiveRank.__init__(
+            self,
+            rank,
+            world_size,
+            rank_address,
+            store_address,
+            store_port,
+            world_addresses,
+        )
+
+    async def __post_create__(self):
+        self.init_rank()

xinference/model/rerank/core.py

@@ -179,6 +179,7 @@ class RerankModel:
         return rerank_type
 
     def load(self):
+        logger.info("Loading rerank model: %s", self._model_path)
         flash_attn_installed = importlib.util.find_spec("flash_attn") is not None
         if (
             self._auto_detect_type(self._model_path) != "normal"
@@ -189,6 +190,7 @@ class RerankModel:
                 "will force set `use_fp16` to True"
             )
             self._use_fp16 = True
+
         if self._model_spec.type == "normal":
             try:
                 import sentence_transformers
@@ -250,22 +252,27 @@ class RerankModel:
         **kwargs,
     ) -> Rerank:
         assert self._model is not None
-        if kwargs:
-            raise ValueError("rerank hasn't support extra parameter.")
         if max_chunks_per_doc is not None:
             raise ValueError("rerank hasn't support `max_chunks_per_doc` parameter.")
+        logger.info("Rerank with kwargs: %s, model: %s", kwargs, self._model)
         sentence_combinations = [[query, doc] for doc in documents]
         # reset n tokens
         self._model.model.n_tokens = 0
         if self._model_spec.type == "normal":
             similarity_scores = self._model.predict(
-                sentence_combinations, convert_to_numpy=False, convert_to_tensor=True
+                sentence_combinations,
+                convert_to_numpy=False,
+                convert_to_tensor=True,
+                **kwargs,
             ).cpu()
             if similarity_scores.dtype == torch.bfloat16:
                 similarity_scores = similarity_scores.float()
         else:
             # Related issue: https://github.com/xorbitsai/inference/issues/1775
-            similarity_scores = self._model.compute_score(sentence_combinations)
+            similarity_scores = self._model.compute_score(
+                sentence_combinations, **kwargs
+            )
+
             if not isinstance(similarity_scores, Sequence):
                 similarity_scores = [similarity_scores]
             elif (

xinference/model/video/diffusers.py

@@ -91,6 +91,20 @@ class DiffUsersVideoModel:
             pipeline = self._model = CogVideoXPipeline.from_pretrained(
                 self._model_path, **kwargs
             )
+        elif self._model_spec.model_family == "HunyuanVideo":
+            from diffusers import HunyuanVideoPipeline, HunyuanVideoTransformer3DModel
+
+            transformer_torch_dtype = kwargs.pop("transformer_torch_dtype")
+            if isinstance(transformer_torch_dtype, str):
+                transformer_torch_dtype = getattr(torch, transformer_torch_dtype)
+            transformer = HunyuanVideoTransformer3DModel.from_pretrained(
+                self._model_path,
+                subfolder="transformer",
+                torch_dtype=transformer_torch_dtype,
+            )
+            pipeline = self._model = HunyuanVideoPipeline.from_pretrained(
+                self._model_path, transformer=transformer, **kwargs
+            )
         else:
             raise Exception(
                 f"Unsupported model family: {self._model_spec.model_family}"

xinference/model/video/model_spec.json

@@ -30,5 +30,20 @@
     "default_generate_config": {
       "guidance_scale": 7
     }
+  },
+  {
+    "model_name": "HunyuanVideo",
+    "model_family": "HunyuanVideo",
+    "model_id": "hunyuanvideo-community/HunyuanVideo",
+    "model_revision": "e8c2aaa66fe3742a32c11a6766aecbf07c56e773",
+    "model_ability": [
+      "text2video"
+    ],
+    "default_model_config": {
+      "transformer_torch_dtype": "bfloat16",
+      "torch_dtype": "float16"
+    },
+    "default_generate_config": {
+    }
   }
 ]

xinference/model/video/model_spec_modelscope.json

@@ -32,5 +32,21 @@
     "default_generate_config": {
       "guidance_scale": 7
     }
+  },
+  {
+    "model_name": "HunyuanVideo",
+    "model_family": "HunyuanVideo",
+    "model_hub": "modelscope",
+    "model_id": "Xorbits/HunyuanVideo",
+    "model_revision": "master",
+    "model_ability": [
+      "text2video"
+    ],
+    "default_model_config": {
+      "transformer_torch_dtype": "bfloat16",
+      "torch_dtype": "float16"
+    },
+    "default_generate_config": {
+    }
   }
 ]

xinference/thirdparty/cosyvoice/bin/average_model.py

@@ -0,0 +1,92 @@
+# Copyright (c) 2020 Mobvoi Inc (Di Wu)
+# Copyright (c) 2024 Alibaba Inc (authors: Xiang Lyu)
+#
+# 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 os
+import argparse
+import glob
+
+import yaml
+import torch
+
+
+def get_args():
+    parser = argparse.ArgumentParser(description='average model')
+    parser.add_argument('--dst_model', required=True, help='averaged model')
+    parser.add_argument('--src_path',
+                        required=True,
+                        help='src model path for average')
+    parser.add_argument('--val_best',
+                        action="store_true",
+                        help='averaged model')
+    parser.add_argument('--num',
+                        default=5,
+                        type=int,
+                        help='nums for averaged model')
+
+    args = parser.parse_args()
+    print(args)
+    return args
+
+
+def main():
+    args = get_args()
+    val_scores = []
+    if args.val_best:
+        yamls = glob.glob('{}/*.yaml'.format(args.src_path))
+        yamls = [
+            f for f in yamls
+            if not (os.path.basename(f).startswith('train')
+                    or os.path.basename(f).startswith('init'))
+        ]
+        for y in yamls:
+            with open(y, 'r') as f:
+                dic_yaml = yaml.load(f, Loader=yaml.BaseLoader)
+                loss = float(dic_yaml['loss_dict']['loss'])
+                epoch = int(dic_yaml['epoch'])
+                step = int(dic_yaml['step'])
+                tag = dic_yaml['tag']
+                val_scores += [[epoch, step, loss, tag]]
+        sorted_val_scores = sorted(val_scores,
+                                   key=lambda x: x[2],
+                                   reverse=False)
+        print("best val (epoch, step, loss, tag) = " +
+              str(sorted_val_scores[:args.num]))
+        path_list = [
+            args.src_path + '/epoch_{}_whole.pt'.format(score[0])
+            for score in sorted_val_scores[:args.num]
+        ]
+    print(path_list)
+    avg = {}
+    num = args.num
+    assert num == len(path_list)
+    for path in path_list:
+        print('Processing {}'.format(path))
+        states = torch.load(path, map_location=torch.device('cpu'))
+        for k in states.keys():
+            if k not in avg.keys():
+                avg[k] = states[k].clone()
+            else:
+                avg[k] += states[k]
+    # average
+    for k in avg.keys():
+        if avg[k] is not None:
+            # pytorch 1.6 use true_divide instead of /=
+            avg[k] = torch.true_divide(avg[k], num)
+    print('Saving to {}'.format(args.dst_model))
+    torch.save(avg, args.dst_model)
+
+
+if __name__ == '__main__':
+    main()