From d5e7756028bd5884ade96b654555c375770a2f64 Mon Sep 17 00:00:00 2001 From: Yikun Jiang Date: Wed, 5 Feb 2025 10:53:12 +0800 Subject: [PATCH] [Core] Init vllm-ascend (#3) ### What this PR does / why we need it? vLLM Ascend plugin (vllm-ascend) is a backend plugin for running vLLM on the Ascend NPU. This plugin is the recommended approach for supporting the Ascend backend within the vLLM community. It adheres to the principles outlined in the [RFC]: Hardware pluggable, providing a hardware-pluggable interface that decouples the integration of the Ascend NPU with vLLM. This patch also include changes to make CI work and use cache speed up e2e test, including: 1. Change push (post merge ci) and pull_request (pr ci) trigger branch to main 2. Make mypy work by ignore base_communicator and clear unused deps 3. Several improvements for vllm_ascend_test: - use cache (pip, ms, hf) speed up e2e test (25mins --> 5mins) - switch `git clone` command to `action/checkout` to speedup checkout and - Enable sv for pytest for better info dump - Remove network host to resole `docker: conflicting ontions: cannot attach both user-defined and non-user-definednetwork-modes`, which is a problem on docker 1.45 but not on 1.39. 4. Adapt MLA decode optimizations: https://github.com/vllm-project/vllm/commit/cabaf4eff3c7df30d785769d5a0a1fa1a1c48a8a ### Does this PR introduce _any_ user-facing change? Yes, init the PR. ### How was this patch tested? - This is the first PR to make ascend NPU work on vLLM. All code is tested on ascend with vLLM V0 Engine. - CI passed --------- Signed-off-by: wangxiyuan Signed-off-by: Yikun Jiang Co-authored-by: wangxiyuan Co-authored-by: MengqingCao Co-authored-by: wangshuai09 <391746016@qq.com> Co-authored-by: Shanshan Shen <467638484@qq.com> Co-authored-by: wangli --- .github/PULL_REQUEST_TEMPLATE.md | 28 + .github/workflows/actionlint.yml | 57 ++ .github/workflows/matchers/actionlint.json | 17 + .github/workflows/matchers/mypy.json | 16 + .github/workflows/matchers/ruff.json | 17 + .github/workflows/mypy.yaml | 74 ++ .github/workflows/ruff.yml | 57 ++ .github/workflows/shellcheck.yml | 54 ++ .github/workflows/vllm_ascend_test.yaml | 106 +++ .github/workflows/yapf.yml | 54 ++ .gitignore | 194 +++++ CODE_OF_CONDUCT.md | 128 ++++ CONTRIBUTING.md | 107 +++ DCO | 34 + Dockerfile | 40 ++ README.md | 102 +++ docs/environment.md | 38 + docs/logos/vllm-ascend-logo-text-dark.png | Bin 0 -> 156286 bytes docs/logos/vllm-ascend-logo-text-light.png | Bin 0 -> 156625 bytes examples/offline_distributed_inference_npu.py | 45 ++ examples/offline_inference_audio_language.py | 153 ++++ examples/offline_inference_npu.py | 39 + format.sh | 341 +++++++++ mypy.ini | 14 + packages.txt | 3 + requirements-dev.txt | 3 + requirements-lint.txt | 15 + requirements.txt | 5 + setup.py | 95 +++ tests/conftest.py | 331 +++++++++ tests/model_utils.py | 303 ++++++++ tests/test_offline_inference.py | 61 ++ tools/actionlint.sh | 33 + tools/check_repo.sh | 34 + tools/mypy.sh | 40 ++ tools/npu-vllm-test.sh | 422 +++++++++++ tools/png-lint.sh | 34 + tools/shellcheck.sh | 44 ++ tools/sphinx-lint.sh | 22 + vllm_ascend/__init__.py | 21 + vllm_ascend/attention.py | 678 ++++++++++++++++++ vllm_ascend/communicator.py | 28 + vllm_ascend/model_runner.py | 620 ++++++++++++++++ vllm_ascend/ops/__init__.py | 18 + vllm_ascend/ops/layernorm.py | 40 ++ vllm_ascend/platform.py | 115 +++ vllm_ascend/worker.py | 481 +++++++++++++ 47 files changed, 5161 insertions(+) create mode 100644 .github/PULL_REQUEST_TEMPLATE.md create mode 100644 .github/workflows/actionlint.yml create mode 100644 .github/workflows/matchers/actionlint.json create mode 100644 .github/workflows/matchers/mypy.json create mode 100644 .github/workflows/matchers/ruff.json create mode 100644 .github/workflows/mypy.yaml create mode 100644 .github/workflows/ruff.yml create mode 100644 .github/workflows/shellcheck.yml create mode 100644 .github/workflows/vllm_ascend_test.yaml create mode 100644 .github/workflows/yapf.yml create mode 100644 .gitignore create mode 100644 CODE_OF_CONDUCT.md create mode 100644 CONTRIBUTING.md create mode 100644 DCO create mode 100644 Dockerfile create mode 100644 README.md create mode 100644 docs/environment.md create mode 100644 docs/logos/vllm-ascend-logo-text-dark.png create mode 100644 docs/logos/vllm-ascend-logo-text-light.png create mode 100644 examples/offline_distributed_inference_npu.py create mode 100644 examples/offline_inference_audio_language.py create mode 100644 examples/offline_inference_npu.py create mode 100755 format.sh create mode 100644 mypy.ini create mode 100644 packages.txt create mode 100644 requirements-dev.txt create mode 100644 requirements-lint.txt create mode 100644 requirements.txt create mode 100644 setup.py create mode 100644 tests/conftest.py create mode 100644 tests/model_utils.py create mode 100644 tests/test_offline_inference.py create mode 100755 tools/actionlint.sh create mode 100644 tools/check_repo.sh create mode 100755 tools/mypy.sh create mode 100644 tools/npu-vllm-test.sh create mode 100755 tools/png-lint.sh create mode 100755 tools/shellcheck.sh create mode 100755 tools/sphinx-lint.sh create mode 100644 vllm_ascend/__init__.py create mode 100644 vllm_ascend/attention.py create mode 100644 vllm_ascend/communicator.py create mode 100644 vllm_ascend/model_runner.py create mode 100644 vllm_ascend/ops/__init__.py create mode 100644 vllm_ascend/ops/layernorm.py create mode 100644 vllm_ascend/platform.py create mode 100644 vllm_ascend/worker.py diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md new file mode 100644 index 000000000..38c0b58e8 --- /dev/null +++ b/.github/PULL_REQUEST_TEMPLATE.md @@ -0,0 +1,28 @@ + +### What this PR does / why we need it? + + +### Does this PR introduce _any_ user-facing change? + + +### How was this patch tested? + + diff --git a/.github/workflows/actionlint.yml b/.github/workflows/actionlint.yml new file mode 100644 index 000000000..1161a6e21 --- /dev/null +++ b/.github/workflows/actionlint.yml @@ -0,0 +1,57 @@ +# +# Adapted from vllm-project/vllm/blob/main/.github +# Copyright 2023 The vLLM team. +# +# 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. +# + +name: Lint GitHub Actions workflows +on: + push: + branches: + - "main" + paths: + - '.github/workflows/*.ya?ml' + - '.github/workflows/actionlint.*' + - '.github/workflows/matchers/actionlint.json' + pull_request: + branches: + - "main" + paths: + - '.github/workflows/*.ya?ml' + - '.github/workflows/actionlint.*' + - '.github/workflows/matchers/actionlint.json' + +env: + LC_ALL: en_US.UTF-8 + +defaults: + run: + shell: bash + +permissions: + contents: read + +jobs: + actionlint: + runs-on: ubuntu-latest + steps: + - name: "Checkout" + uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2 + with: + fetch-depth: 0 + + - name: "Run actionlint" + run: | + echo "::add-matcher::.github/workflows/matchers/actionlint.json" + tools/actionlint.sh -color diff --git a/.github/workflows/matchers/actionlint.json b/.github/workflows/matchers/actionlint.json new file mode 100644 index 000000000..4613e1617 --- /dev/null +++ b/.github/workflows/matchers/actionlint.json @@ -0,0 +1,17 @@ +{ + "problemMatcher": [ + { + "owner": "actionlint", + "pattern": [ + { + "regexp": "^(?:\\x1b\\[\\d+m)?(.+?)(?:\\x1b\\[\\d+m)*:(?:\\x1b\\[\\d+m)*(\\d+)(?:\\x1b\\[\\d+m)*:(?:\\x1b\\[\\d+m)*(\\d+)(?:\\x1b\\[\\d+m)*: (?:\\x1b\\[\\d+m)*(.+?)(?:\\x1b\\[\\d+m)* \\[(.+?)\\]$", + "file": 1, + "line": 2, + "column": 3, + "message": 4, + "code": 5 + } + ] + } + ] +} diff --git a/.github/workflows/matchers/mypy.json b/.github/workflows/matchers/mypy.json new file mode 100644 index 000000000..f048fce52 --- /dev/null +++ b/.github/workflows/matchers/mypy.json @@ -0,0 +1,16 @@ +{ + "problemMatcher": [ + { + "owner": "mypy", + "pattern": [ + { + "regexp": "^(.+):(\\d+):\\s(error|warning):\\s(.+)$", + "file": 1, + "line": 2, + "severity": 3, + "message": 4 + } + ] + } + ] +} diff --git a/.github/workflows/matchers/ruff.json b/.github/workflows/matchers/ruff.json new file mode 100644 index 000000000..f6d4479ee --- /dev/null +++ b/.github/workflows/matchers/ruff.json @@ -0,0 +1,17 @@ +{ + "problemMatcher": [ + { + "owner": "ruff", + "pattern": [ + { + "regexp": "^(.+?):(\\d+):(\\d+): (\\w+): (.+)$", + "file": 1, + "line": 2, + "column": 3, + "code": 4, + "message": 5 + } + ] + } + ] + } diff --git a/.github/workflows/mypy.yaml b/.github/workflows/mypy.yaml new file mode 100644 index 000000000..ec9c2e6f5 --- /dev/null +++ b/.github/workflows/mypy.yaml @@ -0,0 +1,74 @@ +# +# Adapted from vllm-project/vllm/blob/main/.github +# Copyright 2023 The vLLM team. +# +# 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. +# + +name: mypy + +on: + # Trigger the workflow on push or pull request, + # but only for the main branch + push: + branches: + - "main" + paths: + - '**/*.py' + - '.github/workflows/mypy.yaml' + - 'tools/mypy.sh' + pull_request: + branches: + - "main" + # This workflow is only relevant when one of the following files changes. + # However, we have github configured to expect and require this workflow + # to run and pass before github with auto-merge a pull request. Until github + # allows more flexible auto-merge policy, we can just run this on every PR. + # It doesn't take that long to run, anyway. + paths: + - '**/*.py' + - '.github/workflows/mypy.yaml' + - 'tools/mypy.sh' + +jobs: + mypy: + runs-on: ubuntu-latest + strategy: + matrix: + python-version: ["3.9", "3.10", "3.11", "3.12"] + steps: + - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2 + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@0b93645e9fea7318ecaed2b359559ac225c90a2b # v5.3.0 + with: + python-version: ${{ matrix.python-version }} + - name: Install dependencies + run: | + pip install -r requirements-dev.txt + + - name: Checkout vllm-project/vllm repo + uses: actions/checkout@v4 + with: + repository: vllm-project/vllm + path: vllm-empty + + - name: Install vllm-project/vllm from source + working-directory: vllm-empty + run: | + pip install -r requirements-build.txt --extra-index-url https://download.pytorch.org/whl/cpu + VLLM_TARGET_DEVICE=empty pip install . + + - name: Mypy + run: | + echo "::add-matcher::.github/workflows/matchers/mypy.json" + tools/mypy.sh 1 ${{ matrix.python-version }} diff --git a/.github/workflows/ruff.yml b/.github/workflows/ruff.yml new file mode 100644 index 000000000..11573a84a --- /dev/null +++ b/.github/workflows/ruff.yml @@ -0,0 +1,57 @@ +# +# Adapted from vllm-project/vllm/blob/main/.github +# Copyright 2023 The vLLM team. +# +# 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. +# + +name: ruff + +on: + # Trigger the workflow on push or pull request, + # but only for the main branch + push: + branches: + - "main" + paths: + - "**/*.py" + - requirements-lint.txt + - .github/workflows/matchers/ruff.json + - .github/workflows/ruff.yml + pull_request: + branches: + - "main" + +jobs: + ruff: + runs-on: ubuntu-latest + strategy: + matrix: + python-version: ["3.12"] + steps: + - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2 + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@0b93645e9fea7318ecaed2b359559ac225c90a2b # v5.3.0 + with: + python-version: ${{ matrix.python-version }} + - name: Install dependencies + run: | + python -m pip install --upgrade pip + pip install -r requirements-lint.txt + - name: Analysing the code with ruff + run: | + echo "::add-matcher::.github/workflows/matchers/ruff.json" + ruff check --output-format github . + - name: Run isort + run: | + isort . --check-only diff --git a/.github/workflows/shellcheck.yml b/.github/workflows/shellcheck.yml new file mode 100644 index 000000000..6a8ff7a28 --- /dev/null +++ b/.github/workflows/shellcheck.yml @@ -0,0 +1,54 @@ +# +# Adapted from vllm-project/vllm/blob/main/.github +# Copyright 2023 The vLLM team. +# +# 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. +# + +name: Lint shell scripts +on: + push: + branches: + - "main" + paths: + - '**/*.sh' + - '.github/workflows/shellcheck.yml' + pull_request: + branches: + - "main" + paths: + - '**/*.sh' + - '.github/workflows/shellcheck.yml' + +env: + LC_ALL: en_US.UTF-8 + +defaults: + run: + shell: bash + +permissions: + contents: read + +jobs: + shellcheck: + runs-on: ubuntu-latest + steps: + - name: "Checkout" + uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2 + with: + fetch-depth: 0 + + - name: "Check shell scripts" + run: | + tools/shellcheck.sh diff --git a/.github/workflows/vllm_ascend_test.yaml b/.github/workflows/vllm_ascend_test.yaml new file mode 100644 index 000000000..bea98471a --- /dev/null +++ b/.github/workflows/vllm_ascend_test.yaml @@ -0,0 +1,106 @@ +# +# Copyright (c) 2025 Huawei Technologies Co., Ltd. All Rights Reserved. +# This file is a part of the vllm-ascend project. +# +# 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. +# + +name: 'e2e test' + +on: + push: + branches: + - "main" + paths: + - '*.txt' + - '**/*.py' + - '.github/workflows/vllm_ascend_test.yaml' + pull_request: + branches: + - "main" + paths: + - '*.txt' + - '**/*.py' + - '.github/workflows/vllm_ascend_test.yaml' + +# Bash shells do not use ~/.profile or ~/.bashrc so these shells need to be explicitly +# declared as "shell: bash -el {0}" on steps that need to be properly activated. +# It's used to activate ascend-toolkit environment variables. +defaults: + run: + shell: bash -el {0} + +jobs: + test: + name: vLLM Ascend test (self-host) + runs-on: ascend-arm64 # actionlint-ignore: runner-label + + container: + image: quay.io/ascend/cann:8.0.rc3.beta1-910b-ubuntu22.04-py3.10 + volumes: + - /usr/local/dcmi:/usr/local/dcmi + - /usr/local/bin/npu-smi:/usr/local/bin/npu-smi + - /usr/local/Ascend/driver/lib64/:/usr/local/Ascend/driver/lib64/ + # Use self-host cache speed up pip and model download + - /home/action/actions-runner/_work/cache:/github/home/.cache/ + options: >- + --device /dev/davinci6 + --device /dev/davinci_manager + --device /dev/devmm_svm + --device /dev/hisi_hdc + env: + HF_ENDPOINT: https://hf-mirror.com + steps: + - name: Check npu driver + run: | + npu-smi info + + - name: Config mirrors + run: | + sed -i 's|ports.ubuntu.com|mirrors.tuna.tsinghua.edu.cn|g' /etc/apt/sources.list + pip config set global.index-url https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple + + - name: Checkout vllm-project/vllm-ascend repo + uses: actions/checkout@v4 + + - name: Install system dependencies + run: | + apt-get update -y + apt-get -y install `cat packages.txt` + + - name: Install dependencies + run: | + pip install -r requirements-dev.txt + + - name: Checkout vllm-project/vllm repo + uses: actions/checkout@v4 + with: + repository: vllm-project/vllm + path: ./vllm-empty + + - name: Install vllm-project/vllm from source + working-directory: ./vllm-empty + run: | + VLLM_TARGET_DEVICE=empty pip install -e . + + - name: Install vllm-project/vllm-ascend + run: | + pip install -e . + + - name: Run vllm-project/vllm-ascend test + run: | + pytest -sv tests + + - name: Run vllm-project/vllm test + run: | + bash tools/npu-vllm-test.sh diff --git a/.github/workflows/yapf.yml b/.github/workflows/yapf.yml new file mode 100644 index 000000000..14a3ae925 --- /dev/null +++ b/.github/workflows/yapf.yml @@ -0,0 +1,54 @@ +# +# Adapted from vllm-project/vllm/blob/main/.github +# Copyright 2023 The vLLM team. +# +# 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. +# + +name: yapf + +on: + # Trigger the workflow on push or pull request, + # but only for the main branch + push: + branches: + - "main" + paths: + - "**/*.py" + - .github/workflows/yapf.yml + pull_request: + branches: + - "main" + paths: + - "**/*.py" + - .github/workflows/yapf.yml + +jobs: + yapf: + runs-on: ubuntu-latest + strategy: + matrix: + python-version: ["3.12"] + steps: + - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2 + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@0b93645e9fea7318ecaed2b359559ac225c90a2b # v5.3.0 + with: + python-version: ${{ matrix.python-version }} + - name: Install dependencies + run: | + python -m pip install --upgrade pip + pip install yapf==0.32.0 + - name: Running yapf + run: | + yapf --diff --recursive . diff --git a/.gitignore b/.gitignore new file mode 100644 index 000000000..3991ac8f0 --- /dev/null +++ b/.gitignore @@ -0,0 +1,194 @@ +## vLLM Ascend Ignore +# VSCode +.vscode/ + +# egg-info +vllm_ascend.egg-info/ + +# DS Store +.DS_Store + +# Linting +actionlint +shellcheck*/ + + +# Python gitignore +## Adapted from: +## https://github.com/github/gitignore/blob/main/Python.gitignore + +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ +cover/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +.pybuilder/ +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +# For a library or package, you might want to ignore these files since the code is +# intended to run in multiple environments; otherwise, check them in: +.python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +Pipfile.lock + +# UV +# Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control. +# This is especially recommended for binary packages to ensure reproducibility, and is more +# commonly ignored for libraries. +uv.lock + +# poetry +# Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. +# This is especially recommended for binary packages to ensure reproducibility, and is more +# commonly ignored for libraries. +# https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control +poetry.lock + +# pdm +# Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control. +#pdm.lock +# pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it +# in version control. +# https://pdm.fming.dev/latest/usage/project/#working-with-version-control +.pdm.toml +.pdm-python +.pdm-build/ + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# pytype static type analyzer +.pytype/ + +# Cython debug symbols +cython_debug/ + +# PyCharm +# JetBrains specific template is maintained in a separate JetBrains.gitignore that can +# be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore +# and can be added to the global gitignore or merged into this file. For a more nuclear +# option (not recommended) you can uncomment the following to ignore the entire idea folder. +.idea/ + +# Ruff stuff: +.ruff_cache/ + +# PyPI configuration file +.pypirc + diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md new file mode 100644 index 000000000..f801b5f8f --- /dev/null +++ b/CODE_OF_CONDUCT.md @@ -0,0 +1,128 @@ + +# vLLM Code of Conduct + +## Our Pledge + +We as members, contributors, and leaders pledge to make participation in our +community a harassment-free experience for everyone, regardless of age, body +size, visible or invisible disability, ethnicity, sex characteristics, gender +identity and expression, level of experience, education, socioeconomic status, +nationality, personal appearance, race, caste, color, religion, or sexual +identity and orientation. + +We pledge to act and interact in ways that contribute to an open, welcoming, +diverse, inclusive, and healthy community. + +## Our Standards + +Examples of behavior that contributes to a positive environment for our +community include: + +* Demonstrating empathy and kindness toward other people +* Being respectful of differing opinions, viewpoints, and experiences +* Giving and gracefully accepting constructive feedback +* Accepting responsibility and apologizing to those affected by our mistakes, + and learning from the experience +* Focusing on what is best not just for us as individuals, but for the overall + community + +Examples of unacceptable behavior include: + +* The use of sexualized language or imagery, and sexual attention or advances of + any kind +* Trolling, insulting or derogatory comments, and personal or political attacks +* Public or private harassment +* Publishing others' private information, such as a physical or email address, + without their explicit permission +* Other conduct which could reasonably be considered inappropriate in a + professional setting + +## Enforcement Responsibilities + +Community leaders are responsible for clarifying and enforcing our standards of +acceptable behavior and will take appropriate and fair corrective action in +response to any behavior that they deem inappropriate, threatening, offensive, +or harmful. + +Community leaders have the right and responsibility to remove, edit, or reject +comments, commits, code, wiki edits, issues, and other contributions that are +not aligned to this Code of Conduct, and will communicate reasons for moderation +decisions when appropriate. + +## Scope + +This Code of Conduct applies within all community spaces, and also applies when +an individual is officially representing the community in public spaces. +Examples of representing our community include using an official email address, +posting via an official social media account, or acting as an appointed +representative at an online or offline/IRL event. + +## Enforcement + +Instances of abusive, harassing, or otherwise unacceptable behavior may be +reported to the community leaders responsible for enforcement in the #code-of-conduct +channel in the [vLLM Discord](https://discord.com/invite/jz7wjKhh6g). +All complaints will be reviewed and investigated promptly and fairly. + +All community leaders are obligated to respect the privacy and security of the +reporter of any incident. + +## Enforcement Guidelines + +Community leaders will follow these Community Impact Guidelines in determining +the consequences for any action they deem in violation of this Code of Conduct: + +### 1. Correction + +**Community Impact**: Use of inappropriate language or other behavior deemed +unprofessional or unwelcome in the community. + +**Consequence**: A private, written warning from community leaders, providing +clarity around the nature of the violation and an explanation of why the +behavior was inappropriate. A public apology may be requested. + +### 2. Warning + +**Community Impact**: A violation through a single incident or series of +actions. + +**Consequence**: A warning with consequences for continued behavior. No +interaction with the people involved, including unsolicited interaction with +those enforcing the Code of Conduct, for a specified period of time. This +includes avoiding interactions in community spaces as well as external channels +like social media. Violating these terms may lead to a temporary or permanent +ban. + +### 3. Temporary Ban + +**Community Impact**: A serious violation of community standards, including +sustained inappropriate behavior. + +**Consequence**: A temporary ban from any sort of interaction or public +communication with the community for a specified period of time. No public or +private interaction with the people involved, including unsolicited interaction +with those enforcing the Code of Conduct, is allowed during this period. +Violating these terms may lead to a permanent ban. + +### 4. Permanent Ban + +**Community Impact**: Demonstrating a pattern of violation of community +standards, including sustained inappropriate behavior, harassment of an +individual, or aggression toward or disparagement of classes of individuals. + +**Consequence**: A permanent ban from any sort of public interaction within the +community. + +## Attribution + +This Code of Conduct is adapted from the [Contributor Covenant](https://www.contributor-covenant.org/), +version 2.1, available at +[v2.1](https://www.contributor-covenant.org/version/2/1/code_of_conduct.html). + +Community Impact Guidelines were inspired by +[Mozilla's code of conduct enforcement ladder](https://github.com/mozilla/inclusion). + +For answers to common questions about this code of conduct, see the +[Contributor Covenant FAQ](https://www.contributor-covenant.org/faq). Translations are available at +[Contributor Covenant translations](https://www.contributor-covenant.org/translations). + diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md new file mode 100644 index 000000000..c7d45f682 --- /dev/null +++ b/CONTRIBUTING.md @@ -0,0 +1,107 @@ +# Contributing to vLLM Ascend plugin + +## Building and testing +It's recommended to set up a local development environment to build and test +before you submit a PR. + +### Prepare environment and build + +Theoretically, the vllm-ascend build is only supported on Linux because +`vllm-ascend` dependency `torch_npu` only supports Linux. + +But you can still set up dev env on Linux/Windows/macOS for linting and basic +test as following commands: + +```bash +# Choose a base dir (~/vllm-project/) and set up venv +cd ~/vllm-project/ +python3 -m venv .venv +source ./.venv/bin/activate + +# Clone vllm code and install +git clone https://github.com/vllm-project/vllm.git +cd vllm +pip install -r requirements-build.txt +VLLM_TARGET_DEVICE="empty" pip install . +cd .. + +# Clone vllm-ascend and install +git clone https://github.com/vllm-project/vllm-ascend.git +cd vllm-ascend +pip install -r requirements-dev.txt + +# Then you can run lint and mypy test +bash format.sh + +# Build: +# - only supported on Linux (torch_npu available) +# pip install -e . +# - build without deps for debugging in other OS +# pip install -e . --no-deps + +# Commit changed files using `-s` +git commit -sm "your commit info" +``` + +### Testing + +Although vllm-ascend CI provide integration test on [Ascend](.github/workflows/vllm_ascend_test.yaml), you can run it +locally. The simplest way to run these integration tests locally is through a container: + +```bash +# Under Ascend NPU environment +git clone https://github.com/vllm-project/vllm-ascend.git +cd vllm-ascend + +IMAGE=vllm-ascend-dev-image +CONTAINER_NAME=vllm-ascend-dev +DEVICE=/dev/davinci1 + +# The first build will take about 10 mins (10MB/s) to download the base image and packages +docker build -t $IMAGE -f ./Dockerfile . +# You can also specify the mirror repo via setting VLLM_REPO to speedup +# docker build -t $IMAGE -f ./Dockerfile . --build-arg VLLM_REPO=https://gitee.com/mirrors/vllm + +docker run --name $CONTAINER_NAME --network host --device $DEVICE \ + --device /dev/davinci_manager --device /dev/devmm_svm \ + --device /dev/hisi_hdc -v /usr/local/dcmi:/usr/local/dcmi \ + -v /usr/local/bin/npu-smi:/usr/local/bin/npu-smi \ + -v /usr/local/Ascend/driver/lib64/:/usr/local/Ascend/driver/lib64/ \ + -ti --rm $IMAGE bash + +cd vllm-ascend +pip install -r requirements-dev.txt + +pytest tests/ +``` + +## DCO and Signed-off-by + +When contributing changes to this project, you must agree to the DCO. Commits must include a `Signed-off-by:` header which certifies agreement with the terms of the DCO. + +Using `-s` with `git commit` will automatically add this header. + +## PR Title and Classification + +Only specific types of PRs will be reviewed. The PR title is prefixed appropriately to indicate the type of change. Please use one of the following: + +- `[Attention]` for new features or optimization in attention. +- `[Communicator]` for new features or optimization in communicators. +- `[ModelRunner]` for new features or optimization in model runner. +- `[Platform]` for new features or optimization in platform. +- `[Worker]` for new features or optimization in worker. +- `[Core]` for new features or optimization in the core vllm-ascend logic (such as platform, attention, communicators, model runner) +- `[Kernel]` changes affecting compute kernels and ops. +- `[Bugfix]` for bug fixes. +- `[Doc]` for documentation fixes and improvements. +- `[Test]` for tests (such as unit tests). +- `[CI]` for build or continuous integration improvements. +- `[Misc]` for PRs that do not fit the above categories. Please use this sparingly. + +> [!NOTE] +> If the PR spans more than one category, please include all relevant prefixes. + +## Others + +You may find more information about contributing to vLLM Ascend backend plugin on [docs.vllm.ai](https://docs.vllm.ai/en/latest/contributing/overview.html). +If you find any problem when contributing, you can feel free to submit a PR to improve the doc to help other developers. diff --git a/DCO b/DCO new file mode 100644 index 000000000..49b8cb054 --- /dev/null +++ b/DCO @@ -0,0 +1,34 @@ +Developer Certificate of Origin +Version 1.1 + +Copyright (C) 2004, 2006 The Linux Foundation and its contributors. + +Everyone is permitted to copy and distribute verbatim copies of this +license document, but changing it is not allowed. + + +Developer's Certificate of Origin 1.1 + +By making a contribution to this project, I certify that: + +(a) The contribution was created in whole or in part by me and I + have the right to submit it under the open source license + indicated in the file; or + +(b) The contribution is based upon previous work that, to the best + of my knowledge, is covered under an appropriate open source + license and I have the right under that license to submit that + work with modifications, whether created in whole or in part + by me, under the same open source license (unless I am + permitted to submit under a different license), as indicated + in the file; or + +(c) The contribution was provided directly to me by some other + person who certified (a), (b) or (c) and I have not modified + it. + +(d) I understand and agree that this project and the contribution + are public and that a record of the contribution (including all + personal information I submit with it, including my sign-off) is + maintained indefinitely and may be redistributed consistent with + this project or the open source license(s) involved. diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 000000000..63c8bd685 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,40 @@ +# +# Copyright (c) 2025 Huawei Technologies Co., Ltd. All Rights Reserved. +# This file is a part of the vllm-ascend project. +# +# 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. +# + +FROM quay.io/ascend/cann:8.0.rc3.beta1-910b-ubuntu22.04-py3.10 + +# Define environments +ENV DEBIAN_FRONTEND=noninteractive + +RUN apt-get update -y && \ + apt-get install -y python3-pip git vim + +WORKDIR /workspace + +COPY . /workspace/vllm-ascend/ + +RUN pip config set global.index-url https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple + +# Install vLLM main +ARG VLLM_REPO=https://github.com/vllm-project/vllm.git +RUN git clone --depth 1 $VLLM_REPO /workspace/vllm +RUN VLLM_TARGET_DEVICE="empty" python3 -m pip install /workspace/vllm/ + +# Install vllm-ascend main +RUN python3 -m pip install /workspace/vllm-ascend/ + +CMD ["/bin/bash"] diff --git a/README.md b/README.md new file mode 100644 index 000000000..c16e8372d --- /dev/null +++ b/README.md @@ -0,0 +1,102 @@ +

+ + + + vllm-ascend + +

+ +

+vLLM Ascend Plugin +

+ +

+| About Ascend | Developer Slack (#sig-ascend) | +

+ +--- +*Latest News* 🔥 + +- [2024/12] We are working with the vLLM community to support [[RFC]: Hardware pluggable](https://github.com/vllm-project/vllm/issues/11162). +--- +## Overview + +vLLM Ascend plugin (`vllm-ascend`) is a backend plugin for running vLLM on the Ascend NPU. + +This plugin is the recommended approach for supporting the Ascend backend within the vLLM community. It adheres to the principles outlined in the [[RFC]: Hardware pluggable](https://github.com/vllm-project/vllm/issues/11162), providing a hardware-pluggable interface that decouples the integration of the Ascend NPU with vLLM. + +By using vLLM Ascend plugin, popular open-source models, including Transformer-like, Mixture-of-Expert, Embedding, Multi-modal LLMs can run seamlessly on the Ascend NPU. + +## Prerequisites +### Support Devices +- Atlas A2 Training series (Atlas 800T A2, Atlas 900 A2 PoD, Atlas 200T A2 Box16, Atlas 300T A2) +- Atlas 800I A2 Inference series (Atlas 800I A2) + +### Dependencies +| Requirement | Supported version | Recommended version | Note | +|-------------|-------------------| ----------- |------------------------------------------| +| vLLM | main | main | Required for vllm-ascend | +| Python | >= 3.9 | [3.10](https://www.python.org/downloads/) | Required for vllm | +| CANN | >= 8.0.RC2 | [8.0.RC3](https://www.hiascend.com/developer/download/community/result?module=cann&cann=8.0.0.beta1) | Required for vllm-ascend and torch-npu | +| torch-npu | >= 2.4.0 | [2.5.1rc1](https://gitee.com/ascend/pytorch/releases/tag/v6.0.0.alpha001-pytorch2.5.1) | Required for vllm-ascend | +| torch | >= 2.4.0 | [2.5.1](https://github.com/pytorch/pytorch/releases/tag/v2.5.1) | Required for torch-npu and vllm required | + +Find more about how to setup your environment in [here](docs/environment.md). + +## Getting Started + +> [!NOTE] +> Currently, we are actively collaborating with the vLLM community to support the Ascend backend plugin, once supported you can use one line command `pip install vllm vllm-ascend` to compelete installation. + +Installation from source code: +```bash +# Install vllm main branch according: +# https://docs.vllm.ai/en/latest/getting_started/installation/cpu/index.html#build-wheel-from-source +git clone --depth 1 https://github.com/vllm-project/vllm.git +cd vllm +pip install -r requirements-build.txt +VLLM_TARGET_DEVICE=empty pip install . + +# Install vllm-ascend main branch +git clone https://github.com/vllm-project/vllm-ascend.git +cd vllm-ascend +pip install -e . +``` + +Run the following command to start the vLLM server with the [Qwen/Qwen2.5-0.5B-Instruct](https://huggingface.co/Qwen/Qwen2.5-0.5B-Instruct) model: + +```bash +# export VLLM_USE_MODELSCOPE=true to speed up download +vllm serve Qwen/Qwen2.5-0.5B-Instruct +curl http://localhost:8000/v1/models +``` + +Please refer to [vLLM Quickstart](https://docs.vllm.ai/en/latest/getting_started/quickstart.html) for more details. + +## Building + +#### Build Python package from source + +```bash +git clone https://github.com/vllm-project/vllm-ascend.git +cd vllm-ascend +pip install -e . +``` + +#### Build container image from source +```bash +git clone https://github.com/vllm-project/vllm-ascend.git +cd vllm-ascend +docker build -t vllm-ascend-dev-image -f ./Dockerfile . +``` + +See [Building and Testing](./CONTRIBUTING.md) for more details, which is a step-by-step guide to help you set up development environment, build and test. + +## Contributing +We welcome and value any contributions and collaborations: +- Please let us know if you encounter a bug by [filing an issue](https://github.com/vllm-project/vllm-ascend/issues). +- Please see the guidance on how to contribute in [CONTRIBUTING.md](./CONTRIBUTING.md). + +## License + +Apache License 2.0, as found in the [LICENSE](./LICENSE) file. diff --git a/docs/environment.md b/docs/environment.md new file mode 100644 index 000000000..5dd70b29a --- /dev/null +++ b/docs/environment.md @@ -0,0 +1,38 @@ +### Prepare Ascend NPU environment + +### Dependencies +| Requirement | Supported version | Recommended version | Note | +| ------------ | ------- | ----------- | ----------- | +| Python | >= 3.9 | [3.10](https://www.python.org/downloads/) | Required for vllm | +| CANN | >= 8.0.RC2 | [8.0.RC3](https://www.hiascend.com/developer/download/community/result?module=cann&cann=8.0.0.beta1) | Required for vllm-ascend and torch-npu | +| torch-npu | >= 2.4.0 | [2.5.1rc1](https://gitee.com/ascend/pytorch/releases/tag/v6.0.0.alpha001-pytorch2.5.1) | Required for vllm-ascend | +| torch | >= 2.4.0 | [2.5.1](https://github.com/pytorch/pytorch/releases/tag/v2.5.1) | Required for torch-npu and vllm required | + + +Below is a quick note to install recommended version software: + +#### Containerized installation + +You can use the [container image](https://hub.docker.com/r/ascendai/cann) directly with one line command: + +```bash +docker run \ + --name vllm-ascend-env \ + --device /dev/davinci1 \ + --device /dev/davinci_manager \ + --device /dev/devmm_svm \ + --device /dev/hisi_hdc \ + -v /usr/local/dcmi:/usr/local/dcmi \ + -v /usr/local/bin/npu-smi:/usr/local/bin/npu-smi \ + -v /usr/local/Ascend/driver/lib64/:/usr/local/Ascend/driver/lib64/ \ + -v /usr/local/Ascend/driver/version.info:/usr/local/Ascend/driver/version.info \ + -v /etc/ascend_install.info:/etc/ascend_install.info \ + -it quay.io/ascend/cann:8.0.rc3.beta1-910b-ubuntu22.04-py3.10 bash +``` + +You do not need to install `torch` and `torch_npu` manually, they will be automatically installed as `vllm-ascend` dependencies. + +#### Manual installation + +Or follow the instructions provided in the [Ascend Installation Guide](https://ascend.github.io/docs/sources/ascend/quick_install.html) to set up the environment. + diff --git a/docs/logos/vllm-ascend-logo-text-dark.png b/docs/logos/vllm-ascend-logo-text-dark.png new file mode 100644 index 0000000000000000000000000000000000000000..f534d09eefe2c410ae09765faaa9eac95d728e9d GIT binary patch literal 156286 zcmeFaWmHsq`#-GXprj%oAR&Wvi*%15Qqo9+NOz|QI7&%N3erfYgp|MlA}Ep)(k;>@ zA^G3qIdbl!n|m#O>v{LwFI;Y!VSlfV&votXGX*&b9840-GiT1=NJ-vSI&%iM^voH^ zAo_XWC)}DfyTD&(9h4+Q&lI$i%>n5Vh;13D#=ggUN z$!E`;1O7gX`dKpM*QdCp$>)AuLk3Y_#DAN5=gb-S8L8X1R9w$4j<|;zs<{!bI@oM~ zs{Ia6?l;dgdFV`pp?(z|;(g{rxZ4Nu>&cjRpPa$6%+g~fI&V4gZu z%cAsYEiHnW8k*WO;v6N6w^u2CJk1FU3)fC2@Ws0a*HasubGLt}y4NW@+vTw*?1|Iu zI3_&%Xlz@cCi9_7wTRF7oyTX+LZIllF!=v2{wIY0S;GIk;D285KQH*77yQo){(t2K zmI|<;@kgIAPO0`HMg+0w8{2_`*zCFbH#0Mq{2j$}6Ys6`zm^TBK2_nRAcEL4Hg?7?Zf8=W2sFtwCREF~#3sUW@AVRA6d5}EzDKmr$~)X6 z+DlDBY&)adhaG0`tL}ok^A)1b&eTa#YN69<+6iyx{r*0UUv%J0gXkLmzzH{o?chho zKfE$&iM-0ls*@@vQdT_cS04jG=t9ehJ)(@j7(HjJb1lmJ6z_CRl?|Q zp{Rddl=(F$s=x^15@t_p^P>HbT#AR^CL$6Y5#SXxBUN&WxX~NY>!&+(o~DTRa~;3o zL|sN+lD7R<5orqV+D)G^_tm;6GBsXsU8$!(_9e{qz8M5g3b<4rpFuQ2*u5W_y*XkN z3tGXUT#)OW*_x4a{fu)-*wyw4AG$2K;bh`=c1{w|vtB-3(_m|ku+eeq?Lklo?^k|b zEKGQKdq8bUiSDBA+Wv~yQL~W*VJJBLa%{;dO>4@iN!A%ewjk9!>|8(5J$MYcWY?X#XeRC}LWzQ9gER17d z`%`+lD8Jr+`_oh~yoth3;19P&-gS`@oS2hC(lxpwHtjLlHs;zeR^6itI>zrXtbt{T zjchhg_m0Fl%ygP7pypDl3Kt9Pv#x14UAT+af%%3xnOxg(BypP>kdS}$u1w_c!_i*P zyOJ<)zR;mKEN{_Ivc418<;_Pb*&K$7M%PS~p3B*~{n6=x@!{q@85vRY?3McvA8yXyQ8Vue%?K2euh~uUyH=p08cqoo5#WK)b;8~p6;P3$tRz*2 zB3^+b-=0sCRJmljWePy$tVk#%Jq{@TshfF%jQULf6<{ zOv@Fx{(f z#Lenv6g{Y1K}GOW%?9`tHpa%ydbnHMS+Px>Im*m_V^>Mze88P!yc9?!@zL+`L5=Z5 ztqoEFR^VO_TNsYWNwCsxVy_kU4cm3B01u(?Sm2PzY!<>(v4RM|80O(9p?SB+ls(%R zbw$RCbIx#LGJRmcB-ofe7gT1Ck>)_GQ_qjII~_kHw6+rH2{U=_?&ij84ZcxZJNEjs zY7}1eR3{ihIgp^H2;T^wk|Rv*z6CEvtci?(44#jr)?_pKeb>R9^9-T{%hc4)nTqOU zMT2q3DW_+barB(HfhCw}F%qrG%kg6?E4cF^zd$)liAnQMFpQH-Tt!(Ah+lnSKHDlB z)vpc9obK0o&8e%tIl)Zhm4Mi+TwEb}()~cym>dg{sX4R&DwDUdy$Q8Bb7FRf-#Z@q zf`{chEI>NV63>@7-5IG6tdbJ80Ln+)>HSq5mz$Xv^S-^23;x(G~Gi z9Wu@g!E$iu_$YeV#A&(9EcWt;W3-Kp@q-*tt;4wh_dB+AW&)IP5FbT>{BbuT+%tc;5?hQaTX%nWGdV>qGTX;^uTJddW2K7i^mV|!vJ(n+;*oIXdy`V!_3IicZ$Fn>b| zIE6Nwjr(+!2^Tu^)-Hui4k69~ST*VBe2q0uYnR z(NxedbCOlz0$d!DJMKzxb#L~3nl=WG&9030n}~`a91x38Nkb^LAeCCL;xuX z#$^7~E}ZW_p!S(xi>E63hZO7*iKZ(hXc9=ijd=S`UG#K(z=|*t9s3EUFWR=%B>jq3I;=73~A!jM4tr@sXTb~$FnwxeN3#qY! zDLmo|;N``Kso(^hpz%^|JpkYf!EIbAkAJW@Lqut6%I<7*7Szyf?*bXhfN=SAhD(1> z&&+t)iQP9eilj8XzBnsIT&7%i0L;VhN&*L9)MK3rt?9Hz9Mt@XdC$CeSE*%?MNxAz zUM7tYyeb2@o4EJi1pa3jNj3y-pU}Y|YG;BeaL@i*pKt3rz=DO#{RvPOL;)70vI3?4 zywk})>C{9tkqfZNw=pkcQVL|2q2trP^}hv(q5=!-K5%zb`Mffk8-IdQK}{TB1OS1S zG;|kbAFwgfGiP)}jE+Y%cu*k*zokOHmA~5DnCGBk99p zh-K(OKLZsLN=y0p6;$4GF1Ux+xk@SuoSM|K#;*fdC1WXt5?C}%{sENfoL-^#PSus) zxP@5aI1rJYxX)Ej;4KHqe(B>&sEYxn3tW1|WG#K>6c9C?$O9C;R9Y{EXB(lis-<<$ z@m^ps(2qG;OoKJta1N9~eXY$oRimue0Kuv`94f{=Z1Vn$d*~0p_SyL)#7YC=rh#|| zCcOXR6@&<%fgfs_%NR+fGBr+F97}$_gic@R`M@lulNhMeNJ^qGPjyDt6J&QtC229S zNR0iO#t5UOKN+};^{zt>!ya88SOt> z!D|mE{BM0M4}P5L2;8hx>_;PCxYqTM?&{-cf-LQS*x> z*(ROA7RXD*NMFLXFB12_EKdO+(1LlfV)v=WmRT9dZXdOHEkXVY0boL5ZcLw>0-rZd zN%4sRFE*tK0GQ&o<>~w(j%Ia9$US4~t3=(4oQJ9#{t^v`Z zUYO}QNV-AHqc}*Y3Bv#j@t`sS*n;Cgqm93MQh6^v<&wM?(2PL@O_YG^r za>Y6IB#`4zJ`}DDjefYn(}a7ZtUPa~Os)|`qFHLz*eeafH1ZwV`ZE*Q$u|Q%nG07v zZsbP;kcPG*%`?x>Nv|0KCL_mf=L7n60{~mow=5+*Rex_9fIJ*6U@~B?4WA$Aj*Qb( z2Vx-0upJAUWlO=%RH=rK%NR$3;?A#xmm#uf$Nc> zKq;}_xRaC%%6%|yg;#S3UDMkyF9Qa;{GVuQ-$r@3c;NQ^Ij|c=vUReEyz&S82rTgY z6@qiveoo|t;^ar7ZhA;>mPAc30)U4)S~w->jfkV*!Z|*9r<)rmGeGtlHb?S5YaQO~ zb#PKPSGsV5yy=yJTJUCB6DT+hDkXr*thYb}S!fqros0Zds4A?1QJ@QZZ@Kw27(Ao` zou{ekYsFg|pq_J5W+I^hJbbU5vURjGE0qAhSg^mdVFAQ303vBH9c6-O2u@%TJVYU+ zv0fPyu3%ESyQD`%4p%|-0q4t;X{QD)!}8=|_s2L(P8FiiIc4)Rwc8GGfbC40Aww*Yz+!3viFoIR#fuATAY)-1I3ER!Qofy*)D*UjVL)4`!sxi z_RUgT@HCAm2K=91Mw9GRoJga;!!2HhJrbtb7?!4{ex?L14zn;-3@C+x%9ocpImJf} zyi_^Cs^Pg%LidBv^e6WRa#F951_+v)PB?*jD*_Lw&FL>|ovMXFe86P>{#7`visY?9 zv4+1e27>uKkQ&ai(Sm6r9{>(g%d`qlgMGlOf2LO>O85KKIjT!`fWeUYO@QJO(D$f; zVueq>Ja~iwl_~6o9U^_S-J}`UM*f+p`Hi)a7wV8LPyO!@u%z^VLg-5+^^W%UwS$^; zvZq;C7`3wL&~LZhmBU>FUsstz!7FcTRZoRKy+{Uz07n>2uw@*L3fCuQC+$o@HGu#o zzVJr79$XsWrs0hKXdx#zBjfx;E2S^fpyF%B4(c$Up1yY{RD;s^-=YbnV5ji~R01H| znP^OsnkZmmf29yb2%x|!551_tro-^h(DjTfudbc$fWVp`muP+ZpTlfbV8HBxtjQJ} z(w_nr67~1rUq2!KfLS&aJ(9kNcc_lVduJ3+4D;T(pNOe>k-QREHcjROteDe;?cQk? zQcP=*-HZD&qSzGXLeR$%P<^0S=9Ov!MNe(yUh14-p`@K^UVuzEt#OJR$Ia{01PnLFS^K1sy^$I~V_nVQzt}gCNMj z)uhc6K=2?H7{#19A$Y_ER|76gp%_^kxD}5tHoHvVEb$@5C-?c!9#1@YO9phl*>fL| z)$U3P=4m*|zk)(;Og1`J?w*miVR_P^Mgz!7Jt_ix&z3j}m<6PTmx51bPB<7o2Z?EG z_qd5Qk)D2mu*es}UZe8=<%~-26$EgJ(DyG6zDg36sXs*nP;rvC)zV<{PJRfOtcs1i z;qBAJR$BmB(LGA?#T|2tevn9Odl%*;!ncJyVMa^*e_75!N}>VnSARx3^vLK{pl040 zgdG@&aC*jE0Rze4Q9zo`>b7nHZ=FtviQ_?#KmljnYhwHMB%B`a5sB2cPvC^Ws15N> z3^W7<-2+VO^}6P%a8o@M2v*E;E&X(pkXa4Zow5ukO`5Q>9L*;1TC)LA$X(ZS-ls|v zywyk#4i2q`o^>6w>HPr-(px8~^R6bqg4D|6ofBjN{(B|_{*;E|eFu*S8ywnsJ0qa& z%wf8s*5LP0h=!Nv!6#1@W^vU+k==KXrp!i}`Z)T@AQDjDV8xK(ZLkOhM2P>>%u_uR zDQdHP&TM`q&!Nf;8iHvEOhfEc8p*+RjS3%Yq=6s-6)sg8}=(k14!fd$_ zSt(5e{(_(tB|;HsiP@!PEx=&C6U`w{YrI+H;D<@~v_*f-<7X%jN%&#b0qW$Bk@P@O zPMn@mc0!5(&$4|qMV$*?yt4Zy3vrfshG-+gNnnj0U|8DauKn zKF$DZ4o+6N&UkHXEV%~Z%0)^6lckb2SP?6Lp!GEw1EKma7WdxNiKx9@Wa!dE9LkWW|+wE$1VH*5eF@FY&38>ljpptCWa{SxV zAW~fT>Wgh&oay^tac`jc0t3V{_%E4N&*o1VmQ!+#C#m z`oFBc!}FnAD}zpU-`=?^b<1bnn+&(g0X$H4M8gRzt}3ARq!=q%!cXHIJz6LSWNAuk zb!o!g-7L7hg@c+`+0@zcMU?oB5QY$}Bl9~Mq)MLRW! z?2r3-xoqpW96kWB6DoMJC}ic)io5$jeSMSoS_|KWOYieF_{T2#)JF>@Scs#)Jl~|} zpz1BlZv0ZzUwLjZ?xF_&g8nyO;>`1ujwNC3RWDq+pY;Vdmauko|4^NtTdBc?-&4FnE52$wbp+ zX8!fV3*zj8oBFD+%3Ts1r8Bgyoj03vyq;mvm_#Ym{(1drn5a>!9pkik5T%gNBWphL z_=MEYS9N7_^YfybZ_$xwF<2({Nm45B&LuCsvZKtPbbG{!lSG0YI#nv_Qu!sak9brh z@~h?YtM!0eWUqK~MhHw?JN0{LbAgw4d3kCpx0My36FMl03;X*!>DK8)@CCW$Nq$ zzh^KWL>SM0cH8AsZ@=(#B7I_K!eOq3p*voXoSjKRj-R00VUCO>QQ2*`#+d(McgI9m zzqRnGps`@T$S7B-LLWjSeztP2ePKoDLAOqZFW{#PK z;PYDKSAcl=qkfmVjmC8Mqph~Iu5!%Z9R3Cduz$AEAz62H)cU<&EJ5lWQ3TQ#+I=70 z(zNyisPn>#Xi=r|JEI%F?gfuP({(uryl=bNtL8C>M4X#*=b3xy!*st}j>1rK3@J56 zclZ9F#*cM{>yk;IPNvpXsbX1~0i4JB|} ztfW%=xD#9ZjofoRBFWdrb7Ms~9(Z8xvJy4~%E)NDkZ<#LX1$f|XuQL7t0ZcJCBbA) zPm^y}^Dqg$sRL@b zo<8z1V9#Z^(LYgiZJ1TsqM;{?fPhA@TdVbEUJbb|&r5tLc)&=n`f9C`7nDcc#2c z7IxMoIw~K;W)i#S?NY5>3KdxHdQBNh9xK5buRUv5(mgVDja--Wpn7P@_h{#X{DByN ziWpuM`K>ZQ#9=HBy>_RaZuLs=-1d@dQ;K0lG(+VMIe0n2HGD%D(C~W`3!`806S#%o zO;Xp-RS}=kZ{+;Yhur_)BaL#~kq5rdXNTE{PWM zI4lp1?tU%L^d&sXc7H~yM-%pFPCZ_ea?`bK%NyMQGGfauNxfB{%^{X z<9==#RLmgiq}!Ma@{E0puNUzndfG(A0(%v&f^G4gK|Dv#d(`Pp&7|RdT>8P=&;lmI zwwt-e#OCl}wwegXT5*a`{4Ak#Kv!1{-+fZLZI}Dy-2~Bx%*@ON<-&?d8lJKJjLZW4 z0HCCazcpSpD{_?4n)G%r{ON^Di4P((k45zBq7C=k*0ueTo(tnmZCQ7&un?_oXRvsk zr3c&BLD-``>a5nb>H77{P)6p}Z!ky3_{1LIM@5$rdGwD4+^HUa#e*qWA#RcFIJDoh z?ph7pu1~A-)H}!GR_cl5%@oPBYBW8RI@V6I%iJ{N7>`o9r{~7^&`Z0w z?K#m|2rEu^bU1c?ZVPi4XWZ&?6Z(71iYM`FD&ziip@S}ELIT- zuVh#hR2nyH&XUL{FF}qDLyxALYIIkw`duV97x3Br-M7zU4fn5z(6lzhC_PigVO2J> zB52vKF(WP4Y5TYT{Dpqpl>@Md4+DY6Po*fZBZy;aL<+tnO8No*f?+6r`5?yk&U-UT zKy0+AQPD;;cAdY7z|fFWD~nB~847Of)JOEc{mS*(p`>Q4VkZ?#;Awqw6Q1<%2!9;& zYVeOAGUr<-5>=+~pb$>Bhdi|$@8IjNU=mmK1~kX^eXqu)?%Tb>hXB|^DwkXa87kjC6mfTf z&`D^}1=Z!uN>?;qku;{|cz_3^!)gwAlEB7qubfX_IDQQVECG_<;uAJUc2)5*@TA*WI-}k*iom1wuhf!NFfvtN`m%J6 zjZw5EiP+3j?p?F(E>e2~K|H}Evu_D^S*mJnS4Fi1Ledtf8AV}oAGhq% zR!bPqLKuk9iK6$&c%HCJhf@!l=jNw2>K5-b6zy(NnKm#&F==eK+-AuIO_mqYUX$_? znh(?bHa!TSF3L;Wo1z>u2#72>5rjg#zG9oY{bkquc##+;2Cgccc+k-BZgPAi`7GJQi+hYwrt>}7?q1()jt<{m=6=8h5x;E8Z$9^&&e6HlMu3x3 zB{F{IcTkN$ay%o1fxX4aTv+h?AIiYjHkk=6A^06WopGpD?iIABqD&Y8qappPod z1>sV=QS&+T?i_DI`q0wdXe3Su`+XT#3bA)Qhm5e5G_gJuQu=C7W zG!~M_1v0-hjBvz^jG#;k{mjRidL6F!9b#9hWT)Tvjl2w4PnAZSq%IC6ZTga@Q_VeS z5W4Kq&O7zaC(ZPI4%D9IhLQB%K#57mu&16Ltlv#KDjt#vA#&df zd{ViOD+zl_g=b81nk`L|(ofDHa4>lxMYjmq@L*w=5b8R`ikA%2m7Y0|IQ4&3OK=?i zk@EVDB2U&?2;XJi`K&Z&0lg!S&_UyuR?;bOb-Cj3^S^BPZ{`&o5jI=jOQWWubDuVr zrfRj+`9rLs3hxwSIDY%)PdqXh-ah>oVC`zZ^S)vk7*E5dCz<1a+g!JSqpYK7w zlE1{L#i}637~){f*MBF5jF{MeaEQ)^t0r?cz6keou(Vqm95Pi^#XnlR*{3BQC7lj8 zlllEw;+7JmY=REO#UBarvt%=O^f(}xnwIBVhJGjhr`)pAA4h~+WM{J+`{iA%$d5)z zp&UX_p3uSd@F9#_mXKyG)Gx2b!^^UohWSe5+}bSKUu+KN9$r_ti@;*@oMrmjHe}OL zUtg~eX^Hz~uYXTKS`v`O?FB9pQs3K$X=o`Sjra-dRXqOLFn z@hu)cg%&68+SKJ$)_8G<2Z+A!C8!|3xcp@^z#tJ7!fr~XUJ5C`nv37^^zjoyH)3(V z|4`d8z#VoK(4V1k7W8o}y`sp7X;K6QeL2@*D`YN)s z2~hcQZLK-!X89Wyi(t4jl+|Nw@8ZIXZZ|!=g7q7Jcvms2?Z$M0N5cVmE!ny)FW16T z2G8H={#(Rh>_Ak#$*tFL9J`1G5cW!2KU^1G%kDmg8=y_{Dwbxx7E5*khW-k$YdO@y z&Aqs;wzfCszb$^*>@5`j!Np~%sthfr?&Npb5;k#^pCeN{*w*`Fj9{oSzWYIFDN5;k zTUcYCM!VP|)SLnLnG~P}q-+ zjcrJ&&HjgfaWmS=$agrmrPtf|pgE6y6CH&q+&w$%N8m7Q1h%XTKL;f!H9b?sdR*cv zF)BQJBrG@Ai5_?cp@{WPYKJYLp~m+vVEQdd@GO&*Wbu4Ir=`KNuHnj(@)4WEpg@a} zH(ThhbjHV@&ephu3T1HP;NYYSsjU5>Q-C@TN7D^GuOGRJ1RaAvsZ&6(`FRne$?E)G zApND>tm?;DTk~=S$Gr=p6jOz9g1d(nFotPmQM%D;nvo(!5M|3eY-rVldZj&7}&>BEt% zT`8U-EZvV=e-A6D6o&A{q&MwS@Ju-N&Q~(9wI94X=dP1LpysqUgyq6*V^Urj%S-y)Fk4esxsA5U2Iu+e~^;ad@R98y}M;gjv710*-P09Ry2%%458$?Pj` z`~U(iroxqo3YdyFxS=bRwywJvY(vUR)zc=MxloE#T7IvF6Qr8IgZW_-`8Ns~+Rm1lFRp95?0T z9gvA9G<3}S8jTcyKJUT`mZuh{?YVQhDdE6pTQ*)9SwAR%ywjEFF1Nz#SU;)O_tp*v zPcjy%%V9!M*Zo|H zu3!p;5KN){@Z)yMwH8j6F)Omo1IXK+>V~Iw{B5ZhvM4V|hihk3hd6|Eb^1P$RJ5?L z;B;ADESFEt67R@C1Y#BY!|${CB~ zo@<8>)n6NZVbVeXwWMl+&cc4!li*6nW0(Au6oJD{;{gehniL+FN{C1d>X~;KSPZ22 z695}j2oq6(g4Vpt8OG?iKn0h2W8lR_lx1-m6xQ&|32an2yf38+#y3qyYOy{XS;*Y{ z?g-?J^LJ7#esc=c3y7@emJ`);-i=)pxxgSTa8uOc%3Zzv&ae$JOzy9suOUjd1F|e< zyKcv^`Wf)iDMA`CunKnM28z&uZkGf-h;-Ys{uFlrl_;fR?oNIYw>Q){qSm z`H$lC!nyhR!3WHH-P{1~wpcOcEE99hv-={xvw!YT^`E+?K@8E!4w~E2S8=}^j!my< zl1_dOu>uGQzdv?N$bVcA+=br?e1cQ)kA%5dZ>VJNJbG()Z3Pz=_5g9HP?R~Tzk(f_ z+=+qvB?wMd09PwD;gC%8sMfv~P*q*M?bfO_>O5^aR4j}r#n4{!I_!9$laR3C=j+=| z80Y#Q8vCo}eMx|x&L`6msaZ>4J$%C^0_$PK83Yk}sVbwVnk&K|$l@TWmRR5{(PD5y ze)O>=+@uYA$Ljs*OBhDX83fA}(-N;CCC1jvurOJKeK>DB-+M70PL&Yn0i(=}WuYoI zLE}+&tzbKsI64I$gxIB;yh;P5*_X6(!(|$`0;^sx{Qh`))^lWW$TCwJucvr$+-Gb= z1G=CtE0d|>i>_$Uw;==*+NQdsNx+Ye$!EaJicGb|B1J{9b=n)O0Sy=$0h-fR+B0I0 zkq!{4>35%JIo~fAnk3GJUgTeW{4}%H@auDf{=jIA9yPte(q^J-wn$Hzy}iAKq1U5- z2qlf6BHQ5Og@zRo8!{sfRXPPpMBm4DOicp&X&TV#Rci)?HfmD7-% z`GOvB2GNB@eFcr>PGJ_XDy_tb+bp%HtWAENPAc5gkKEZmMDyX!keExG(>Em|=zHz) zthDG_hkhNpJ5ka`pZ2={crz!^jqtpY=VR~T@RH9T{Cp9Sicv}}=BY+MnA{rkceV1b z+Q1hB$Rsx&lK+!QWRZSTrNRFHm{2!un0MfzN&6S~ui`dd+bL#&vVu@wCfh-?!XcaX zc#XXn>2@88f`pl49{&;>;yuQ&pxeiKJF+7Qf8?#;_c%`zIaoX2iVf5y1%;-p{`U2s zX{9CPvBg#~hwAlzDk%emvu0{mO_ zF_RXejZ@~M73VR4j()#gr!LuLi|zwN8BA&^ zJhfR8?ra8t>Q_>*#j(Yyc|KTg;L&zG_fpSiIROh@p}k%rgeKIr2E#2-ZH>tUt zm4FNq+OE<|^7v|5?z{wFBI*5OBTO#{T08LhGdFIzHo1gd2eDI%2E+$Xp)*yXkp-B9 z{NX@Q5@rBKdU^rAef-(nW&a3;?(0Gm{wTb@3}2lz4s)+!kShy-P0@kE=9$4>1^*=} zpw+)9{0&LdoaFdEmER>_0Fp*%YLg`VBTPI{SBG)HDTqY*-0@BSxt8SAu$rXYqA~ zfX2D3j4CXky}123W7CquqW#lnu~`=%zIam0>tWW2zz(mC2Rh1`?XF+1&gNyhzqiWb%3(rZ9uTjx|;5L zYz@V%xO4^HpLU4@k^m?Li(1iw%x}oWYDcFKXnbHBkOxFWaLGCB4eOiLoJN+41a~xQ^*VGe#Sb{k^&JI8qX}o1S#!Omm*MrVe8n8 zJYIH^f>}VKa93SK&wf=49&^eJY07mUtI;ddC)6Olz4k{l2*@$a2J!V#CY``P#A&hK zAdY(Z=8>5UN`?XusdObqx+~%=B^-u8)Yp3fnYi8S`XX2T?Hx$Hu(^drASz8y>8=If zi);nkJeoNq;mW@XDI+xH`|)mSw4(8%0Ouua?4ByCr9bLw^XosG(We%EwO2@n@@a9* zz2Tl{*8)#7RdXLVZT53qOD7E#MpFFbNTnDW)l zt=*pOpW-bL{ru6T58s^&0-Y?aitsb&ds z@&p^f!<{LY>{}6WFa--lbS#I-+c&wnxlVd|$*6w!moR?y8w&Uc5#jZnOffOPzE|wQ zxGhoen*`lI^uym>U|rUFZTew8>b~Nq>uTqiuR^pKSNm9WY_Ve8t?11sz9wt=8?pam zJAX%YQz)7D)!;;@W9rsv!YWE!YR{{1L(v80VId7ybvxXbQ7`J6mWC0iC{&c!Qw;($ z5^~q^!;$h4=hdtC_Xhh9YwIVzB_gq)?Sk9Gb1BJ9u}_}{XuLi19{;x!VO$U%XGagt z{V)e(a|j+f!Vz8Ya#L3(qgY!K?{vzA-R{fb^gwUq4W}1;?eUGLr#O3#lfBeg|3#h3 zXH~A>)i|vSBg^F#q2}X5dnSz6ycWgaZ%{%>Z~9u}`acgM6G$MP!kVsH#QyD7e0csc zipn9~AFLVk^Ygn>{K)M`orlW2ma{WekGQL2{RM3xSQph@*Lt!?SZ3_`Y_dQ6zIEAx z01(L$6YqxUvf7157Y$!2s354NqhrFmn-j0?PtD#xd^sklqjJFwAGQiXd~PgR(p{Cd zN{lCsQ|wITj@JC`oigHhyaLn$B4`*#H{XRldqP<7MW(**I`o(95T)pVPBia`l0ngX zRAFWXkqyu8PrTRt3pasDF>cv05D%Kaek_zJzp&dP!Mc}A;7tXEbYQ;SpJ7|kc>67x zN`^+n?+f*DIR5Jb@f~9rfcRwq>+X2PcJuOOQ-36m9YLKvkd1_h@^#lRnwUv$p690t zQ$@^+UpHVUCtS`NQ!ky7@E{q?cvST8Qdcd0z9 zBZ)K5zU2@H3%iG?SLm4;6LUK}Al%-(R+VMb)I0GmSXwpWGSKdq5uwjIuwdjbYwblR zS-pP9(&T2)^Tznt+K=zw2NdrQl#k1lzb?>lB^iM@gGOw^fJa~Scq*RZ>b^;$8*LoF z)5mzVn)x!n3~K5J1nT39B^`;JX6vswnnNjw+Mmf|GE+MJMm#X;=y!2iBBV>V@u4Cd z%4FeQ!_D%8f7zl4P1_NZVu&qv-TcULQKNFb{o(iAOAzQy2HSdK36F<6IQ2Hc20?kK zlKnrWk^BYH)+Bd->z|({(kW!`*sZ&f9a6(#A`liuy!H#N^1?R(V?zc)7bkR~-7T4@ z!oMc5Svh?o#MAxIH%{~TQ?gEE3;e2b^5QGP%;>fC!U_K^=4Oz z-k6<<>lTJLoE#cXuW?QM!$R{?)#vXt9yLdKFT}|^oo>M>AhUj)?|Uhu92PqLSpO{r zAR7Ci%77vbvpnC?bzhNh#$ zZr8k|6)Lcmwb9_(J4M}yV@0UTRDm>FIqF0!F>W_yi)oFG$XY&ETuaeHR`vMb;({kY zt(U*;-o~So=+71y!3EM+VMC3$oL7a-jBenbs;Bjlz%ub&F$H~~65xQC^fGi)HLL{V zFZ9G%|H%X}uSm5OV|{SUL@=gz03oSI2QWv)Z7GI#<89eE+i6@AeGM!pNg;R{XACIR zY94!R&U1B99IiTkWiw`rVNx_PX>Mp`tDEeU4N2s|2tpt~#rj#7d|!=uYwkz>#wMFk z{lg%ETwL&SotIl=lRlY72_f6h-t^edvNDmf0S2i#aEFQ|Mc#o%;essE$8RwR;IQo56TBw8R|Kb&vsD5fsucv) zt_9oNv9hv?Z8rwS3g$_I*=B>K%Ymt;#ugb7mmhtF>K^SzTzuI*VAqL6!oTXZ9T$7@UnQgY z^{})C!!}u2`NQcgf!g(jymqwEFIZ^rUX}v~Cmv;(5W==GWJIh-qK9wYEM+X+ zX<6Cj*zfn-=$Jv`;^3KrnJ8v!{(uufq(f?22|H!Yv2M|(b3z+ zz5<<>*%i6n#R#M@fZVQy$feZ>I_yv0__qA%CL^iG}9bQ!62_{jBg};hUOO z@(%QAF&J5W6?=e;3=xoW-kNTHwE0TKqyd!Z5JVj&J0}k;#DTOk^PfS?FAuCFQs}(C zEyjH7m)!!upT7=EX}Suq1qL%fg=}m8SElmsePt`4=$4i6_{^cVG&A-xl}DF=;<;v_ z;Nkp-%)}a`M=L{jx#1?{pweNM>|wnR(Y46hZ?_{Q5Nb7(Q7d0OwnyS}(e4#+YpQcc~gb4s$+!dmtRk-0>%9B#r$`_7zaQu z1=h+h?iI$-ba0@umnwNeI6%yx2+T5+5EXbc^SrYK)y|fi1M)}PBBKr~2X)rg1&Jjw zBW9+i^z+N}!&^mS7u}s&QZKu7e`HN;@niW5GwaK{8u&73fbVgK-LvQOjLdGzfr!VOam)p-#dN5g&=_sR~i3MKh zEQekA#%49)wU?dtx5>rVD|asa`*uLDsE;u{e|tqAC&BVKP@A*hS}&1XhZvxiEDoU! zI zr9v5r4qf6agB%M6REH{9?<6QT0wSubGZqDTd0))Kc?h(%hAO@#x?kJrb}6jcYG3u- zVzjrUXDIx4%LXhhd5cBaZ78g-Ok~Z}qS1so3!{1BsfEWdFE0q`cg2lrt;eS3p#T{q z8cxX6r}Nu|?!O7`F?<<_rY$33(!YbtfS%zgP|>zTTXWZonJ;ZLx61C1IE)!gy}xI3 zK58UeQ(JGPW_$2qhmiYd{0Q^yL}vs~&75q4GCy72Yt7r~{3d4R=H>yO2dj9gM960BrPQ^nBgJzY@xRQ+iD8!qDc5PUycm16G*OqMe*| z@Gw_(wOhH%#FN<}ALgl_bsTKYk7@*}7VeuH=yx)mg`g3*%Czv|hy)}k!`&JF9f*NM z@E$b;VNdHlPCD?f(C~M&Q=f3+fHL9>9wNG)I)w27H((;LatPm0bH0alvhdoPyoY{U z99Jk07njhs{`n)unAWaH2J&j{)eIi($of^EczZ;G%kqow;W1?Ps>;d^AE^#nS96-o z6Fqn5zEzLy9g29nl&A$yu_>?r_5c8V9x_-tgN%H>%Co5G3|>bd(ngFj(B&dm)92_s z-L=?=w5<4;chk2X!>iCl?Y_Ukov={Gn|Vf=Xr+V~c;jELi)wviiGWJ+s~@my`s<@I zye#jMo94aI&cIK?Xc367(YyiV5XsLk{85lGmWq;HW(En}X69GV)u$GoyJ-|7>orAG z6cJksy{5c#Y(F>YG&oGiJSLyf$>pon?K1cxFNo~)6WvV|G?Ol~mF~-U^XARBOqavO zn7Z9DzXCVi#Sa^YTXeq?@87L?*ja?aC;hq#JTC_C`3tewK{2>I^sCLb3iInJ8K$8M zEt4x30dQn&TuB!|oseHJ;z{C0-4^30R9k!X2{SKQ;DEf}*-`}=N=KT$cDyqL?}9cY z*p+xh>2;mI3q1T}`5NAu6kQrRq|c58>?5%wY!hAI=L%V#-!G_MuG~-DTh8U=;juCP z;8-^TH0!bpb93rd-&>Ts$+N!|Qy1ygw>l>XxU@eLSSnRk$yO;Qc&Ne{l?ps-bg4_s z;@WOYOx?b`SBuK(lix%8A#;&scTc-**!tjVL!Xyt7X|btRT#F9f=Fy+cp^|p$M}j8 z${W%;A^@^@5Limlof-^*61>NX`}+d%3024pq~P=Zk|#VL&EAvTFu$_&7>2xY2Vy6P zYwf)~{QY&P$G4c)7?ITm$Yp`5kUSQ}n z{qA^%1x!SwH%CW*HtPzoc*DzEHf$B#{C*nJ&(0u3vAp>)_{LgsbiAgDy|jAEcc1k| zTN0HKlaU1(w|{Y%1$Gv@1F>q_q-#|nEDqbTc5`orEb)QmAI&n280Vb(!byNLehlUr z-SL?LOH9G){*khkaj_(fuauK%Grl?7wJ$+|9 zXLCxTPbwiFnHIxk)Q;7tNXx-g^Wnr-cTcA=onAa~jifiD4;Ne~8lHv%mN`JPQ0ZUy z8Zuk6)?o0pJ(i53~B8fn9)VVE+G_J7u zrNam)ala@bl4$K_R+~JSVpw&{=0jL?KG*|v63ZZLpN3e8?$HGsQKXsfMdFTCDCXJx z`QLmXV9CioZNKm~z+?FltLF?avR>kh|C?Pz1BRehDcuM8L8)w&K?VL9i^78~2@0>p zHTsZ}gV#=|Riwqm7i(MP_jd#Kv0vULfpxCu;LEu-$_XqDlhw9zCGT~){3xmRTzkf4 zvF!HfJB!)x|D|JAIWm}BhXUuqyzadf&rJznb|Cd#l9zmPSlpv#BPLIC^WbvX0~A0K zlz<#anX_sx_@P)PNSSvquUMvM^qWlr+@P^o{>Mb857-5YTw*%cPdABr1uH48LaE6) zdR-}}F2NeJa7I));pXtZQt#S&t>E}Z=t2!O%ma)kD zN1J;@i|l3Y4+yNE#+5xGoO&M|x?FdJkN}>P5~!_sZdsy{VnFr5^|$v^P0Q+OnDoa^ z_|24mWnudjkjKyAGUghNL=4+vG zadGnu+8edIdwXd=Hnv~BUOBvQO>5&lmpT;D9dy+_0YJAcId0qt%YHP)8AR}AYDp#cXu}kNFBQ4-$&H@-TVGyFdW+< zp0n3lGoSg)x$0MeMh^gzzt8jY?cdDizJ?(gGYaCBIc?PSRu?~`Ok+# z%aNi|(qBjqXv29w@=QP=8xSuvl#vn#@KF9*=+>_4RhQ7~-PpUGIvQu?#gWm`$l`an z`YbyA8K#vp6r8$0N2`1k=X`5wI}qtDdS7ntayWMhrcV5s1u(eFJXt)T1VG&16oW>% zPlg4G#?&>p@1JJCjqYtBTFys3IRHJvZWhQ=6F4hO&R_w4Yee2cHFS)GXKbTQ%UoR@ z=lk9tR@7^A3bGUKRaNs&bLWkBrwmIKc|Yp^`j+45&{xUj&X@9bGLfTI0t$0kG)yC? z7g7A|YBwKpQ=JYkH0%-@fb?#=(iox}`7i>9$H@X7C2wuRhhXfD{n_RwHd6aKwEpJ^ zYY~A&_Wva1e-9G!puG+P*W3`@TSCMUkV26~F@(uN?DA>Xs(=COjXme>Bo6CJ={I5m z-5$+oqWDu4+AW@viHT+Qq~qI7GgvfEer|VV&U}$j#w7n0!<`45F3ZZr)L|CNhaUlk z+A_(7!pth#_`>T&Xz5wgI-Wc566cGn__G5pHH*x*luz!+8Y zR&!kdk0!s*%xZ+C>Dk>9=2M^?$$Y+e-M%Kx{UeQ~i@NdzuKuh%N@jO=cPrQIUNv!c zb~fXBzYctV-GWkFa^jZX?%vj%g3J8hp|2+rygHV!)Y@F97FJ^}I5GX3j~cG$ z2i2@EyG@1@z1BFq2hF5D;_ov6QPk94xI`@JQ+ctePpi4|-)#dF3|ObJufRX^IG^Hl zA5C~X?ZN;Iq!G4Q-KUAIx9jXJ8*+p z{L`&Cwzmw!4E7qP>O^OKPXkFU#@~tVRbICTY?@b0D80*)>rq&xqZ=4Wc#U$q63S(E zU&1v{&MdD-`S053zAUH8*CnaS5?I-Ew zt#AB88`u&v*M2?%_{lGW#Q!(mdJ8}+5dk{rf1wqA9_YyKrxrUag}^}qE~>P6$U;By zS9uK+ZZm4LAWaxQmbI?yF4q0hy`ez4N>MQ=YbnTsZ|&KQ%&hkM;QUl zA~4wW94GCMk>i%emhSsSV#UFDmL~kB{889Ng4z zHf@-Lo?<&t;6J@jJpAF=5OZ?s_Pyo%7UcfBOtflk78*9gg>73LUK|!Ut*XD0`0&7A z2?HdlXBPqgzuWRWtK*=Fu49MPEA$5vL=zGdnV*J}MH`+k*qbVMag4TCS+b8-OxcP(i#AaQc_j~^iB2N@;-Hi}(3l70Sr4?qF%bU{!!w}eUBzZgLw zyf`eX(!h~U>a#hUIFQVe8()~P-Fm-hb=Vj$Epnhoaj*zfL!UYCzjl?VNosIH1>nt* zA-B7rxyY~gSFawA{!JZ!r!}(7o_JhbIKEm+ym-%P*Dbpe-WcanfOJTApEey6Q~>fGzlaGdne5@E zgCMOYfPNi=#K&q88_HZ8tT(#e0G}D0&hLpBwP3fiM^q1Py!Hc5uM5>-H&L_B&a}LX zP`+x({r+~5@vPw|i3tdUQhNT%KbDTiH8$DatU!S}9-%2O@1+xv-O=!MQgNmdfI=Lf1U3YXp0N6r1hKpmJyF&!R4#~{Uo z6P_*bp&i6u*)~$$ODczcfegImUmOAQz^?>hkwizJ|2Iqg^<{YI{%Z~zD=AMK5|5|u zex}|n-8NlKG~CYu{`&GQEG%s1?b+PsiC!3w(NI4nDd6Yp_XuKX0cK9U1yB#p-kZ$) zJ~=s=TV?-)07vt{muNhb&-Gv54|z?TYPZpoWJ${`HFoW;h$>wv&}#se6_+^1F4=aS zx0onLLdnO3Pnk$gBPLLE$L{>L&RPyv<^3Ra`{?^^LNsP=ur z@h}d7OIR+^;3yT^FMC8NApd;8?U_z=e-Y!Z^*!SpWdd=tj5`|WVkju6+xr?7+Qic5 z=-;pb${IZDF;C@oJU28n%-skH`}jFa?&Z}2I3?HR{(9+NU~AJ}Zzi_#uarFOvF8Z9 z`qISf;u@pngyCMoOp~5jXc2l;w|-})fDAVJ?H!Hk52t~tVfExDz#51vfEgq;mcQU|aij?vCKPrQ5-w;L?``|Mpu@ zAU!J7(EN^pAGvDbM`^EiMaH06DJ>KMzt!-yD)~l{k&%ToG&G_Hc{lr&H?2&f$G^cybKQqyw8d( zvc6dR_I?`-4%@Ha!68Bx=i}LJx0X%QpXPWENnl>0!Qm(eBOZ@4G9VoX=(s7y;rKX) zF^0*A$F+6`@Y^P;RhcSQec!HBTG+^+)3n9IkBwr z^ZQTv)(I-AOU}QL(02z#)G72%6!obL_J! z|NoDex1u}vDdWC+&3DYHqz%M3<$zQS9DI3l>? zQpS7xxF-CK#MXN5ei@&SW^l(`t@ZW}W-k~&d2Uyhnc>xv6y97jDpwV4vnnl2=Fh3y z&J~z_p4i*F)+shi9BZ}y-95ng1VS6556Dy{0t%1*8PLJqxMF|1Wi*# zyiWrFHh8{8^afWjv~;bDg(8~3kqUaPz{!$#GOt0xma=NAYEWPkhezj7a9(gtvT*ZXkFh0 zVilN~o0#<7T(G{5&LH=rb#ryTKIw^<5do2+v#$jo+oy7V-1eDRMP2b8MynXfjm{VT zIO+XUi}$={TVqm`NfBdEX_T~QloNOz!!-U2cS+~CCQN~9(tgp<7hjCOds>jF9i1}T zhh-2HY^bEwnkrO9Y*(UhY_l?t=G7K0qRn2(#m$M%`ky|$z9%32{P+w91HR3LuEPet z1fK8$w7}^lW!sz7e=O-#ksbkHP|^-TCFU-0ufw#}4G(Q!n=5|)yC=UNJn<1OUQzgc zriS1Vf8^}XgAaOc`wF-A7%*tzeElig{KW)iii6cRgNmGo8y`tKXaov2gvI*1kGut^Uy4mpu9F;1md0=5dKI5y6shCSa zD>=i82!gueOLAw1pF6jk2kFJ5-TWsIO>#o;2A9Bk-y!E4q}uN86mp(r0c}ZtR`l?| zuMY`3cZcEs;$vw*>zsNS#TuS)Idv(hOz8)ovMO78$M1xRmzjpdXRj)-x%o znYqySYHAsE;5)_pFn5=^rLfSxA-2rpGRO^`thA`~Y3y9})~<1sW)1=G8fxWLuDQ}t zU}{7<;!>lhOc9shpY5?fQB|y3*_kpO(;Kd*_~l>$7N6OCkwI*)>`_tpii!(GKSNT# z2BvlgP?J*n;YY7lST@NH#HnV2a6Yi?)4@C2U6?f*N@7C>F#LO8(z-!|{;n>~GSUG8SipJ%zucX`PbIlwJ%9XU52b3+YNrbzo2Q)1vEHjg;=0X~lswqM z#ZCWD`o!B22i@5jTUzltuiHK`s)bAjtkegIBn6k{CjMIOL|x;R|RXaKTd0-e)O zl+0c?LAAY>T?AEvGBW3R7!V(z%f)o`t8z2@!D2j1ETrL_BzE?yijK9(|gIBr3p z$Yf!&)eT^zgB*sJM>$NG)v}Nz#l&;U?@3jjZRSf8aQi_6H<%+kSpC1LB>yC&C^+jM z@V5y}kbi04tlnJHwCuogrBOP$)pK`uSD^lQ zje4-WEL#qCv(9O{=7~+dy}`dt*7CeXQFoZ0cikX7>t`PNK;I)l9sm$4783#d_x^hA z-IEgBPAaG(V7?oWJr>ptH>GsYPTH5`b~puqcv#coI-E3w=_Vx|9x@L+wCeAfJDDr& zt44T^bA3QFAF5mU_0(NVwrY^_xm%rn$gh^Z8LV9F^6qN|I(hoNP9ZPE|Qc zSz8|mE%lBcAKZU4Z1slE(hKEWEl)n5x1M_o!!R8I_eFmw&ay|EOWL10x>sz{e42A& z^;H<}mEmQd*4?O|AS!|!%O^63q?pOVzA5y_i3zW}9d- z{xw%PbN%#JNR)?DotL>|yW$sFl??<``WnmWU%%ArzS9El#PD7$N2$t)KzhG%i}){6 zZX$;}3r8xWB2I^T#gbb8CvRgBYKC!ssx$TSzgq(l?$_x4q(07fUPqN5r+6IJLfABc zxeq5e;E#JgR^2)h%3V-kj{6eLgo^17E^bdmdWXJ%>peDmGwiB4NPVqx&dq5L7zlLv z-Z!@57oA(X5LynXsJR+LR@Z%~hY+Y*IHfqQ+u$wwOSisBFJ}+t`T5O8rGf;s-@-($ zFZm^8#7im_*W10l9)Z-8O35wWRJIZ*mcx4MJ-!afhxw=X`j30Eg7i*=!YUj8Ro6BQ zf5|KhJwk}SA5jjEkK>=22e_)=`6`J(!xiFCbxhpOUl|Zi!QX5Fl!~^aA1H;UW@dxs z;uX~``xun0wl;Q+j{2At`kc>N%q7x(v}0&FZUEJ|QMEh;)(Z9Q#ezFL=Zh85Cq(KM z+r6mjm0mK**&cwSkj3-F#41xs4bQ;dA-B4S%h1K%vBj!TVOaTfJsJXog>@HUS;p6+ zXsW<6SC7I2(s*MJzf5*syTk2h1N_OkYoUBnEXc^kZ7S488Zdq>S7oS1c6x#J7^*k! zzr7Z4U`Ch#2PGu)#s6^pewpWBx#gw1y)hcM!=SpRxKl4|Mc=y$lT63!0iKg@RgJbS zRH}t3a-N7wmxHccoO3veePbU?jg5=~l#11C`?%LlsC?VJ%@-0}LU=TXh5cq#kM1BB29@V6iKPeDJp2Iz0slP-Mx$MAag!zoZdtGA(Mt_6|v1Koo? z+W68*-@;7Rakmm5dA`E(Prb#D4O>vh@9LSY{xS~t>A-;R`Z9;eVY$U%cDB@YP#ZGV zVac`XA~%-ca8WxdtfhE_crz>h@y4$88R5dhT!{u(c;1(U1c{N%FkV)hy{g7rbCQFl z-(>+}KhR5h{qLIZ-vynbb2z-Ud=+$B3lZjnUl$elU{t%s#?O&ij#aEM$~mt@##-<| zyI~+N6E*?4&N$HiabHPDunn2Ds*0{+Z`Qg~ifJ99n~XZ^Xd5y+`ad3*SQ!A)*Nxf9 z|FY2;siAP3!vcr?$=H8lT+}ty-H0|6DBY&XAq1KoSWCIHy3lWs(TR*PT!3zcN@S=|dSXBi1YAxFoD*meWu>%u z3+HHj)>jFFh( z#aE}Z8wN_p3z6hOgK#yKpUAWr3}lz5^}^iF37y}X;!(#kW4Y#Gipuca+Sts=nBQB# zxe&{@AVOw_b6|AK0!MrF%T6up`TpBZQF%A-?`hm)qVr^+_DGbbfWmx_;iVCLXf<7z z0nWu#nI5EhnfNmhQ88|)`P38Rv&Cr^bpCHoL3a>;<&gGZA656C@w-4XNj&&2HHCxd z?uT=NK9Qwz>9uCp+0yAL<#SZu|I0dah~UpFugsp{xVt@0z1yd&nzs{`lsq%xR|ryj zo5;G?Zx6)QWt#09Mj|jVw5p>G7AsH;CO}TC{sbuG1?|@#7pH1E-<~cFs2>1~I}iR) zXeNjrH$wE7=_Ib@-=@ln&O%=F99Hn>9NRjlc+Z3uvG^U=vrj2CA0`6ti`_S!0N27_ z3Eg_W5sG>^`bk*h*l?)CG3fdKc$^RF%QNrG^|@hJ{sJdRg4%--IF+$6ji;s~l^D{Y zRmqGT^SzwZw}(}(4Gs2KjcLLc?<#sBfhNFPiln%%ntz(_4N$K<`E&1+Pi?pDP| z=jN_kmbj0$*z9L51r+FG?{z&3>ls;CFr`u#$GEM}c){?mny6_kgRIv;n<>tBhkJVj z8jl}8#?zwm0kgb*EgZ&oS7+D}*yw(>@_LF}X$`f_tSH;o)EGZy1CUN&{D}oOcolWP zZxmzX8)+VPh5sshqs_F5TKYanr!aqRmfRLxZAYLKq=w|Zw?||=^)=>~Py_vE023(r z*`1a$kN$@jvNWEQt!N2|09od;L+y1gTUUf*V#evex))thp_>g%4RVC@5D9%GSeH_J__j z?+aecb^kN`X$^!BWoq}R3FseKoUbyTkm(FDncFQj(gMtf5G)b`b30X3@PRTMFw{8P1&Nl z^Gmu(`QRx7`$9EQZU&SHjG>siZ>8D`NAYGf-f088CxFhwSo$&yM6&zW4$+Y-N z)&4QE1Bm@x8>K}XjmHVcRX_=~m_cd*9CcWnTt=PlFI*8PTz=PCwNm+Fg!G(m;cWb| zeN%47XsZt*B`~bRUO8AoieD`DK@d=8#%GqIs$^Fftd*7tQiW~%h%a#GhGwO9NmWb;(2+RTum}2y?$#0|r|lnEWw-z>70J_hhFx-NLvrOt?9&wO_RCQ>?mMue@$ExZ`Vz>ELS( zhrZqqult%&mh9O^YaiSA;>_B?&{`5X2N?FZ+9p5#$~mT@8J^^|Jku{4$qB# zVOj|M^=o~=tcm{MjLCJW`-%otQ^b5ypMV(cOPugAxGN|k_q3y*Hj!l<*w&Dihuh0ntwv4N!i|*xtM^l%5cP<8gkQY%$4^qiM65XyzuWbWEi? zPgH$#bj!uXh3yMYiI;S@Fr>QbSg^l8(BeDIb7sP+hcvW=>v(uEP$ja7QWV$SqO9fss7F)8gGCap&hi zI}`sKnAY>HBEjt(9F|+DtOc}17vZ>)#c_ef|1@_SVXK@sxNoAa9d8n}9#?J-6s>?` z7)zd7yT_%fvhm%6w@pl1>t7@x9@;ptVEucRh^Gtuu5(KcvN$ISJI##IwrZAXWk{rj z-dr!XCW=DQ{o>JhzG2;ky+KT;9~f;VICUFFXC>&3Lm~IwxV(%zot9cD@T!2IK#sY{ zqm`%a`Rx5&>%EKK((PG;1GwQVsou`?^!)QD>4_k2pmU6fj@O~(I|JW}H%;U5M9Cdz zVmv0pcJa#v_lmjp04deEJBcj0lY=%CzGL(IDY52TS7UCVnmU8n`#=ODAfllrJ%w7YgX1T06Yt`K6z7MU|56fHF zG$2`&>R@MQ$F;SWiFa!q5lux!P`g>njycujgbwA{_;QJe!g;W@J^k@lj_PL9XR1|m zwOukF55N%+@IM2N%J|)v2*N~etTJ3Y<)Q~nPz`~0XN#BhhVS}w#V7gqFc@MP(c*bl z+pCHNX7nn*#^p4tAk^#7;te^>iTV!F*ZJuw1(q7P5c~Wcga^q}>fyY>dBA2Nwz+7> zZ5AhTwd(QYXb2iiT&CgJK5vzD!_q7uY;v_jUdoGYGJGb(ObsMDBCyia51P*Z3P!*2 zjP#mCM$5s8#qugqVs399K19KGntd{ENo%E9O6>%Ng6DX(Wywe31 z5;0Gt0lGe>9RIr@0p#o4C}heG7b+I3o?JW$na8op_jF$=@gpA0)(GPK{3}~G^86cR z!yfb6%uQNjM6F$Oy5y#lmPN`S1Y&bQQ^wVZT~doR9hgcc_cn4HwgVgu{4Vb|s3`OP zNYsN<@`Y{%?k*6hmTaqM?+NK4v+`=bj>D0RoBRFz3vNveH`u0< ztJ;^&Ah-FR#khdqoncgI&6<9VwI=)5=9eG(GRB(b%BQ@lI_CE0W4uiU^N;4WEBB zIep)7W&Rc5EvU^@ZC`_3!FBtET0>3{?A$W~p|CFe{wSh2we^%9{vKS2t?PI9QY~6Ep0#e>2b@uNMw5wD#A_5Q9O?GET|{lIM|A!pYYS9E&=}peL&A{xZpb$^>{L%?P&=4If`o<=QT;au65U(Njd-~9O`U0? zB}N2MZk_ffrqtil-BsIRa7=C&k(o3-pQN_jgX~ufXd(l91=`m*%JHRwES>Q?IuSb~ zy5zt`CB`Cbgq}WDIfB7HQ&Qoj{2#y$dEUT#>tX{#5`>o!a;BAJ)Lx_E7B|aCh+kG9 zUSB0Wex=UQ2SL4=K`UIR-ru@=5>@->-i>1vBBLx#m3;m~Yc%}Af59!+;9E}9@9gau z%V=I^ws<8RHZfIDqL|Y)IS^*H4(@6*NJ`)K`UTPfSP(KqT8)5nd+?!HsykVL^%qJR->G~$|+4}EtRJM5*OwHcsy&<55+JtU?~Bo^oW@kLFp+doVEv^dUsg_^zIM)8w} zt~L?uCLXyX2f1ynCa{DAs{jr+s(D9%Y3=ySFz$wxnc;h&KL&adsBS|f^I*3Ix2Q$O zDXu`6Cf|DKm@vn?DX~?(@8!*SWFhj?J8;m3me11Gd~kNmC}e^V0O_~7In*5}RZM?4 z<+}0;p^e#$P1TxT9Sq-!*0~!xxKDSQFQ*tkDNpr82K+ zaS6<2mpxRklezRdQ!t*u!m?esscF&r=rT0jE`T%U%$oMV0>Q6ond2vee}(Ti@IVyN z^r}c$WTmV`7rVmachwYE4`^^%y+_o*XX;!q@EU>E&t;0;t-XW#+`i}Mrn zfHt!zzl@6>^;*#C=2#?cAC8Ms^Z&L3fI1v^Ad^gQcl6!!Id4J{30G7e#xF>vWm-jl;}9KZp5cYFVB9pkof(SB9^!WY5q`ULc~$A%5(BBhq$YN^r*; zzNJgPIMnfdxCC}$XbIa>1+UW{&O_#=48PxA`2rt4{kj2{Y7 z<;A$X-$~z4)e7{wMO39}k1$2JbTTIrA+x^v(wuqI3h5luJIfmQ@wYN1jyH$5LsAkF zOg4B1Jv}|0yBxBYg6nqq@-yqYP^>s7~3KLck&s7Rm^0W5Q6zA-B z&>;R=r-v@|!2-k5Wn^`ROnP}&L7??gM-H|R6Ml)@vYQb4dlx0D$YtHsU2PI5E_m(v zo)e?X-E!Y@PcihEZ6CS4@N+BLkEb>!@gTCU_eae$3x4&zUMZ)jj&gg?#aMZ9Na{<& z`2(OCQ+9N_RJuFDZQvw(pttpodBP91&!{ztIt(NuX}`0-^?;|t-+z=q3E3IQ&jG6^ zlrP$a=}D9C?|5A3`*a5{Jv^C`^b7>&(5mgnW9X#A!>{0*G4~r_h_ykFPA*9BG3uv z=YSIm_CFksky5o!GR3{pT&ERnE|h@0HZn$aug*1RLKCJmbGlC`&t}?CbrQX3_{ki7$i5rGeBY~vuPvfI zs!>7oiJaGkS(ogdy7;ud65Y`T%}BpZeDj`ojkq@00L$rZBgVS=jU3~br3B{#$H*l@ zY(F?aD+QO0Vt(tSSo1M7D7o0}vYKz_HBsttwWN8OoE7m4$)cmZ%~b|CfOGENju{I2 zIz}a7ND?EJYCe~rCF$7Ka%YwX^IHxcq(RoVx#{k7d5VCm;+mM0bg#U@`J8%9nKl&q z^P5bQslntPEmp%Q>HHB0zp!E?w9-fbzSa; zbXdluzl6*p@DT+ipoQ`WSl@!gsR1qI=Nta>&Ftu&mr_j9{z9!o_<4lqQO$3l@0vgO zAzquQ51FvTzIm`!-+~?umVETQHM09@|9!DidkSwV=i=K-9D6Hafwl`nud`cXSnTUw zlZL>pLjL!TYBgegg0{^v;&ztAEge?%sfZCmIM-$HL~5z-QNIk&m()j%CSxNKkt)On znIiS3=>`5r zrMCp{y959Y)J^YX{YP|nC*c(DdE3Fhc|iUm79>-J<(qRm-+j+T!%wpC{0vuzqi)UCg|axx1RNY35n+6nt2G2%cDsQEI?o>t^jq{J3JTyri@YZkLU)$j{S4M7 zPUtC0D0)>w^T_cc9!$GOEA+-!mOa#0tz!pNzN>6ySZDFY98$!kWLs>aNd0Q5Kgub~ zWgxmp_`-ri_lLRdCjz%;39r(HKkcedB8)Vimf6|;keMV zOD}A#DCqV~cKK!D(b<`xT*4$qza0}twy$oHR#|9-B>0Q1;>;ismaLq9yh(BKQ^rQW zAc6{h>X@;k-3{YYQgK%`mTVr0Hkl?60e9}vQs>|b^P)#<{d+AfJ*fw;{tF ze$pAXath_*Yd32Un1Dh~tm?1w*B1g0tNdvTmne4I>^hSQYZrKna9{0lbrpn}5PL#! zhx*P`HVpO`jB)F#mP3;IaIo;h{f?}T7O7@i?f*IcUp7>elqeVMtWb;JFp z>*5evCR1F^cqssb@@#a(z3Otl#yWP+WFp^aIZ3`?7##y6Bzmc6mdW)Bhr#3rd-B6p z_yej&F80DB;GN=R=BUHXq(tkJ7<4$yQXQrs^l1x>-zG9wNZZZWm^AfSg6H*SDSxOB zbg0;)F`|^&q8wG;{4-KQSD29zPmgjlVn8v$c)AVBEX-MXfQwnh^!PZDsE==0!L zF+mq8yKwQr3p3$Yb_^<1h&@w*zQ2@76)J7S!Sb*;Bo zd$4Ut8zkv4+4lGftt(<~SrYIj$g}G;RUH8i^e#`{{$Ixj=czun+1`7fG{k#-)CAnA z)t2YADB5{>2_q8q<;&NT6aAwvG@6g?E!4GKeom(^)Y%*1Ao$>)WZY!`U`9pq4NjdZ zPA)eb>DTx%)r|ch8Jwuva)<;@d8@p-M*(D4+Dt)#nO}ihv3}XpZ_&-MwsVRhxOdO0 z1Cn(MNT}`MJ-Z2^nevA^3%^sAXax13{Bcrb7SBIrb&hD3XVbS3w{AlPgc`!)6Lp`2U;hC!wHOr z3aLvX_c)wEWr7=hHVWMeEi`BsP*9}j5+4rS`av>`6&^(L_7OB3Ip*a+5_E*mH8ZgR zKRZq?w5-{@cVjWA=J|^**+>>i^kl{w@plGn?Q@C5eJx_>&FW89?8VWDOc&Fa*6mj$ z*z2)hY$9?a2grbX9Q)jfmpt#AFXB!rvF<#a>+YZN{1)PHj}T~1WOmZ5z9J&NXq&6Y zsZVB4h|CEm$T-lw-@u});=_$0`2~B^^#%KvT)0A|4*7L(wx|M@Y}zrcm{NPosIpQAB_0r8k2u~=P_^U&%DYXWiZAaK7%OWGmpeh#08TgjA zCX4!JHj|ju%s!Q|3pU%giTaFmN<3C!gLPJg^+lu6^;0T`3Nwu_D3Q?6e ztrR?c5D9XO>iqSAP&17X6K-pi!)3>tqV2slNtDBA_uBAB#gY@B=bxyC9w-U!dzIVh zI+nQ^+biUj<9?nKxdD8)EVMZd?oPV`#w1=xNOUnVe1mV6e;rQ%u}vQ zRPo+Yq$Ae#H{H11kHiq5t&dd1h@AlM7fl?S>2t&C0?k2xHJMWK6V{U?+$elvnf-a> zvLiJ;j7MY9lV@QErNm)^wE`-=6vI$;sXm3Ubvq=HZ^MKigSKcmSW{pf5#$6P$1ZH? znn0g&T&<#smEt{CAg7=xm(8Nwg8h4@CU7i!tmWc<@3WVTk#D=~BSJryuozF8;?naw zkZcN`{8()%Z7OL=*jV-Rtj;sIaM=h}EKvHv1!t4L?|L&4T^Y*RL$dNPNfRb9DTISg%m4 zPbax***;Al2-$81#o&KQBHCPE7gBP&UkE;5bY>`6SDXJ8M3OC2fZiIfWG~VN!fe95 z)qm&x8T{Kn@Ed`iCVuS^T4<5r65sqnjQVQe<@J$u=zePQ?Pql45%^!>H!f6?37cSd z7Y%MD?JTvDMFS-UUL$SgyJWsvPjZ~~yfLB}C$Gjm=y;?oJYp1qxbhAZrw{KRLAhn`0zR6p*QPn z`lLdUn*E+P7)+o@UsGB#3tXt+5VCH%X_6+CA^s05w355fYUw`_!yhA_7qk}#(kZ_1 z7!sHACj&*b3s{wugi72QtxD=$Tr!BUsz`edF@%jVp-&xcwpu4T>PLkz^64!fb_|9F$tE{ z@;LTu?-1Hfeu%7^)ebM08<{u6Mn^aBlDxV1!@an5%ar%C>(a99m{>?&{rR!ZbhaFS ztlqI~y`H<_h(dxXc6awF7opqkcfW>t_uyoRp8`4r#OdZI)~Y85K49-}%ZUj7GW*NA zpksMvLdF*xAL)@J(p3eCQO2GZ?^cl<-?YqC?p278S3D%Q?flCKEg>jdyC|@qV@&Fic<)?x=*(}h(sJUW)!|Vdj)gzItsv1cy?__&^O&_%7 zEUx_u|H!->p}m&i2udijHQ4vWYuqbWPsib7di1trDZ0z(kkb%RuMy{gZll zK$nva*Pf1u+TwEkSnc*MiMirLX_(V$5~txtnr0LT^zkC)yN|*0eMV2U5l2?uJQmb6 z_nlOR9=hx|0PqkiK7x0M1DFV7Y`{pFgSDF*7w!Yu4YZ%{5fBi9gM&}h9zQwZLwt9j z=73*Ux)eaEZ?m(wr%omloT+H?_A+8vwi!uIKbjjyIsK&k3j;XUUI^_R?rrG*~^McVir3tw*%p$||uISnd7j(X6rf&h*E=K7z+2 zT{h?2&syopOo_wZvYh;&wKggB)IAbyP?Vr6B}cu#DTB|#amueleS>Ic`TZe`aH$v_ z`m3_0d$*Cwj3CFjoO3?vn>q~+D%RvNy!z!e121;F7x&+i_-nUS}`47*^f?=-#7^@1g}|44qfA; zC>yRr{Q2PRJ^bMMWd^o_EVNE!yOCZ$0ma!Jz8N;R*#n5vrbq)b-Vdj%20Hq1SUZ_t zF7!Tc>ew=w5*Aytsy*;j;={Wcj>&?oP6xDR+gy@w6-Y(F=b^2UFTx6HCP0TkJ)AB5^5kyzo2FRw_$3tOZy@EI-4nwx`GrP9Hh0 z2}x%Z2i6ID{<>|~xceh&712FA|1@^g5f^=rwse(n9c=VA59!Qjg3fRt9(k~MNtDC$ zjFFt`7ei}Y_pX;o{9W=nmuj|PB6za9Xi9+!A#9&&G6UOIqQv0llmU_UO@=3EGW{Xi z5hK02csy64?ZF4_!1zf9kW8|ly*g90 zD;L}xOh~yLh%`?{A=`4-Vq;)f+M2Df9>@&)>6V-+%k!aLDp7Cj>Wsrq0u(fK%$lAOZzs~=Yn<;V+%Su)$>?1ymGQ22RL*7`}pw2a7rC( z#19nfAhFl}%97;J^zb3sf|VWvYvC!HJ}Z^gBe4PD*Qir6;Ss2V;`YT+1#Ks7;oxD) z&&k%GV7WbIAE+G=M5S7lNy(p_{qGgcUhIs20wF5 z#3n39#?_d7*4e*(I*82&-R^l>?0S8)SpM`m)&q3$*Kit&E^odr&>HOTpN$6+jbyMN zCv5;ixVBC^Fx;arhm-)J%eTqA!FKm0pmT{Eo11fK3%t>u9!t|e14haaUoy>R*PCnF zcg(*|!UGvPZd|}mlllm4syer%Bj5cxUhjX?h^*AqzB6hgM%x_2!hO{7yeGu&6zkU7kE&j16_7 zsL_q-P=U)NO9xip8R+r<1XH~P^YRXpZOV5yw0T%7gcyZ5;ZwJ|KW$vmW1W}M{Bi0} zFQ3=Dd8t2+fQh1gj?TYi>oK>)zwf;~!c7~9Y6!!}D{^0tVwCSMlVbPyme{ ryN) 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 z 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 W7+EgNZ1@N8kEHm+yBVU|FaHmWYPz@p literal 0 HcmV?d00001 diff --git a/docs/logos/vllm-ascend-logo-text-light.png b/docs/logos/vllm-ascend-logo-text-light.png new file mode 100644 index 0000000000000000000000000000000000000000..b71b4926773492b219486087715f4b721aa40b0f GIT binary patch literal 156625 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 iU^EvD|6CA}(O9o@dQKW2d#)w}5O})!xvX\n" * audio_count + question + }] + prompt = tokenizer.apply_chat_template(messages, + tokenize=False, + add_generation_prompt=True) + + llm = LLM(model=model_name, + max_model_len=4096, + max_num_seqs=5, + trust_remote_code=True, + limit_mm_per_prompt={"audio": audio_count}) + stop_token_ids = None + return llm, prompt, stop_token_ids + + +# Qwen2-Audio +def run_qwen2_audio(question: str, audio_count: int): + model_name = "Qwen/Qwen2-Audio-7B-Instruct" + + llm = LLM(model=model_name, + max_model_len=4096, + max_num_seqs=5, + limit_mm_per_prompt={"audio": audio_count}) + + audio_in_prompt = "".join([ + f"Audio {idx+1}: " + f"<|audio_bos|><|AUDIO|><|audio_eos|>\n" for idx in range(audio_count) + ]) + + prompt = ("<|im_start|>system\nYou are a helpful assistant.<|im_end|>\n" + "<|im_start|>user\n" + f"{audio_in_prompt}{question}<|im_end|>\n" + "<|im_start|>assistant\n") + stop_token_ids = None + return llm, prompt, stop_token_ids + + +# TODO (cmq): test ultravox +model_example_map = { + # "ultravox": run_ultravox, + "qwen2_audio": run_qwen2_audio +} + + +def main(args): + model = args.model_type + if model not in model_example_map: + raise ValueError(f"Model type {model} is not supported.") + + audio_count = args.num_audios + llm, prompt, stop_token_ids = model_example_map[model]( + question_per_audio_count[audio_count], audio_count) + + # We set temperature to 0.2 so that outputs can be different + # even when all prompts are identical when running batch inference. + sampling_params = SamplingParams(temperature=0.2, + max_tokens=64, + stop_token_ids=stop_token_ids) + + mm_data = {} + if audio_count > 0: + mm_data = { + "audio": [ + asset.audio_and_sample_rate + for asset in audio_assets[:audio_count] + ] + } + + assert args.num_prompts > 0 + inputs = {"prompt": prompt, "multi_modal_data": mm_data} + if args.num_prompts > 1: + # Batch inference + inputs = [inputs] * args.num_prompts + + outputs = llm.generate(inputs, sampling_params=sampling_params) + + for o in outputs: + generated_text = o.outputs[0].text + print(generated_text) + + +if __name__ == "__main__": + parser = FlexibleArgumentParser( + description='Demo on using vLLM for offline inference with ' + 'audio language models') + parser.add_argument('--model-type', + '-m', + type=str, + default="qwen2_audio", + choices=model_example_map.keys(), + help='Huggingface "model_type".') + parser.add_argument('--num-prompts', + type=int, + default=1, + help='Number of prompts to run.') + parser.add_argument("--num-audios", + type=int, + default=1, + choices=[0, 1, 2], + help="Number of audio items per prompt.") + + args = parser.parse_args() + main(args) diff --git a/examples/offline_inference_npu.py b/examples/offline_inference_npu.py new file mode 100644 index 000000000..10c2c6e40 --- /dev/null +++ b/examples/offline_inference_npu.py @@ -0,0 +1,39 @@ +# +# Copyright (c) 2025 Huawei Technologies Co., Ltd. All Rights Reserved. +# This file is a part of the vllm-ascend project. +# Adapted from vllm-project/vllm/examples/offline_inference/basic.py +# Copyright 2023 The vLLM team. +# +# 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. +# + +from vllm import LLM, SamplingParams + +prompts = [ + "Hello, my name is", + "The president of the United States is", + "The capital of France is", + "The future of AI is", +] + +# Create a sampling params object. +sampling_params = SamplingParams(max_tokens=100, temperature=0.0) +# Create an LLM. +llm = LLM(model="facebook/opt-125m") + +# Generate texts from the prompts. +outputs = llm.generate(prompts, sampling_params) +for output in outputs: + prompt = output.prompt + generated_text = output.outputs[0].text + print(f"Prompt: {prompt!r}, Generated text: {generated_text!r}") diff --git a/format.sh b/format.sh new file mode 100755 index 000000000..9ea7495c2 --- /dev/null +++ b/format.sh @@ -0,0 +1,341 @@ +#!/usr/bin/env bash + +# +# Copyright (c) 2025 Huawei Technologies Co., Ltd. All Rights Reserved. +# This file is a part of the vllm-ascend project. +# Adapted from https://github.com/vllm-project/vllm/tree/main/tools +# Copyright 2023 The vLLM team. +# +# 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. +# + +# YAPF formatter, adapted from ray and skypilot. +# +# Usage: +# # Do work and commit your work. + +# # Format files that differ from origin/main. +# bash format.sh + +# # Commit changed files with message 'Run yapf and ruff' +# +# +# YAPF + Clang formatter (if installed). This script formats all changed files from the last mergebase. +# You are encouraged to run this locally before pushing changes for review. + +# Cause the script to exit if a single command fails +set -eo pipefail + +# this stops git rev-parse from failing if we run this from the .git directory +builtin cd "$(dirname "${BASH_SOURCE:-$0}")" +ROOT="$(git rev-parse --show-toplevel)" +builtin cd "$ROOT" || exit 1 + +check_command() { + if ! command -v "$1" &> /dev/null; then + echo "❓❓$1 is not installed, please run \`pip install -r requirements-lint.txt\`" + exit 1 + fi +} + +check_command yapf +check_command ruff +check_command mypy +check_command codespell +check_command isort +check_command clang-format + +YAPF_VERSION=$(yapf --version | awk '{print $2}') +RUFF_VERSION=$(ruff --version | awk '{print $2}') +MYPY_VERSION=$(mypy --version | awk '{print $2}') +CODESPELL_VERSION=$(codespell --version) +ISORT_VERSION=$(isort --vn) +CLANGFORMAT_VERSION=$(clang-format --version | awk '{print $3}') +SPHINX_LINT_VERSION=$(sphinx-lint --version | awk '{print $2}') + +# params: tool name, tool version, required version +tool_version_check() { + expected=$(grep "$1" requirements-lint.txt | cut -d'=' -f3) + if [[ "$2" != "$expected" ]]; then + echo "❓❓Wrong $1 version installed: $expected is required, not $2." + exit 1 + fi +} + +tool_version_check "yapf" "$YAPF_VERSION" +tool_version_check "ruff" "$RUFF_VERSION" +tool_version_check "mypy" "$MYPY_VERSION" +tool_version_check "isort" "$ISORT_VERSION" +tool_version_check "codespell" "$CODESPELL_VERSION" +tool_version_check "clang-format" "$CLANGFORMAT_VERSION" +tool_version_check "sphinx-lint" "$SPHINX_LINT_VERSION" + +YAPF_FLAGS=( + '--recursive' + '--parallel' +) + +YAPF_EXCLUDES=( + '--exclude' 'build/**' +) + +# Format specified files +format() { + yapf --in-place "${YAPF_FLAGS[@]}" "$@" +} + +# Format files that differ from main branch. Ignores dirs that are not slated +# for autoformat yet. +format_changed() { + # The `if` guard ensures that the list of filenames is not empty, which + # could cause yapf to receive 0 positional arguments, making it hang + # waiting for STDIN. + # + # `diff-filter=ACM` and $MERGEBASE is to ensure we only format files that + # exist on both branches. + MERGEBASE="$(git merge-base origin/main HEAD)" + + if ! git diff --diff-filter=ACM --quiet --exit-code "$MERGEBASE" -- '*.py' '*.pyi' &>/dev/null; then + git diff --name-only --diff-filter=ACM "$MERGEBASE" -- '*.py' '*.pyi' | xargs -P 5 \ + yapf --in-place "${YAPF_EXCLUDES[@]}" "${YAPF_FLAGS[@]}" + fi + +} + +# Format all files +format_all() { + yapf --in-place "${YAPF_FLAGS[@]}" "${YAPF_EXCLUDES[@]}" . +} + +## This flag formats individual files. --files *must* be the first command line +## arg to use this option. +if [[ "$1" == '--files' ]]; then + format "${@:2}" + # If `--all` is passed, then any further arguments are ignored and the + # entire python directory is formatted. +elif [[ "$1" == '--all' ]]; then + format_all +else + # Format only the files that changed in last commit. + format_changed +fi +echo 'vLLM yapf: Done' + +# Run mypy +echo 'vLLM mypy:' +tools/mypy.sh +echo 'vLLM mypy: Done' + + +# If git diff returns a file that is in the skip list, the file may be checked anyway: +# https://github.com/codespell-project/codespell/issues/1915 +# Avoiding the "./" prefix and using "/**" globs for directories appears to solve the problem +CODESPELL_EXCLUDES=( + '--skip' 'tests/prompts/**,./benchmarks/sonnet.txt,*tests/lora/data/**,build/**' +) + +# check spelling of specified files +spell_check() { + codespell "$@" +} + +spell_check_all(){ + codespell --toml pyproject.toml "${CODESPELL_EXCLUDES[@]}" +} + +# Spelling check of files that differ from main branch. +spell_check_changed() { + # The `if` guard ensures that the list of filenames is not empty, which + # could cause ruff to receive 0 positional arguments, making it hang + # waiting for STDIN. + # + # `diff-filter=ACM` and $MERGEBASE is to ensure we only lint files that + # exist on both branches. + MERGEBASE="$(git merge-base origin/main HEAD)" + if ! git diff --diff-filter=ACM --quiet --exit-code "$MERGEBASE" -- '*.py' '*.pyi' &>/dev/null; then + git diff --name-only --diff-filter=ACM "$MERGEBASE" -- '*.py' '*.pyi' | xargs \ + codespell "${CODESPELL_EXCLUDES[@]}" + fi +} + +# Run Codespell +## This flag runs spell check of individual files. --files *must* be the first command line +## arg to use this option. +if [[ "$1" == '--files' ]]; then + spell_check "${@:2}" + # If `--all` is passed, then any further arguments are ignored and the + # entire python directory is linted. +elif [[ "$1" == '--all' ]]; then + spell_check_all +else + # Check spelling only of the files that changed in last commit. + spell_check_changed +fi +echo 'vLLM codespell: Done' + + +# Lint specified files +lint() { + ruff check "$@" +} + +# Lint files that differ from main branch. Ignores dirs that are not slated +# for autolint yet. +lint_changed() { + # The `if` guard ensures that the list of filenames is not empty, which + # could cause ruff to receive 0 positional arguments, making it hang + # waiting for STDIN. + # + # `diff-filter=ACM` and $MERGEBASE is to ensure we only lint files that + # exist on both branches. + MERGEBASE="$(git merge-base origin/main HEAD)" + + if ! git diff --diff-filter=ACM --quiet --exit-code "$MERGEBASE" -- '*.py' '*.pyi' &>/dev/null; then + git diff --name-only --diff-filter=ACM "$MERGEBASE" -- '*.py' '*.pyi' | xargs \ + ruff check + fi + +} + +# Run Ruff +### This flag lints individual files. --files *must* be the first command line +### arg to use this option. +if [[ "$1" == '--files' ]]; then + lint "${@:2}" + # If `--all` is passed, then any further arguments are ignored and the + # entire python directory is linted. +elif [[ "$1" == '--all' ]]; then + lint vllm tests +else + # Format only the files that changed in last commit. + lint_changed +fi +echo 'vLLM ruff: Done' + +# check spelling of specified files +isort_check() { + isort "$@" +} + +isort_check_all(){ + isort . +} + +# Spelling check of files that differ from main branch. +isort_check_changed() { + # The `if` guard ensures that the list of filenames is not empty, which + # could cause ruff to receive 0 positional arguments, making it hang + # waiting for STDIN. + # + # `diff-filter=ACM` and $MERGEBASE is to ensure we only lint files that + # exist on both branches. + MERGEBASE="$(git merge-base origin/main HEAD)" + + if ! git diff --diff-filter=ACM --quiet --exit-code "$MERGEBASE" -- '*.py' '*.pyi' &>/dev/null; then + git diff --name-only --diff-filter=ACM "$MERGEBASE" -- '*.py' '*.pyi' | xargs \ + isort + fi +} + +# Run Isort +# This flag runs spell check of individual files. --files *must* be the first command line +# arg to use this option. +if [[ "$1" == '--files' ]]; then + isort_check "${@:2}" + # If `--all` is passed, then any further arguments are ignored and the + # entire python directory is linted. +elif [[ "$1" == '--all' ]]; then + isort_check_all +else + # Check spelling only of the files that changed in last commit. + isort_check_changed +fi +echo 'vLLM isort: Done' + +# Clang-format section +# Exclude some files for formatting because they are vendored +# NOTE: Keep up to date with .github/workflows/clang-format.yml +CLANG_FORMAT_EXCLUDES=( + 'csrc/moe/topk_softmax_kernels.cu' + 'csrc/quantization/gguf/ggml-common.h' + 'csrc/quantization/gguf/dequantize.cuh' + 'csrc/quantization/gguf/vecdotq.cuh' + 'csrc/quantization/gguf/mmq.cuh' + 'csrc/quantization/gguf/mmvq.cuh' +) + +# Format specified files with clang-format +clang_format() { + clang-format -i "$@" +} + +# Format files that differ from main branch with clang-format. +clang_format_changed() { + # The `if` guard ensures that the list of filenames is not empty, which + # could cause clang-format to receive 0 positional arguments, making it hang + # waiting for STDIN. + # + # `diff-filter=ACM` and $MERGEBASE is to ensure we only format files that + # exist on both branches. + MERGEBASE="$(git merge-base origin/main HEAD)" + + # Get the list of changed files, excluding the specified ones + changed_files=$(git diff --name-only --diff-filter=ACM "$MERGEBASE" -- '*.h' '*.cpp' '*.cu' '*.cuh' | (grep -vFf <(printf "%s\n" "${CLANG_FORMAT_EXCLUDES[@]}") || echo -e)) + if [ -n "$changed_files" ]; then + echo "$changed_files" | xargs -P 5 clang-format -i + fi +} + +# Format all files with clang-format +clang_format_all() { + find csrc/ \( -name '*.h' -o -name '*.cpp' -o -name '*.cu' -o -name '*.cuh' \) -print \ + | grep -vFf <(printf "%s\n" "${CLANG_FORMAT_EXCLUDES[@]}") \ + | xargs clang-format -i +} + +# Run clang-format +if [[ "$1" == '--files' ]]; then + clang_format "${@:2}" +elif [[ "$1" == '--all' ]]; then + clang_format_all +else + clang_format_changed +fi +echo 'vLLM clang-format: Done' + +echo 'vLLM actionlint:' +tools/actionlint.sh -color +echo 'vLLM actionlint: Done' + +echo 'vLLM shellcheck:' +tools/shellcheck.sh +echo 'vLLM shellcheck: Done' + +echo 'excalidraw png check:' +tools/png-lint.sh +echo 'excalidraw png check: Done' + +if ! git diff --quiet &>/dev/null; then + echo + echo "🔍🔍There are files changed by the format checker or by you that are not added and committed:" + git --no-pager diff --name-only + echo "🔍🔍Format checker passed, but please add, commit and push all the files above to include changes made by the format checker." + + exit 1 +else + echo "✨🎉 Format check passed! Congratulations! 🎉✨" +fi + +# echo 'vLLM sphinx-lint:' +# tools/sphinx-lint.sh +# echo 'vLLM sphinx-lint: Done' diff --git a/mypy.ini b/mypy.ini new file mode 100644 index 000000000..b627e7f51 --- /dev/null +++ b/mypy.ini @@ -0,0 +1,14 @@ +[mypy] +; warn_return_any = True +warn_unused_configs = True + +; Suppress all missing import errors from torch_npu for mypy. +[mypy-torch_npu.*] +ignore_missing_imports = True + +[mypy-transformers.*] +ignore_missing_imports = True + +; Remove this after https://github.com/vllm-project/vllm/pull/11324 merged +[mypy-vllm.distributed.device_communicators.base_communicator] +ignore_missing_imports = True diff --git a/packages.txt b/packages.txt new file mode 100644 index 000000000..c6490115b --- /dev/null +++ b/packages.txt @@ -0,0 +1,3 @@ +git +vim + diff --git a/requirements-dev.txt b/requirements-dev.txt new file mode 100644 index 000000000..60a78830d --- /dev/null +++ b/requirements-dev.txt @@ -0,0 +1,3 @@ +-r requirements-lint.txt +modelscope +pytest diff --git a/requirements-lint.txt b/requirements-lint.txt new file mode 100644 index 000000000..711bb50a0 --- /dev/null +++ b/requirements-lint.txt @@ -0,0 +1,15 @@ +# formatting +yapf==0.32.0 +toml==0.10.2 +tomli==2.0.2 +ruff==0.6.5 +codespell==2.3.0 +isort==5.13.2 +clang-format==18.1.5 +sphinx-lint==1.0.0 + +# type checking +mypy==1.11.1 +types-PyYAML +types-requests +types-setuptools diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 000000000..51cb33f2b --- /dev/null +++ b/requirements.txt @@ -0,0 +1,5 @@ +decorator +pyyaml +scipy +setuptools +torch_npu == 2.5.1rc1 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..4aaab9907 --- /dev/null +++ b/setup.py @@ -0,0 +1,95 @@ +# +# Copyright (c) 2025 Huawei Technologies Co., Ltd. All Rights Reserved. +# This file is a part of the vllm-ascend project. +# Adapted from https://github.com/vllm-project/vllm/blob/main/setup.py +# Copyright 2023 The vLLM team. +# +# 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 +from typing import List + +from setuptools import setup + +ROOT_DIR = os.path.dirname(__file__) + + +def get_path(*filepath) -> str: + return os.path.join(ROOT_DIR, *filepath) + + +def read_readme() -> str: + """Read the README file if present.""" + p = get_path("README.md") + if os.path.isfile(p): + with open(get_path("README.md"), encoding="utf-8") as f: + return f.read() + else: + return "" + + +def get_requirements() -> List[str]: + """Get Python package dependencies from requirements.txt.""" + + def _read_requirements(filename: str) -> List[str]: + with open(get_path(filename)) as f: + requirements = f.read().strip().split("\n") + resolved_requirements = [] + for line in requirements: + if line.startswith("-r "): + resolved_requirements += _read_requirements(line.split()[1]) + elif line.startswith("--"): + continue + else: + resolved_requirements.append(line) + return resolved_requirements + + try: + requirements = _read_requirements("requirements.txt") + except ValueError: + print("Failed to read requirements.txt in vllm_ascend.") + return requirements + + +setup( + name='vllm_ascend', + # Follow: + # https://packaging.python.org/en/latest/specifications/version-specifiers + version='0.1.0a1', + author="vLLM-Ascend team", + license="Apache 2.0", + description=("vLLM Ascend backend plugin"), + long_description=read_readme(), + long_description_content_type="text/markdown", + url="https://github.com/vllm-project/vllm-ascend", + project_urls={ + "Homepage": "https://github.com/vllm-project/vllm-ascend", + }, + classifiers=[ + "Programming Language :: Python :: 3.9", + "Programming Language :: Python :: 3.10", + "Programming Language :: Python :: 3.11", + "Programming Language :: Python :: 3.12", + "License :: OSI Approved :: Apache Software License", + "Intended Audience :: Developers", + "Intended Audience :: Information Technology", + "Intended Audience :: Science/Research", + "Topic :: Scientific/Engineering :: Artificial Intelligence", + "Topic :: Scientific/Engineering :: Information Analysis", + ], + packages=['vllm_ascend'], + python_requires=">=3.9", + install_requires=get_requirements(), + extras_require={}, + entry_points={'vllm.platform_plugins': ["ascend = vllm_ascend:register"]}) diff --git a/tests/conftest.py b/tests/conftest.py new file mode 100644 index 000000000..3a593e45e --- /dev/null +++ b/tests/conftest.py @@ -0,0 +1,331 @@ +# +# Copyright (c) 2025 Huawei Technologies Co., Ltd. All Rights Reserved. +# This file is a part of the vllm-ascend project. +# Adapted from vllm-project/vllm/blob/main/tests/conftest.py +# Copyright 2023 The vLLM team. +# +# 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. +# + +from typing import List, Optional, Tuple, TypeVar, Union + +import numpy as np +import pytest +from PIL import Image +from vllm import LLM, SamplingParams +from vllm.config import TaskOption +from vllm.distributed import cleanup_dist_env_and_memory +from vllm.inputs import ExplicitEncoderDecoderPrompt, TextPrompt, TokensPrompt +from vllm.logger import init_logger +from vllm.outputs import RequestOutput +from vllm.sampling_params import BeamSearchParams +from vllm.utils import is_list_of + +from tests.model_utils import (TokensTextLogprobs, + TokensTextLogprobsPromptLogprobs) + +logger = init_logger(__name__) + +_M = TypeVar("_M") +_PromptMultiModalInput = Union[List[_M], List[List[_M]]] + +PromptImageInput = _PromptMultiModalInput[Image.Image] +PromptAudioInput = _PromptMultiModalInput[Tuple[np.ndarray, int]] +PromptVideoInput = _PromptMultiModalInput[np.ndarray] + + +class VllmRunner: + + def __init__( + self, + model_name: str, + task: TaskOption = "auto", + tokenizer_name: Optional[str] = None, + tokenizer_mode: str = "auto", + # Use smaller max model length, otherwise bigger model cannot run due + # to kv cache size limit. + max_model_len: int = 1024, + dtype: str = "half", + disable_log_stats: bool = True, + tensor_parallel_size: int = 1, + block_size: int = 16, + enable_chunked_prefill: bool = False, + swap_space: int = 4, + enforce_eager: Optional[bool] = False, + **kwargs, + ) -> None: + self.model = LLM( + model=model_name, + task=task, + tokenizer=tokenizer_name, + tokenizer_mode=tokenizer_mode, + trust_remote_code=True, + dtype=dtype, + swap_space=swap_space, + enforce_eager=enforce_eager, + disable_log_stats=disable_log_stats, + tensor_parallel_size=tensor_parallel_size, + max_model_len=max_model_len, + block_size=block_size, + enable_chunked_prefill=enable_chunked_prefill, + **kwargs, + ) + + def get_inputs( + self, + prompts: List[str], + images: Optional[PromptImageInput] = None, + videos: Optional[PromptVideoInput] = None, + audios: Optional[PromptAudioInput] = None, + ) -> List[TextPrompt]: + if images is not None: + assert len(prompts) == len(images) + + if videos is not None: + assert len(prompts) == len(videos) + + if audios is not None: + assert len(prompts) == len(audios) + + inputs = [TextPrompt(prompt=prompt) for prompt in prompts] + if images is not None: + for i, image in enumerate(images): + if image is not None: + inputs[i]["multi_modal_data"] = {"image": image} + + if videos is not None: + for i, video in enumerate(videos): + if video is not None: + inputs[i]["multi_modal_data"] = {"video": video} + + if audios is not None: + for i, audio in enumerate(audios): + if audio is not None: + inputs[i]["multi_modal_data"] = {"audio": audio} + + return inputs + + def generate( + self, + prompts: List[str], + sampling_params: SamplingParams, + images: Optional[PromptImageInput] = None, + videos: Optional[PromptVideoInput] = None, + audios: Optional[PromptAudioInput] = None, + ) -> List[Tuple[List[List[int]], List[str]]]: + inputs = self.get_inputs(prompts, + images=images, + videos=videos, + audios=audios) + + req_outputs = self.model.generate(inputs, + sampling_params=sampling_params) + + outputs: List[Tuple[List[List[int]], List[str]]] = [] + for req_output in req_outputs: + prompt_str = req_output.prompt + prompt_ids = req_output.prompt_token_ids + req_sample_output_ids: List[List[int]] = [] + req_sample_output_strs: List[str] = [] + for sample in req_output.outputs: + output_str = sample.text + output_ids = list(sample.token_ids) + req_sample_output_ids.append(prompt_ids + output_ids) + req_sample_output_strs.append(prompt_str + output_str) + outputs.append((req_sample_output_ids, req_sample_output_strs)) + return outputs + + @staticmethod + def _final_steps_generate_w_logprobs( + req_outputs: List[RequestOutput], + ) -> List[TokensTextLogprobsPromptLogprobs]: + outputs: List[TokensTextLogprobsPromptLogprobs] = [] + for req_output in req_outputs: + assert len(req_output.outputs) > 0 + for sample in req_output.outputs: + output_str = sample.text + output_ids = list(sample.token_ids) + output_logprobs = sample.logprobs + outputs.append((output_ids, output_str, output_logprobs, + req_output.prompt_logprobs)) + return outputs + + def generate_w_logprobs( + self, + prompts: List[str], + sampling_params: SamplingParams, + images: Optional[PromptImageInput] = None, + audios: Optional[PromptAudioInput] = None, + videos: Optional[PromptVideoInput] = None, + ) -> Union[List[TokensTextLogprobs], + List[TokensTextLogprobsPromptLogprobs]]: + inputs = self.get_inputs(prompts, + images=images, + videos=videos, + audios=audios) + + req_outputs = self.model.generate(inputs, + sampling_params=sampling_params) + + toks_str_logsprobs_prompt_logprobs = ( + self._final_steps_generate_w_logprobs(req_outputs)) + # Omit prompt logprobs if not required by sampling params + return ([x[0:-1] for x in toks_str_logsprobs_prompt_logprobs] + if sampling_params.prompt_logprobs is None else + toks_str_logsprobs_prompt_logprobs) + + def generate_encoder_decoder_w_logprobs( + self, + encoder_decoder_prompts: List[ExplicitEncoderDecoderPrompt[str, str]], + sampling_params: SamplingParams, + ) -> Union[List[TokensTextLogprobs], + List[TokensTextLogprobsPromptLogprobs]]: + ''' + Logprobs generation for vLLM encoder/decoder models + ''' + + assert sampling_params.logprobs is not None + req_outputs = self.model.generate(encoder_decoder_prompts, + sampling_params=sampling_params) + toks_str_logsprobs_prompt_logprobs = ( + self._final_steps_generate_w_logprobs(req_outputs)) + # Omit prompt logprobs if not required by sampling params + return ([x[0:-1] for x in toks_str_logsprobs_prompt_logprobs] + if sampling_params.prompt_logprobs is None else + toks_str_logsprobs_prompt_logprobs) + + def generate_greedy( + self, + prompts: List[str], + max_tokens: int, + images: Optional[PromptImageInput] = None, + videos: Optional[PromptVideoInput] = None, + audios: Optional[PromptAudioInput] = None, + ) -> List[Tuple[List[int], str]]: + greedy_params = SamplingParams(temperature=0.0, max_tokens=max_tokens) + outputs = self.generate(prompts, + greedy_params, + images=images, + videos=videos, + audios=audios) + return [(output_ids[0], output_str[0]) + for output_ids, output_str in outputs] + + def generate_greedy_logprobs( + self, + prompts: List[str], + max_tokens: int, + num_logprobs: int, + num_prompt_logprobs: Optional[int] = None, + images: Optional[PromptImageInput] = None, + audios: Optional[PromptAudioInput] = None, + videos: Optional[PromptVideoInput] = None, + stop_token_ids: Optional[List[int]] = None, + stop: Optional[List[str]] = None, + ) -> Union[List[TokensTextLogprobs], + List[TokensTextLogprobsPromptLogprobs]]: + greedy_logprobs_params = SamplingParams( + temperature=0.0, + max_tokens=max_tokens, + logprobs=num_logprobs, + prompt_logprobs=num_prompt_logprobs, + stop_token_ids=stop_token_ids, + stop=stop) + + return self.generate_w_logprobs(prompts, + greedy_logprobs_params, + images=images, + audios=audios, + videos=videos) + + def generate_encoder_decoder_greedy_logprobs( + self, + encoder_decoder_prompts: List[ExplicitEncoderDecoderPrompt[str, str]], + max_tokens: int, + num_logprobs: int, + num_prompt_logprobs: Optional[int] = None, + ) -> Union[List[TokensTextLogprobs], + List[TokensTextLogprobsPromptLogprobs]]: + greedy_logprobs_params = SamplingParams( + temperature=0.0, + max_tokens=max_tokens, + logprobs=num_logprobs, + prompt_logprobs=(num_prompt_logprobs), + ) + ''' + Greedy logprobs generation for vLLM encoder/decoder models + ''' + + return self.generate_encoder_decoder_w_logprobs( + encoder_decoder_prompts, greedy_logprobs_params) + + def generate_beam_search( + self, + prompts: Union[List[str], List[List[int]]], + beam_width: int, + max_tokens: int, + ) -> List[Tuple[List[List[int]], List[str]]]: + if is_list_of(prompts, str, check="all"): + prompts = [TextPrompt(prompt=prompt) for prompt in prompts] + else: + prompts = [ + TokensPrompt(prompt_token_ids=tokens) for tokens in prompts + ] + outputs = self.model.beam_search( + prompts, + BeamSearchParams(beam_width=beam_width, max_tokens=max_tokens)) + returned_outputs = [] + for output in outputs: + token_ids = [x.tokens for x in output.sequences] + texts = [x.text for x in output.sequences] + returned_outputs.append((token_ids, texts)) + return returned_outputs + + def classify(self, prompts: List[str]) -> List[List[float]]: + req_outputs = self.model.classify(prompts) + return [req_output.outputs.probs for req_output in req_outputs] + + def encode( + self, + prompts: List[str], + images: Optional[PromptImageInput] = None, + videos: Optional[PromptVideoInput] = None, + audios: Optional[PromptAudioInput] = None, + ) -> List[List[float]]: + inputs = self.get_inputs(prompts, + images=images, + videos=videos, + audios=audios) + + req_outputs = self.model.embed(inputs) + return [req_output.outputs.embedding for req_output in req_outputs] + + def score( + self, + text_1: Union[str, List[str]], + text_2: Union[str, List[str]], + ) -> List[float]: + req_outputs = self.model.score(text_1, text_2) + return [req_output.outputs.score for req_output in req_outputs] + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_value, traceback): + del self.model + cleanup_dist_env_and_memory() + + +@pytest.fixture(scope="session") +def vllm_runner(): + return VllmRunner diff --git a/tests/model_utils.py b/tests/model_utils.py new file mode 100644 index 000000000..1b9eadccd --- /dev/null +++ b/tests/model_utils.py @@ -0,0 +1,303 @@ +# +# Copyright (c) 2025 Huawei Technologies Co., Ltd. All Rights Reserved. +# This file is a part of the vllm-ascend project. +# Adapted from vllm-project/vllm/blob/main/tests/models/utils.py +# Copyright 2023 The vLLM team. +# +# 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 warnings +from typing import Dict, List, Optional, Sequence, Tuple, Union + +import torch +from vllm.config import ModelConfig, TaskOption +from vllm.inputs import InputContext +from vllm.sequence import Logprob, PromptLogprobs, SampleLogprobs + +TokensText = Tuple[List[int], str] + + +def check_outputs_equal( + *, + outputs_0_lst: Sequence[TokensText], + outputs_1_lst: Sequence[TokensText], + name_0: str, + name_1: str, +): + """ + Compare the two sequences generated by different models, + which should be equal. + """ + assert len(outputs_0_lst) == len(outputs_1_lst) + + for prompt_idx, (outputs_0, + outputs_1) in enumerate(zip(outputs_0_lst, + outputs_1_lst)): + output_ids_0, output_str_0 = outputs_0 + output_ids_1, output_str_1 = outputs_1 + + # The text and token outputs should exactly match + fail_msg = (f"Test{prompt_idx}:" + f"\n{name_0}:\t{output_str_0!r}" + f"\n{name_1}:\t{output_str_1!r}") + + assert output_str_0 == output_str_1, fail_msg + assert output_ids_0 == output_ids_1, fail_msg + + +# Representation of generated sequence as a tuple of +# * Token ID list +# * String +# * List of top sample logprobs for each sampled token +# +# Assumes prompt logprobs were not requested. +TokensTextLogprobs = Tuple[List[int], str, Optional[Union[List[Dict[int, + float]], + SampleLogprobs]]] + +# Allow for tokens to be represented as str's rather than IDs; +# tuple of +# * Token string representations list +# * String +# * Optional list of top sample logprobs for each sampled token +# +# Assumes prompt logprobs were not requested. +TextTextLogprobs = Tuple[List[str], str, Optional[Union[List[Dict[str, float]], + List[Dict[str, + Logprob]]]]] + +# Representation of generated sequence as a tuple of +# * Token ID list +# * String +# * Optional list of top sample logprobs for each sampled token +# * Optional list of top prompt logprobs for each prompt token +# +# Allows prompt logprobs to be requested. +TokensTextLogprobsPromptLogprobs = Tuple[ + List[int], str, Optional[Union[List[Dict[int, float]], SampleLogprobs]], + Optional[Union[List[Optional[Dict[int, float]]], PromptLogprobs]]] + + +def check_logprobs_close( + *, + outputs_0_lst: Sequence[Union[TokensTextLogprobs, + TokensTextLogprobsPromptLogprobs, + TextTextLogprobs]], + outputs_1_lst: Sequence[Union[TokensTextLogprobs, + TokensTextLogprobsPromptLogprobs, + TextTextLogprobs]], + name_0: str, + name_1: str, + num_outputs_0_skip_tokens: int = 0, + warn_on_mismatch: bool = True, + always_check_logprobs: bool = False, +) -> None: + """Compare the logprobs of two sequences generated by different models, + which should be similar but not necessarily equal. + + How sample logprobs are compared: + * `always_check_logprobs == True`: set of highest-logprob token ids + must match between seq0 and seq1 at all sampled token offsets + * `always_check_logprobs == False`: highest-logprob token ids are + only compared at sampled token offsets for which generated token + ids don't match + + Prompt logprobs must be provided either for both input sequences, or + for neither. If prompt logprobs are provided, then highest-logprob + prompt token ids must match between seq0 and seq1 at all prompt token + offsets. + + Args: + outputs_0_lst: First sequence to compare + outputs_0_lst: Second sequence to compare + name_0: sequence #0 name + name_1: sequence #1 name + num_outputs_0_skip_tokens: If > 0, specifies the number of initial + sequence #0 tokens & logprobs to discard + before comparison, i.e. all + of sequence #1 will be compared to + sequence #0 beginning at index + num_outputs_0_skip_tokens + warn_on_mismatch: Issue a warning if there is token-wise or text-wise + mismatch between the two sequences + always_check_logprobs: If true, check logprobs even when tokens match + """ + assert len(outputs_0_lst) == len(outputs_1_lst) + + # Loop through responses to each prompt. + for prompt_idx, (outputs_0, + outputs_1) in enumerate(zip(outputs_0_lst, + outputs_1_lst)): + assert len(outputs_0) == len(outputs_1) + if len(outputs_0) == 3: + assert len(outputs_1) == 3 + # Break out tokens, text & sample logprobs + # (prompt logprobs were not provided) + output_ids_0, output_str_0, logprobs_0 = outputs_0 + output_ids_1, output_str_1, logprobs_1 = outputs_1 + elif len(outputs_0) == 4: + assert len(outputs_1) == 4 + # Break out tokens, text, sample logprobs & prompt logprobs + ( + output_ids_0, + output_str_0, + logprobs_0, + prompt_logprobs_0, + ) = outputs_0 + ( + output_ids_1, + output_str_1, + logprobs_1, + prompt_logprobs_1, + ) = outputs_1 + + # Test prompt logprobs closeness + if (prompt_logprobs_0 is not None + and prompt_logprobs_1 is not None): + # Both sequences' prompt logprobs lists are not `None`` + # (although individual list elements may be `None`); + # for each token's logprobs: + for idx, (logprobs_elem_0, logprobs_elem_1) in enumerate( + zip(prompt_logprobs_0, prompt_logprobs_1)): + fail_msg = ( + f"Prompt logprobs test:" + f"\n{name_0}:\tPrompt index {idx}\t{logprobs_elem_0}" + f"\n{name_1}:\tPrompt index {idx}\t{logprobs_elem_1}") + + if logprobs_elem_0 is None: + # If the seq 0 token's logprobs are `None`, + # the seq 1 token's logprobs must be `None` + assert logprobs_elem_1 is None, fail_msg + else: + # If the seq 0 token's logprobs are not `None`, + # the seq 1 token's logprobs must not be `None` + assert logprobs_elem_1 is not None, fail_msg + # Logprobs check: top-k token choices must be the same + assert (set(logprobs_elem_0.keys()) == set( + logprobs_elem_1.keys())), fail_msg + else: + # Both sequence logprobs lists must be `None` + fail_msg = (f"Prompt logprobs test:" + f"\n{name_0}:\tlogprobs\t{prompt_logprobs_0}" + f"\n{name_1}:\tlogprobs\t{prompt_logprobs_1}") + + assert (prompt_logprobs_0 is None + and prompt_logprobs_1 is None), fail_msg + else: + raise ValueError(f"Outputs tuple must have 3 or 4 elements but " + f"{len(outputs_0)} elements were provided: " + f"{outputs_0}") + + if logprobs_0 is None: + logprobs_0 = [None] * len(output_ids_0) + if logprobs_1 is None: + logprobs_1 = [None] * len(output_ids_1) + + # Skip specified number of initial sequence #0 tokens + # & logprobs, leaving output text as-is for simplicity + # (text mismatches may generate warnings but do not + # cause the test to fail.) + if num_outputs_0_skip_tokens < 0: + raise ValueError("num_outputs_0_skip_tokens must be non-negative") + output_ids_0 = output_ids_0[num_outputs_0_skip_tokens:] + logprobs_0 = logprobs_0[num_outputs_0_skip_tokens:] + + # Loop through generated tokens. + for idx, (output_id_0, + output_id_1) in enumerate(zip(output_ids_0, output_ids_1)): + + is_tok_mismatch = output_id_0 != output_id_1 + + # If generated tokens don't match + # or it is desired to always check logprobs, + # then + if is_tok_mismatch or always_check_logprobs: + logprobs_elem_0 = logprobs_0[idx] + logprobs_elem_1 = logprobs_1[idx] + + # Each predicted token must be in top N logprobs of the other + fail_msg = ( + f"Test{prompt_idx}:" + f"\nMatched tokens:\t{output_ids_0[:idx]}" + f"\n{name_0}:\t{output_str_0!r}\t{logprobs_elem_0}" + f"\n{name_1}:\t{output_str_1!r}\t{logprobs_elem_1}") + + assert logprobs_elem_0 is not None, fail_msg + assert logprobs_elem_1 is not None, fail_msg + assert output_id_0 in logprobs_elem_1, fail_msg + assert output_id_1 in logprobs_elem_0, fail_msg + + if warn_on_mismatch and is_tok_mismatch: + with warnings.catch_warnings(): + # This ensures that repeated warnings are shown + # in the output, not just the first occurrence + warnings.simplefilter("always") + + warnings.warn(fail_msg, stacklevel=2) + + # Break out since sequences will now diverge. + break + else: + if output_str_0 != output_str_1 and warn_on_mismatch: + # The token outputs exactly match, + # so the text outputs should exactly match as well + fail_msg = (f"Test{prompt_idx}:" + f"\n{name_0}:\t{output_str_0!r}" + f"\n{name_1}:\t{output_str_1!r}") + + with warnings.catch_warnings(): + # This ensures that repeated warnings are shown + # in the output, not just the first occurrence + warnings.simplefilter("always") + + warnings.warn(fail_msg, stacklevel=2) + + +def build_model_context(model_name: str, + task: TaskOption = "auto", + tokenizer_name: Optional[str] = None, + trust_remote_code: bool = False, + dtype: Optional[Union[str, torch.dtype]] = None, + mm_processor_kwargs: Optional[Dict] = None, + limit_mm_per_prompt: Optional[Dict] = None): + """Creates an InputContext for a given model. + + Args: + model_name: Name of the model being considered. + tokenizer_name: Name of the tokenizer being considered. + trust_remote_code: Whether or not to allow loading remote code. + mm_processor_kwargs: optional processor kwargs for to be leveraged + in the input processor, mapper, dummy data creation, etc. + limit_mm_per_prompt: Multimodal limits. + + Returns: + InputContext for the model being considered. + """ + if tokenizer_name is None: + tokenizer_name = model_name + if dtype is None: + dtype = "half" + + model_config = ModelConfig( + model_name, + task=task, + tokenizer=tokenizer_name, + tokenizer_mode="auto", + trust_remote_code=trust_remote_code, + dtype=dtype, + seed=0, + mm_processor_kwargs=mm_processor_kwargs, + limit_mm_per_prompt=limit_mm_per_prompt, + ) + return InputContext(model_config) diff --git a/tests/test_offline_inference.py b/tests/test_offline_inference.py new file mode 100644 index 000000000..484bce63c --- /dev/null +++ b/tests/test_offline_inference.py @@ -0,0 +1,61 @@ +# +# Copyright (c) 2025 Huawei Technologies Co., Ltd. All Rights Reserved. +# This file is a part of the vllm-ascend project. +# Adapted from vllm/tests/basic_correctness/test_basic_correctness.py +# Copyright 2023 The vLLM team. +# +# 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. +# +"""Compare the short outputs of HF and vLLM when using greedy sampling. + +Run `pytest tests/test_offline_inference.py`. +""" +import os + +import pytest +import vllm # noqa: F401 +from conftest import VllmRunner + +import vllm_ascend # noqa: F401 + +MODELS = [ + "Qwen/Qwen2.5-0.5B-Instruct", +] +os.environ["VLLM_USE_MODELSCOPE"] = "True" + +TARGET_TEST_SUITE = os.environ.get("TARGET_TEST_SUITE", "L4") + + +@pytest.mark.parametrize("model", MODELS) +@pytest.mark.parametrize("dtype", ["half", "float16"]) +@pytest.mark.parametrize("max_tokens", [5]) +def test_models( + model: str, + dtype: str, + max_tokens: int, +) -> None: + os.environ["VLLM_ATTENTION_BACKEND"] = "ASCEND" + + # 5042 tokens for gemma2 + # gemma2 has alternating sliding window size of 4096 + # we need a prompt with more than 4096 tokens to test the sliding window + prompt = "The following numbers of the sequence " + ", ".join( + str(i) for i in range(1024)) + " are:" + example_prompts = [prompt] + + with VllmRunner(model, + max_model_len=8192, + dtype=dtype, + enforce_eager=False, + gpu_memory_utilization=0.7) as vllm_model: + vllm_model.generate_greedy(example_prompts, max_tokens) diff --git a/tools/actionlint.sh b/tools/actionlint.sh new file mode 100755 index 000000000..72a10b18f --- /dev/null +++ b/tools/actionlint.sh @@ -0,0 +1,33 @@ +#!/bin/bash + +# +# Copyright (c) 2025 Huawei Technologies Co., Ltd. All Rights Reserved. +# This file is a part of the vllm-ascend project. +# Adapted from https://github.com/vllm-project/vllm/tree/main/tools +# Copyright 2023 The vLLM team. +# +# 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. +# + +if command -v actionlint &> /dev/null; then + # NOTE: avoid check .github/workflows/vllm_ascend_test.yaml becase sel-hosted runner `npu-arm64` is unknown + actionlint .github/workflows/*.yml .github/workflows/mypy.yaml + exit 0 +elif [ -x ./actionlint ]; then + ./actionlint .github/workflows/*.yml .github/workflows/mypy.yaml + exit 0 +fi + +# download a binary to the current directory - v1.7.3 +bash <(curl https://raw.githubusercontent.com/rhysd/actionlint/aa0a7be8e566b096e64a5df8ff290ec24fa58fbc/scripts/download-actionlint.bash) +./actionlint .github/workflows/*.yml .github/workflows/mypy.yaml diff --git a/tools/check_repo.sh b/tools/check_repo.sh new file mode 100644 index 000000000..e86d0f110 --- /dev/null +++ b/tools/check_repo.sh @@ -0,0 +1,34 @@ +#!/bin/bash + +# +# Copyright (c) 2025 Huawei Technologies Co., Ltd. All Rights Reserved. +# This file is a part of the vllm-ascend project. +# Adapted from https://github.com/vllm-project/vllm/tree/main/tools +# Copyright 2023 The vLLM team. +# +# 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. +# + +# Checks whether the repo is clean and whether tags are available (necessary to correctly produce vllm version at build time) + +if ! git diff --quiet; then + echo "Repo is dirty" >&2 + + exit 1 +fi + +if ! git describe --tags; then + echo "No tags are present. Is this a shallow clone? git fetch --unshallow --tags" >&2 + + exit 1 +fi diff --git a/tools/mypy.sh b/tools/mypy.sh new file mode 100755 index 000000000..fcb7c0e4b --- /dev/null +++ b/tools/mypy.sh @@ -0,0 +1,40 @@ +#!/bin/bash + +# +# Copyright (c) 2025 Huawei Technologies Co., Ltd. All Rights Reserved. +# This file is a part of the vllm-ascend project. +# Adapted from https://github.com/vllm-project/vllm/tree/main/tools +# Copyright 2023 The vLLM team. +# +# 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. +# + +CI=${1:-0} +PYTHON_VERSION=${2:-3.9} + +if [ "$CI" -eq 1 ]; then + set -e +fi + +run_mypy() { + echo "Running mypy on $1" + if [ "$CI" -eq 1 ] && [ -z "$1" ]; then + mypy --python-version "${PYTHON_VERSION}" "$@" + return + fi + mypy --follow-imports skip --python-version "${PYTHON_VERSION}" "$@" +} + +run_mypy vllm_ascend +run_mypy examples +run_mypy tests diff --git a/tools/npu-vllm-test.sh b/tools/npu-vllm-test.sh new file mode 100644 index 000000000..17c7a4d43 --- /dev/null +++ b/tools/npu-vllm-test.sh @@ -0,0 +1,422 @@ +#!/bin/bash + +# +# Copyright (c) 2025 Huawei Technologies Co., Ltd. All Rights Reserved. +# This file is a part of the vllm-ascend project. +# Copyright 2023 The vLLM team. +# +# 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. +# + +set -o pipefail + +TEST_DIR="./vllm-empty/tests" +TEST_FILES=( + test_sequence.py + # test_utils.py + # test_config.py + test_cache_block_hashing.py + # test_scalartype.py + # test_embedded_commit.py + # test_inputs.py + # test_sharded_state_loader.py + test_sampling_params.py + # test_logger.py + # test_logits_processor.py + # test_regression.py + # prefix_caching/test_prefix_caching.py + # prefix_caching/test_disable_sliding_window.py + # weight_loading/test_weight_loading.py + # samplers/test_beam_search.py + # samplers/test_typical_acceptance_sampler.py + # samplers/test_no_bad_words.py + # samplers/test_rejection_sampler.py + # samplers/test_ignore_eos.py + # samplers/test_ranks.py + # samplers/test_logits_processor.py + # samplers/test_sampler.py + # samplers/test_seeded_generate.py + # samplers/test_logprobs.py + # kernels/test_encoder_decoder_attn.py + # kernels/test_rotary_embedding.py + # kernels/test_prefix_prefill.py + # kernels/test_flashinfer.py + # kernels/utils.py + # kernels/test_machete_mm.py + # kernels/test_flash_attn.py + # kernels/test_awq.py + # kernels/test_blocksparse_attention.py + # kernels/test_utils.py + # kernels/test_aqlm.py + # kernels/test_cutlass.py + # kernels/test_causal_conv1d.py + # kernels/test_marlin_gemm.py + # kernels/test_layernorm.py + # kernels/test_pos_encoding.py + # kernels/test_moe.py + # kernels/test_awq_marlin.py + # kernels/test_int8_quant.py + # kernels/test_gptq.py + # kernels/test_attention.py + # kernels/test_activation.py + # kernels/quant_utils.py + # kernels/test_permute_cols.py + # kernels/test_triton_scaled_mm.py + # kernels/test_gguf.py + # kernels/test_awq_triton.py + # kernels/test_attention_selector.py + # kernels/test_ggml.py + # kernels/test_mamba_ssm.py + # kernels/test_fused_quant_layernorm.py + # kernels/test_fp8_quant.py + # kernels/test_cascade_flash_attn.py + # kernels/conftest.py + # kernels/allclose_default.py + # kernels/test_block_fp8.py + # kernels/test_cache.py + # kernels/test_semi_structured.py + # quantization/test_quark.py + # quantization/test_compressed_tensors.py + # quantization/utils.py + # quantization/test_experts_int8.py + # quantization/test_lm_head.py + # quantization/test_ipex_quant.py + # quantization/test_bitsandbytes.py + # quantization/test_cpu_offload.py + # quantization/test_fp8.py + # quantization/test_configs.py + # tool_use/test_tool_calls.py + # tool_use/utils.py + # tool_use/test_chat_completions.py + # tool_use/test_jamba_tool_parser.py + # tool_use/test_chat_completion_request_validations.py + # tool_use/conftest.py + # tool_use/test_parallel_tool_calls.py + # runai_model_streamer/test_runai_model_streamer_loader.py + # runai_model_streamer/test_weight_utils.py + # kv_transfer/test_lookup_buffer.sh + # kv_transfer/test_send_recv.py + # kv_transfer/test_send_recv.sh + # kv_transfer/test_lookup_buffer.py + # kv_transfer/module_test.py + # kv_transfer/disagg_test.py + # plugins/vllm_add_dummy_platform/setup.py + # plugins/vllm_add_dummy_platform/vllm_add_dummy_platform/dummy_platform.py + # plugins/vllm_add_dummy_platform/vllm_add_dummy_platform/dummy_attention_backend.py + # plugins/vllm_add_dummy_model/setup.py + # plugins/vllm_add_dummy_model/vllm_add_dummy_model/my_opt.py + # plugins/vllm_add_dummy_model/vllm_add_dummy_model/my_gemma_embedding.py + # plugins/vllm_add_dummy_model/vllm_add_dummy_model/my_llava.py + # prompt_adapter/test_multi_adapter_inference.py + # prompt_adapter/test_pa_lora.py + # prompt_adapter/test_bloom.py + # compile/test_pass_manager.py + # compile/utils.py + # compile/test_wrapper.py + # compile/test_fusion.py + # compile/backend.py + # compile/test_full_graph.py + # compile/test_basic_correctness.py + # compile/test_functionalization.py + # compile/piecewise/test_simple.py + # compile/piecewise/test_toy_llama.py + # lora/test_punica_ops_variation.py + # lora/test_quant_model.py + # lora/test_lora_checkpoints.py + # lora/test_mixtral.py + # lora/test_qwen2vl.py + # lora/test_baichuan.py + # lora/utils.py + # lora/test_phi.py + # lora/test_utils.py + # lora/test_minicpmv_tp.py + # lora/test_layers.py + # lora/test_worker.py + # lora/test_jamba.py + # lora/test_tokenizer_group.py + # lora/test_lora_bias_e2e.py + # lora/test_chatglm3_tp.py + # lora/test_punica_ops_sizes.py + # lora/test_lora_manager.py + # lora/test_llama_tp.py + # lora/test_lora_huggingface.py + # lora/test_long_context.py + # lora/test_gemma.py + # lora/conftest.py + # lora/data/long_context_test_data.py + # models/registry.py + # models/utils.py + # models/test_registry.py + # models/test_initialization.py + # models/test_oot_registration.py + # models/multimodal/processing/test_internvl.py + # models/multimodal/processing/test_llava_next.py + # models/multimodal/processing/test_idefics3.py + # models/multimodal/processing/test_qwen2_vl.py + # models/multimodal/processing/test_phi3v.py + # models/multimodal/processing/test_common.py + # models/multimodal/processing/test_qwen.py + # models/multimodal/processing/test_llava_onevision.py + # models/encoder_decoder/language/test_bart.py + # models/encoder_decoder/audio_language/test_whisper.py + # models/encoder_decoder/vision_language/test_broadcast.py + # models/encoder_decoder/vision_language/test_florence2.py + # models/encoder_decoder/vision_language/test_mllama.py + # models/decoder_only/language/test_models.py + # models/decoder_only/language/test_gptq_marlin.py + # models/decoder_only/language/test_granite.py + # models/decoder_only/language/test_modelopt.py + # models/decoder_only/language/test_phimoe.py + # models/decoder_only/language/test_aqlm.py + # models/decoder_only/language/test_mistral.py + # models/decoder_only/language/test_jamba.py + # models/decoder_only/language/test_gptq_marlin_24.py + # models/decoder_only/language/test_mamba.py + # models/decoder_only/language/test_gguf.py + # models/decoder_only/language/test_fp8.py + # models/decoder_only/audio_language/test_ultravox.py + # models/decoder_only/vision_language/test_models.py + # models/decoder_only/vision_language/test_awq.py + # models/decoder_only/vision_language/test_intern_vit.py + # models/decoder_only/vision_language/test_qwen2_vl.py + # models/decoder_only/vision_language/test_pixtral.py + # models/decoder_only/vision_language/test_phi3v.py + # models/decoder_only/vision_language/test_h2ovl.py + # models/decoder_only/vision_language/vlm_utils/types.py + # models/decoder_only/vision_language/vlm_utils/model_utils.py + # models/decoder_only/vision_language/vlm_utils/runners.py + # models/decoder_only/vision_language/vlm_utils/core.py + # models/decoder_only/vision_language/vlm_utils/custom_inputs.py + # models/decoder_only/vision_language/vlm_utils/case_filtering.py + # models/decoder_only/vision_language/vlm_utils/builders.py + # models/embedding/utils.py + # models/embedding/language/test_scoring.py + # models/embedding/language/test_gritlm.py + # models/embedding/language/test_cls_models.py + # models/embedding/language/test_embedding.py + # models/embedding/vision_language/test_llava_next.py + # models/embedding/vision_language/test_dse_qwen2_vl.py + # models/embedding/vision_language/test_phi3v.py + # multimodal/utils.py + # multimodal/test_processor_kwargs.py + # multimodal/test_utils.py + # multimodal/test_inputs.py + # multimodal/test_processing.py + # standalone_tests/python_only_compile.sh + # standalone_tests/lazy_torch_compile.py + # async_engine/test_async_llm_engine.py + # async_engine/api_server_async_engine.py + # async_engine/test_api_server.py + # async_engine/test_request_tracker.py + # mq_llm_engine/utils.py + # mq_llm_engine/test_load.py + # mq_llm_engine/test_abort.py + # mq_llm_engine/test_error_handling.py + # tokenization/test_tokenizer.py + # tokenization/test_tokenizer_group.py + # tokenization/test_get_eos.py + # tokenization/test_cached_tokenizer.py + # tokenization/test_detokenize.py + # core/utils.py + # core/test_chunked_prefill_scheduler.py + # core/test_serialization.py + # core/test_num_computed_tokens_update.py + # core/test_scheduler_encoder_decoder.py + # core/test_scheduler.py + # core/block/test_cpu_gpu_block_allocator.py + # core/block/test_prefix_caching_block.py + # core/block/test_common.py + # core/block/test_block_table.py + # core/block/test_block_manager.py + # core/block/conftest.py + # core/block/test_naive_block.py + # core/block/e2e/test_correctness.py + # core/block/e2e/test_correctness_sliding_window.py + # core/block/e2e/conftest.py + # tracing/test_tracing.py + # engine/test_arg_utils.py + # engine/test_detokenization.py + # engine/test_short_mm_context.py + # engine/test_custom_executor.py + # engine/test_multiproc_workers.py + # engine/test_computed_prefix_blocks.py + # engine/test_stop_reason.py + # engine/test_skip_tokenizer_init.py + # engine/test_stop_strings.py + # engine/output_processor/test_stop_checker.py + # engine/output_processor/test_multi_step.py + # tensorizer_loader/test_tensorizer.py + # tensorizer_loader/conftest.py + # entrypoints/test_chat_utils.py + # entrypoints/conftest.py + # entrypoints/llm/test_lazy_outlines.py + # entrypoints/llm/test_generate_multiple_loras.py + # entrypoints/llm/test_encode.py + # entrypoints/llm/test_init.py + # entrypoints/llm/test_guided_generate.py + # entrypoints/llm/test_gpu_utilization.py + # entrypoints/llm/test_chat.py + # entrypoints/llm/test_accuracy.py + # entrypoints/llm/test_prompt_validation.py + # entrypoints/llm/test_generate.py + # entrypoints/offline_mode/test_offline_mode.py + # entrypoints/openai/test_completion.py + # entrypoints/openai/test_models.py + # entrypoints/openai/test_chat_echo.py + # entrypoints/openai/test_score.py + # entrypoints/openai/test_tokenization.py + # entrypoints/openai/test_cli_args.py + # entrypoints/openai/test_chunked_prompt.py + # entrypoints/openai/test_encoder_decoder.py + # entrypoints/openai/test_chat_template.py + # entrypoints/openai/test_oot_registration.py + # entrypoints/openai/test_run_batch.py + # entrypoints/openai/test_metrics.py + # entrypoints/openai/test_vision_embedding.py + # entrypoints/openai/test_embedding.py + # entrypoints/openai/test_lora_adapters.py + # entrypoints/openai/test_video.py + # entrypoints/openai/test_serving_models.py + # entrypoints/openai/test_chat.py + # entrypoints/openai/test_pooling.py + # entrypoints/openai/test_basic.py + # entrypoints/openai/test_accuracy.py + # entrypoints/openai/test_prompt_validation.py + # entrypoints/openai/test_vision.py + # entrypoints/openai/test_audio.py + # entrypoints/openai/test_async_tokenization.py + # entrypoints/openai/test_return_tokens_as_ids.py + # entrypoints/openai/test_serving_chat.py + # entrypoints/openai/test_shutdown.py + # entrypoints/openai/test_root_path.py + # entrypoints/openai/tool_parsers/utils.py + # entrypoints/openai/tool_parsers/test_pythonic_tool_parser.py + # model_executor/weight_utils.py + # model_executor/test_enabled_custom_ops.py + # model_executor/test_guided_processors.py + # model_executor/test_model_load_with_params.py + # model_executor/conftest.py + # metrics/test_metrics.py + # system_messages/sonnet3.5_nov2024.txt + # encoder_decoder/test_e2e_correctness.py + # v1/core/test_kv_cache_utils.py + # v1/core/test_prefix_caching.py + # v1/sample/test_sampler.py + # v1/engine/test_engine_core.py + # v1/engine/test_async_llm.py + # v1/engine/test_output_processor.py + # v1/engine/test_engine_args.py + # v1/engine/test_engine_core_client.py + # v1/e2e/test_cascade_attention.py + # v1/worker/test_gpu_input_batch.py + # spec_decode/utils.py + # spec_decode/test_utils.py + # spec_decode/test_ngram_worker.py + # spec_decode/test_metrics.py + # spec_decode/test_batch_expansion.py + # spec_decode/test_multi_step_worker.py + # spec_decode/test_scorer.py + # spec_decode/test_spec_decode_worker.py + # spec_decode/test_dynamic_spec_decode.py + # spec_decode/e2e/test_mlp_correctness.py + # spec_decode/e2e/test_ngram_correctness.py + # spec_decode/e2e/test_seed.py + # spec_decode/e2e/test_integration.py + # spec_decode/e2e/test_medusa_correctness.py + # spec_decode/e2e/test_integration_dist_tp4.py + # spec_decode/e2e/test_eagle_correctness.py + # spec_decode/e2e/test_compatibility.py + # spec_decode/e2e/test_multistep_correctness.py + # spec_decode/e2e/test_integration_dist_tp2.py + # spec_decode/e2e/conftest.py + # spec_decode/e2e/test_logprobs.py + # multi_step/test_correctness_async_llm.py + # multi_step/test_correctness_llm.py + # vllm_test_utils/setup.py + # vllm_test_utils/vllm_test_utils/blame.py + # vllm_test_utils/vllm_test_utils/monitor.py + # plugins_tests/test_platform_plugins.py + # tpu/test_compilation.py + # tpu/test_quantization_accuracy.py + # tpu/test_custom_dispatcher.py + # distributed/test_custom_all_reduce.py + # distributed/test_distributed_oot.py + # distributed/test_pipeline_parallel.py + # distributed/test_pynccl.py + # distributed/test_pipeline_partition.py + # distributed/test_utils.py + # distributed/test_pp_cudagraph.py + # distributed/test_ca_buffer_sharing.py + # distributed/test_multi_node_assignment.py + # distributed/test_same_node.py + # distributed/test_shm_broadcast.py + # distributed/test_comm_ops.py + # basic_correctness/test_chunked_prefill.py + # basic_correctness/test_preemption.py + # basic_correctness/test_cpu_offload.py + # basic_correctness/test_basic_correctness.py + # worker/test_model_runner.py + # worker/test_encoder_decoder_model_runner.py + # worker/test_swap.py + # worker/test_profile.py + # worker/test_model_input.py +) + +# print usage +usage() { + echo "Usage: $0 -t -t ..." + echo "Example: $0 -t test_inputs.py -t test_regression.py" + exit 1 +} + +# parse command line args +while getopts ":t:" opt; do + case ${opt} in + t) + TEST_FILES+=("${OPTARG}") + ;; + *) + usage + ;; + esac +done + +echo "------ Test vllm_ascend on vLLM native ut ------" + + +# check if the test scripts are specified +if [ ${#TEST_FILES[@]} -eq 0 ]; then + echo "Error: No test scripts specified." + usage +fi + + +# test all the specified ut +for test_file in "${TEST_FILES[@]}"; do + full_path="$TEST_DIR/$test_file" + if [ -f "$full_path" ]; then + echo "Running $test_file..." + # Check if pytest ran successfully + if ! pytest -sv "$full_path" + then + echo "Error: $test_file failed." + exit 1 + fi + echo "Completed $test_file." + else + echo "Error: $test_file not found in $TEST_DIR." + exit 1 + fi +done + +echo "------ All specified tests completed -------" diff --git a/tools/png-lint.sh b/tools/png-lint.sh new file mode 100755 index 000000000..5eeb11eda --- /dev/null +++ b/tools/png-lint.sh @@ -0,0 +1,34 @@ +#!/bin/bash + +# +# Copyright (c) 2025 Huawei Technologies Co., Ltd. All Rights Reserved. +# This file is a part of the vllm-ascend project. +# Adapted from https://github.com/vllm-project/vllm/tree/main/tools +# Copyright 2023 The vLLM team. +# +# 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. +# + +# Ensure that *.excalidraw.png files have the excalidraw metadata +# embedded in them. This ensures they can be loaded back into +# the tool and edited in the future. + +find . -iname '*.excalidraw.png' | while read -r file; do + if git check-ignore -q "$file"; then + continue + fi + if ! grep -q "excalidraw+json" "$file"; then + echo "$file was not exported from excalidraw with 'Embed Scene' enabled." + exit 1 + fi +done diff --git a/tools/shellcheck.sh b/tools/shellcheck.sh new file mode 100755 index 000000000..d782af70a --- /dev/null +++ b/tools/shellcheck.sh @@ -0,0 +1,44 @@ +#!/bin/bash + +# +# Copyright (c) 2025 Huawei Technologies Co., Ltd. All Rights Reserved. +# This file is a part of the vllm-ascend project. +# Adapted from https://github.com/vllm-project/vllm/tree/main/tools +# Copyright 2023 The vLLM team. +# +# 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. +# + +set -e + +scversion="stable" + +if [ -d "shellcheck-${scversion}" ]; then + PATH="$PATH:$(pwd)/shellcheck-${scversion}" + export PATH +fi + +if ! [ -x "$(command -v shellcheck)" ]; then + if [ "$(uname -s)" != "Linux" ] || [ "$(uname -m)" != "x86_64" ]; then + echo "Please install shellcheck: https://github.com/koalaman/shellcheck?tab=readme-ov-file#installing" + exit 1 + fi + + # automatic local install if linux x86_64 + wget -qO- "https://github.com/koalaman/shellcheck/releases/download/${scversion?}/shellcheck-${scversion?}.linux.x86_64.tar.xz" | tar -xJv + PATH="$PATH:$(pwd)/shellcheck-${scversion}" + export PATH +fi + +# TODO - fix warnings in .buildkite/run-amd-test.sh +find . -name "*.sh" -not -path "./.buildkite/run-amd-test.sh" -print0 | xargs -0 -I {} sh -c 'git check-ignore -q "{}" || shellcheck "{}"' diff --git a/tools/sphinx-lint.sh b/tools/sphinx-lint.sh new file mode 100755 index 000000000..806408013 --- /dev/null +++ b/tools/sphinx-lint.sh @@ -0,0 +1,22 @@ +#!/bin/bash + +# +# Copyright (c) 2025 Huawei Technologies Co., Ltd. All Rights Reserved. +# This file is a part of the vllm-ascend project. +# Adapted from https://github.com/vllm-project/vllm/tree/main/tools +# Copyright 2023 The vLLM team. +# +# 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. +# + +sphinx-lint --disable trailing-whitespace,missing-final-newline docs diff --git a/vllm_ascend/__init__.py b/vllm_ascend/__init__.py new file mode 100644 index 000000000..80af5a525 --- /dev/null +++ b/vllm_ascend/__init__.py @@ -0,0 +1,21 @@ +# +# Copyright (c) 2025 Huawei Technologies Co., Ltd. All Rights Reserved. +# This file is a part of the vllm-ascend project. +# +# 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. +# + + +def register(): + """Register the NPU platform.""" + return "vllm_ascend.platform.NPUPlatform" diff --git a/vllm_ascend/attention.py b/vllm_ascend/attention.py new file mode 100644 index 000000000..0693d44e3 --- /dev/null +++ b/vllm_ascend/attention.py @@ -0,0 +1,678 @@ +# +# Copyright (c) 2025 Huawei Technologies Co., Ltd. All Rights Reserved. +# This file is a part of the vllm-ascend project. +# Adapted from vllm-project/vllm/vllm/attention/backends +# Copyright 2023 The vLLM team. +# +# 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 math +from dataclasses import dataclass +from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, Type + +import torch + +try: + import torch_npu # noqa: F401 +except ImportError: + print("Failed to import torch_npu.") + +from vllm.attention.backends.abstract import (AttentionBackend, AttentionImpl, + AttentionLayer, + AttentionMetadata, AttentionType) +from vllm.attention.backends.utils import (PAD_SLOT_ID, CommonAttentionState, + CommonMetadataBuilder, + compute_slot_mapping_start_idx, + is_block_tables_empty) +from vllm.attention.ops.paged_attn import (PagedAttention, + PagedAttentionMetadata) + +if TYPE_CHECKING: + from vllm_ascend.model_runner import ModelInputForNPUBuilder + +SHARE_MASK_TRIL_PREFIX_CACHE = None +SHARE_MASK_TRIL = None + + +class AscendAttentionBackend(AttentionBackend): + + @staticmethod + def get_name() -> str: + return "ASCEND" + + @staticmethod + def get_impl_cls() -> Type["AscendAttentionBackendImpl"]: + return AscendAttentionBackendImpl + + @staticmethod + def get_metadata_cls() -> Type["AscendMetadata"]: + return AscendMetadata + + @staticmethod + def get_state_cls() -> Type["CommonAttentionState"]: + return CommonAttentionState + + @staticmethod + def get_kv_cache_shape( + num_blocks: int, + block_size: int, + num_kv_heads: int, + head_size: int, + ) -> Tuple[int, ...]: + return (2, num_blocks, block_size, num_kv_heads * head_size) + + @staticmethod + def swap_blocks( + src_kv_cache: List[torch.Tensor], + dst_kv_cache: List[torch.Tensor], + src_to_dst: torch.Tensor, + ) -> None: + src_key_cache, src_value_cache = src_kv_cache[0], src_kv_cache[1] + dst_key_cache, dst_value_cache = dst_kv_cache[0], dst_kv_cache[1] + src_indices = src_to_dst[:, 0] + dst_indices = src_to_dst[:, 1] + + dst_key_cache[dst_indices] = src_key_cache[src_indices].to( + dst_key_cache.device) + dst_value_cache[dst_indices] = src_value_cache[src_indices].to( + dst_key_cache.device) + + @staticmethod + def copy_blocks( + kv_caches: List[torch.Tensor], + src_to_dists: torch.Tensor, + ) -> None: + src_indices = src_to_dists[:, 0] + dst_indices = src_to_dists[:, 1] + + for kv_cache in kv_caches: + key_caches = kv_cache[0] + value_caches = kv_cache[1] + key_caches[dst_indices] = key_caches[src_indices] + value_caches[dst_indices] = value_caches[src_indices] + + @staticmethod + def get_builder_cls() -> Type["AscendMetadataBuilder"]: + return AscendMetadataBuilder + + @classmethod + def make_metadata_builder(cls, *args, **kwargs) -> "AscendMetadataBuilder": + return cls.get_builder_cls()(*args, **kwargs) + + +class AscendPagedAttention(PagedAttention): + + @staticmethod + def write_to_paged_cache( + key: torch.Tensor, + value: torch.Tensor, + key_cache: torch.Tensor, + value_cache: torch.Tensor, + slot_indices: torch.Tensor, + ) -> None: + torch_npu.npu_scatter_nd_update_(key_cache, slot_indices, key) + torch_npu.npu_scatter_nd_update_(value_cache, slot_indices, value) + + +@dataclass +class AscendMetadata(AttentionMetadata, PagedAttentionMetadata): + """Metadata for Ascendbackend. + * modified from XFormersbackend + NOTE: Any python object stored here is not updated when it is + cuda-graph replayed. If you have values that need to be changed + dynamically, it should be stored in tensor. The tensor has to be + updated from `CUDAGraphRunner.forward` API. + """ + + # |---------- N-1 iteration --------| + # |---------------- N iteration ---------------------| + # |- tokenA -|......................|-- newTokens ---| + # |---------- context_len ----------| + # |-------------------- seq_len ----------------------| + # |-- query_len ---| + + # seq_lens stored as a tensor. + seq_lens_tensor: Optional[torch.Tensor] + + # FIXME: It is for flash attn. + # Maximum sequence length among prefill batch. 0 if there are decoding + # requests only. + max_prefill_seq_len: int + # Maximum sequence length among decode batch. 0 if there are prefill + # requests only. + max_decode_seq_len: int + + # Whether or not if cuda graph is enabled. + # Cuda-graph is currently enabled for decoding only. + # TODO(woosuk): Move `use_cuda_graph` out since it's unrelated to attention. + use_cuda_graph: bool + + # (batch_size,). The sequence length per sequence. Sequence length means + # the computed tokens + new tokens None if it is a decoding. + seq_lens: Optional[List[int]] = None + + # FIXME: It is for flash attn. + # (batch_size + 1,). The cumulative sequence lengths of the sequences in + # the batch, used to index into sequence. E.g., if the sequence length is + # [4, 6], it is [0, 4, 10]. + seq_start_loc: Optional[torch.Tensor] = None + + # (batch_size,) A tensor of context lengths (tokens that are computed + # so far). + context_lens_tensor: Optional[torch.Tensor] = None + + # Maximum query length in the batch. None for decoding. + max_query_len: Optional[int] = None + + # (batch_size + 1,). The cumulative subquery lengths of the sequences in + # the batch, used to index into subquery. E.g., if the subquery length + # is [4, 6], it is [0, 4, 10]. + query_start_loc: Optional[torch.Tensor] = None + + # Self-attention prefill/decode metadata cache + _cached_prefill_metadata: Optional["AscendMetadata"] = None + _cached_decode_metadata: Optional["AscendMetadata"] = None + + # Begin encoder attn & enc/dec cross-attn fields... + + # Encoder sequence lengths representation + encoder_seq_lens: Optional[List[int]] = None + encoder_seq_lens_tensor: Optional[torch.Tensor] = None + + # Maximum sequence length among encoder sequences + max_encoder_seq_len: Optional[int] = None + + # Number of tokens input to encoder + num_encoder_tokens: Optional[int] = None + + attn_mask: Optional[torch.Tensor] = None + pse_shift: Optional[torch.Tensor] = None + sparse_mode: int = 0 + + # Cross-attention memory-mapping data structures: slot mapping + # and block tables + cross_slot_mapping: Optional[torch.Tensor] = None + cross_block_tables: Optional[torch.Tensor] = None + + # slot_mapping: Optional[torch.Tensor] = None + + @property + def prefill_metadata(self) -> Optional["AscendMetadata"]: + if self.num_prefills == 0: + return None + + if self._cached_prefill_metadata is not None: + # Recover cached prefill-phase attention + # metadata structure + return self._cached_prefill_metadata + + assert ((self.seq_lens is not None) + or (self.encoder_seq_lens is not None)) + assert ((self.seq_lens_tensor is not None) + or (self.encoder_seq_lens_tensor is not None)) + + # Compute some attn_metadata fields which default to None + query_start_loc = (None if self.query_start_loc is None else + self.query_start_loc[:self.num_prefills + 1]) + slot_mapping = (None if self.slot_mapping is None else + self.slot_mapping[:self.num_prefill_tokens]) + seq_lens = (None if self.seq_lens is None else + self.seq_lens[:self.num_prefills]) + seq_lens_tensor = (None if self.seq_lens_tensor is None else + self.seq_lens_tensor[:self.num_prefills]) + seq_start_loc = (None if self.seq_start_loc is None else + self.seq_start_loc[:self.num_prefills + 1]) + context_lens_tensor = (None if self.context_lens_tensor is None else + self.context_lens_tensor[:self.num_prefills]) + block_tables = (None if self.block_tables is None else + self.block_tables[:self.num_prefills]) + + # Construct & cache prefill-phase attention metadata structure + self._cached_prefill_metadata = AscendMetadata( + num_prefills=self.num_prefills, + num_prefill_tokens=self.num_prefill_tokens, + num_decode_tokens=0, + slot_mapping=slot_mapping, + seq_lens=seq_lens, + seq_lens_tensor=seq_lens_tensor, + max_query_len=self.max_query_len, + max_prefill_seq_len=self.max_prefill_seq_len, + max_decode_seq_len=0, + query_start_loc=query_start_loc, + seq_start_loc=seq_start_loc, + context_lens_tensor=context_lens_tensor, + block_tables=block_tables, + use_cuda_graph=False, + # Begin encoder & cross attn fields below... + encoder_seq_lens=self.encoder_seq_lens, + encoder_seq_lens_tensor=self.encoder_seq_lens_tensor, + max_encoder_seq_len=self.max_encoder_seq_len, + multi_modal_placeholder_index_maps=self. + multi_modal_placeholder_index_maps, + cross_slot_mapping=self.cross_slot_mapping, + cross_block_tables=self.cross_block_tables, + enable_kv_scales_calculation=False) + return self._cached_prefill_metadata + + @property + def decode_metadata(self) -> Optional["AscendMetadata"]: + if self.num_decode_tokens == 0: + return None + + if self._cached_decode_metadata is not None: + # Recover cached decode-phase attention + # metadata structure + return self._cached_decode_metadata + assert ((self.seq_lens_tensor is not None) + or (self.encoder_seq_lens_tensor is not None)) + + # Compute some attn_metadata fields which default to None + slot_mapping = (None if self.slot_mapping is None else + self.slot_mapping[self.num_prefill_tokens:]) + seq_lens_tensor = (None if self.seq_lens_tensor is None else + self.seq_lens_tensor[self.num_prefills:]) + block_tables = (None if self.block_tables is None else + self.block_tables[self.num_prefills:]) + + # Construct & cache decode-phase attention metadata structure + self._cached_decode_metadata = AscendMetadata( + num_prefills=0, + num_prefill_tokens=0, + num_decode_tokens=self.num_decode_tokens, + slot_mapping=slot_mapping, + seq_lens_tensor=seq_lens_tensor, + max_prefill_seq_len=0, + max_decode_seq_len=self.max_decode_seq_len, + # Batch may be composed of prefill|decodes, adjust query start + # indices to refer to the start of decodes. E.g. + # in tokens:[3 prefills|6 decodes], query_start_loc=[3,9] => [0,6]. + query_start_loc=(self.query_start_loc[self.num_prefills:] - + self.query_start_loc[self.num_prefills]) + if self.query_start_loc is not None else None, + seq_start_loc=self.seq_start_loc[self.num_prefills:] + if self.seq_start_loc is not None else None, + context_lens_tensor=None, + block_tables=block_tables, + use_cuda_graph=self.use_cuda_graph, + # Begin encoder & cross attn fields below... + encoder_seq_lens=self.encoder_seq_lens, + encoder_seq_lens_tensor=self.encoder_seq_lens_tensor, + max_encoder_seq_len=self.max_encoder_seq_len, + multi_modal_placeholder_index_maps=self. + multi_modal_placeholder_index_maps, + cross_slot_mapping=self.cross_slot_mapping, + cross_block_tables=self.cross_block_tables, + enable_kv_scales_calculation=False) + return self._cached_decode_metadata + + +class AscendMetadataBuilder(CommonMetadataBuilder[AscendMetadata]): + + _metadata_cls = AscendMetadata + + def compute_npu_slot_indices(self, is_profile_run, slot_indices, seq_id, + seq_len, context_len, start_idx, block_size, + block_tables, max_query_len): + """ + compute slot indices + slot mapping in other backend of vllm stores slot indices, + which are indicates by `block_number * block_size + block_offset` + In Ascend backend, slot mapping stores [block_number, block_offset]. + To distinguish this, slot_indices is used in this func + """ + if is_profile_run: + # During memory profiling, the block tables are not + # initialized yet. In this case, we just use a dummy + # slot mapping. + # In embeddings, the block tables are {seq_id: None}. + slot_indices.extend([[PAD_SLOT_ID, 0]] * seq_len) + return + # Mask the [0, start_idx) tokens of the prompt with + # [PAD_SLOT_ID, 0], where start_idx is max(0, seq_len - + # sliding_window). For example, if the prompt len is 10, + # sliding window is 8, and block size is 4, the first two + # tokens are masked and the slot mapping will be + # [-1, -1, 2, 3, 4, 5, 6, 7, 0, 1]. + padding_mask_len = max(0, start_idx - context_len) + slot_indices.extend([[PAD_SLOT_ID, 0]] * padding_mask_len) + + range_start = max(start_idx, context_len) + range_end = seq_len + numel = range_end - range_start + block_table = block_tables[seq_id] + + for i in range(range_start, range_end): + block_number = block_table[i // block_size] + block_offset = i % block_size + slot_indices.append([block_number, block_offset]) + slot_indices.extend([[PAD_SLOT_ID, 0]] * (max_query_len - numel)) + + def _add_seq_group( + self, inter_data: "ModelInputForNPUBuilder.InterDataForSeqGroup", + chunked_prefill_enabled: bool): + """Add a sequence group to the metadata. Specifically update/append + 1. context length. + 2. block table. + 3. slot mapping. + """ + is_prompt = inter_data.is_prompt + block_tables = inter_data.block_tables + max_query_len = max( + max(data.query_lens) + for data in self.input_builder.inter_data_list) + + is_prompt = inter_data.is_prompt + block_tables = inter_data.block_tables + + for (seq_id, token_len, seq_len, curr_seq_len, query_len, context_len, + curr_sliding_window_block) in zip( + inter_data.seq_ids, [len(t) for t in inter_data.input_tokens], + inter_data.orig_seq_lens, inter_data.seq_lens, + inter_data.query_lens, inter_data.context_lens, + inter_data.curr_sliding_window_blocks): + self.context_lens.append(context_len) + if is_prompt: + self.num_prefills += 1 + self.num_prefill_tokens += token_len + self.prefill_seq_lens.append(seq_len) + else: + assert query_len == 1, ( + "seq_len: {}, context_len: {}, query_len: {}".format( + seq_len, context_len, query_len)) + self.num_decode_tokens += query_len + self.curr_seq_lens.append(curr_seq_len) + + # Compute block table. + # TODO(sang): Combine chunked prefill and prefix caching by + # only allowing multiple of block_size chunk size. + # NOTE: This only works for oooooooxxx style attention. + block_table: List[int] = [] + prefix_cache_hit = any([ + inter_data.prefix_cache_hit + for inter_data in self.input_builder.inter_data_list + ]) + if prefix_cache_hit: + # NOTE(woosuk): For flash-attn, the block table should + # include the entries for the incoming prefill tokens. + if block_tables is not None: + block_table = block_tables[seq_id] + elif ((chunked_prefill_enabled or not is_prompt) + and block_tables is not None): + if curr_sliding_window_block == 0: + block_table = block_tables[seq_id] + else: + block_table = block_tables[seq_id][ + -curr_sliding_window_block:] + self.block_tables.append(block_table) + + # Compute slot mapping. + is_profile_run = is_block_tables_empty(block_tables) + start_idx = compute_slot_mapping_start_idx(is_prompt, query_len, + context_len, + self.sliding_window) + + self.compute_npu_slot_indices(is_profile_run, self.slot_mapping, + seq_id, seq_len, context_len, + start_idx, self.block_size, + inter_data.block_tables, + max_query_len) + + +class AscendAttentionBackendImpl(AttentionImpl): + + def __init__( + self, + num_heads: int, + head_size: int, + scale: float, + num_kv_heads: int, + alibi_slopes: Optional[List[float]], + sliding_window: Optional[int], + kv_cache_dtype: str, + blocksparse_params: Optional[Dict[str, Any]] = None, + logits_soft_cap: Optional[float] = None, + attn_type: str = AttentionType.DECODER, + ) -> None: + self.num_heads = num_heads + self.head_size = head_size + self.scale = float(scale) + self.num_kv_heads = num_heads if num_kv_heads is None else num_kv_heads + self.kv_cache_dtype = kv_cache_dtype + self.sliding_window = sliding_window + if alibi_slopes is not None: + alibi_slopes = torch.tensor(alibi_slopes, + dtype=torch.float32, + device="npu") + self.alibi_slopes = alibi_slopes + self.attn_type = attn_type + + assert self.num_heads % self.num_kv_heads == 0 + self.num_queries_per_kv = self.num_heads // self.num_kv_heads + + def forward( + self, + layer: AttentionLayer, + query: torch.Tensor, + key: torch.Tensor, + value: torch.Tensor, + kv_cache: List[torch.Tensor], + attn_metadata: AscendMetadata, + attn_type: str = AttentionType.DECODER, + output: Optional[torch.Tensor] = None, + ) -> torch.Tensor: + """Forward pass with Ascend attention. + Args: + query: shape = [num_tokens, num_heads * head_size] + num_tokens = batch_size * seq_len + key: shape = [num_tokens, num_kv_heads * head_size] + value: shape = [num_tokens, num_kv_heads * head_size] + kv_cache: shape = [2, num_blocks, block_size, + num_kv_heads * head_size] + key_cache = [num_blocks, block_size, + num_kv_heads * head_size] + value_cache = [num_blocks, block_size, + num_kv_heads * head_size] + attn_metadata: Metadata for attention. + Returns: + shape = [batch_size, seq_len * num_heads * head_size] + """ + assert layer._k_scale == 1.0 and layer._v_scale == 1.0 + attn_type = self.attn_type + if attn_type != AttentionType.DECODER: + raise NotImplementedError("Encoder self-attention and " + "encoder/decoder cross-attention " + "are not implemented for " + "PallasAttentionBackendImpl") + # view q k v to BSH + num_tokens = query.shape[0] + + if kv_cache is not None and len(kv_cache) >= 2: + slot_indices = attn_metadata.slot_mapping + key_cache, value_cache = kv_cache[0], kv_cache[1] + AscendPagedAttention.write_to_paged_cache( + key, + value, + key_cache, + value_cache, + slot_indices, + ) + + if attn_metadata.num_prefills > 0: + if attn_metadata.attn_mask is None: + if num_tokens > 16384: + attn_metadata.sparse_mode = 2 + attention_mask = gen_input_mask( + attn_metadata.max_prefill_seq_len, self.sliding_window, + num_tokens) + attn_metadata.attn_mask = attention_mask + + if (self.alibi_slopes is not None + and attn_metadata.pse_shift is None): + attn_metadata.pse_shift = _make_alibi_bias( + self.alibi_slopes, + self.num_kv_heads, + dtype=query.dtype, + seq_len=attn_metadata.max_prefill_seq_len, + batch_size=num_tokens, + ) + + if (len(kv_cache) == 0 or attn_metadata.block_tables is None + or attn_metadata.block_tables.numel() == 0): + max_seq_len = attn_metadata.max_prefill_seq_len + + # shape of q/k/v [B,S*H] --> [B,S,N,D] + query = query.view(-1, max_seq_len, self.num_heads, + self.head_size).transpose(1, 2) + key = key.view(-1, max_seq_len, self.num_kv_heads, + self.head_size).transpose(1, 2) + value = value.view(-1, max_seq_len, self.num_kv_heads, + self.head_size).transpose(1, 2) + # FA for prefill phase + output = torch_npu.npu_prompt_flash_attention( + query, + key, + value, + pse_shift=attn_metadata.pse_shift, + atten_mask=attn_metadata.attn_mask, + num_heads=self.num_heads, + scale_value=1 / math.sqrt(self.head_size), + input_layout="BNSD", + num_key_value_heads=self.num_kv_heads, + pre_tokens=65535, + next_tokens=0, + sparse_mode=attn_metadata.sparse_mode, + ) + # reshape to [B,H] + output = output.transpose(1, 2).reshape( + num_tokens, self.num_heads * self.head_size) + else: + # prefix-enabled attention + assert attn_type == AttentionType.DECODER, ( + "Only decoder-only models support prefix caching") + assert attn_metadata.seq_lens is not None + assert kv_cache is not None + query = query.view(query.shape[0], -1, + self.num_heads * self.head_size) + output = torch.zeros(query.shape, + device="npu", + dtype=query.dtype) + # TODO (Mengqing Cao): torch_npu.npu_incre_flash_attention + # support only when `S == 1`, OPTIMIZE ME when prefix caching + # is supported in torch-npu ops. + for i in range(query.shape[0]): + # FA for prefill phase + output[i] = torch_npu.npu_incre_flash_attention( + query[i].unsqueeze(0), + key_cache, + value_cache, + num_heads=self.num_heads, + num_key_value_heads=self.num_kv_heads, + scale_value=self.scale, + input_layout="BSH", + block_table=attn_metadata.block_tables, + block_size=key_cache. + shape[1], # max val of block_size == 512 + actual_seq_lengths=attn_metadata.seq_lens, + ) + # [B,S,H] --> [B,H] + output = output.squeeze(1) + + elif attn_metadata.decode_metadata: + # FA for decoding phase + assert kv_cache is not None + # shape of query [B,S*H] --> [B,S,H] + query = query.view( + -1, + 1, + self.head_size * self.num_heads, + ) + output = torch_npu.npu_incre_flash_attention( + query, + key_cache, + value_cache, + num_heads=self.num_heads, + num_key_value_heads=self.num_kv_heads, + scale_value=self.scale, + input_layout="BSH", + block_table=attn_metadata.block_tables, + block_size=key_cache.shape[1], # max val of block_size == 512 + actual_seq_lengths=attn_metadata.seq_lens, + ) + + # [B,S,H] --> [B,H] + output = output.squeeze(1) + return output + + +def gen_input_mask(seq_len, sliding_window, len): + """ + Generating lower triangular matrix + """ + if len > 16384: + # improve computing performance on NPU when input tokens are huge + global SHARE_MASK_TRIL_PREFIX_CACHE + if SHARE_MASK_TRIL_PREFIX_CACHE is None: + SHARE_MASK_TRIL_PREFIX_CACHE = torch.triu( + torch.ones(1, 1, 2048, 2048, dtype=bool, device="npu"), + diagonal=1, + ) + attention_mask = SHARE_MASK_TRIL_PREFIX_CACHE + else: + global SHARE_MASK_TRIL + if SHARE_MASK_TRIL is None or SHARE_MASK_TRIL.shape[0] < seq_len: + SHARE_MASK_TRIL = ~torch.tril( + torch.ones(seq_len, seq_len, dtype=bool, device="npu")) + + attention_mask = SHARE_MASK_TRIL + if sliding_window is not None: + attention_mask = ~attention_mask + attention_mask = torch.triu(attention_mask, + diagonal=1 - sliding_window) + attention_mask = ~attention_mask + + return attention_mask + + +def _make_alibi_bias( + alibi_slopes: torch.Tensor, + num_kv_heads: int, + dtype: torch.dtype, + seq_len: int, + batch_size: int, +): + bias = torch.arange(seq_len, dtype=dtype, device=alibi_slopes.device) + # NOTE(zhuohan): HF uses + # `bias = bias[None, :].repeat(seq_len, 1)` + # here. We find that both biases give the same results, but + # the bias below more accurately follows the original ALiBi + # paper. + # Calculate a matrix where each element represents ith element- jth + # element. + bias = bias[None, :] - bias[:, None] + + padded_len = (seq_len + 7) // 8 * 8 + num_heads = alibi_slopes.shape[0] + bias = torch.empty( + 1, + num_heads, + seq_len, + padded_len, + device=alibi_slopes.device, + dtype=dtype, + )[:, :, :, :seq_len].copy_(bias) + bias.mul_(alibi_slopes[:, None, None]) + if num_heads != num_kv_heads: + bias = bias.unflatten(1, (num_kv_heads, num_heads // num_kv_heads)) + + return bias diff --git a/vllm_ascend/communicator.py b/vllm_ascend/communicator.py new file mode 100644 index 000000000..efef46e92 --- /dev/null +++ b/vllm_ascend/communicator.py @@ -0,0 +1,28 @@ +# +# Copyright (c) 2025 Huawei Technologies Co., Ltd. All Rights Reserved. +# This file is a part of the vllm-ascend project. +# +# 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 torch +import torch.distributed as dist +from vllm.distributed.device_communicators.base_communicator import \ + CommunicatorBase + + +class NPUCommunicator(CommunicatorBase): + + def all_reduce(self, x: torch.Tensor) -> torch.Tensor: + dist.all_reduce(x, group=self.group) + return x diff --git a/vllm_ascend/model_runner.py b/vllm_ascend/model_runner.py new file mode 100644 index 000000000..96ef1914b --- /dev/null +++ b/vllm_ascend/model_runner.py @@ -0,0 +1,620 @@ +# +# Copyright (c) 2025 Huawei Technologies Co., Ltd. All Rights Reserved. +# This file is a part of the vllm-ascend project. +# Adapted from vllm-project/vllm/vllm/worker/model_runner.py +# Copyright 2023 The vLLM team. +# +# 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 dataclasses +from typing import Any, Dict, List, Optional, Set, Type + +import torch +import torch.distributed +from torch import nn +from vllm.distributed import get_pp_group +from vllm.logger import init_logger +from vllm.lora.layers import LoRAMapping +from vllm.lora.request import LoRARequest +from vllm.model_executor import SamplingMetadata +from vllm.multimodal import MultiModalKwargs, MultiModalPlaceholderMap +from vllm.platforms import current_platform +from vllm.prompt_adapter.layers import PromptAdapterMapping +from vllm.prompt_adapter.request import PromptAdapterRequest +from vllm.sampling_params import SamplingParams +from vllm.sequence import SequenceGroupMetadata +from vllm.utils import flatten_2d_lists, make_tensor_with_pad +from vllm.worker.model_runner import (ModelInputForGPU, + ModelInputForGPUBuilder, + ModelInputForGPUWithSamplingMetadata, + ModelRunner) + +logger = init_logger(__name__) + +LORA_WARMUP_RANK = 8 + + +class ModelInputForNPUBuilder(ModelInputForGPUBuilder): + """Build ModelInputForGPU from SequenceGroupMetadata.""" + + # Note: ideally we would be using a dataclass(kw_only=True) + # here, so that this can be subclassed easily, + # but kw_only is not supported in python<3.10. + def build(self) -> ModelInputForGPU: + """Finalize the builder intermediate data and + create on-device tensors. + """ + # Combine and flatten intermediate data. + input_tokens = [ + flatten_2d_lists(inter_data.input_tokens) + for inter_data in self.inter_data_list + ] + if not input_tokens: + # This may happen when all prefill requests hit + # prefix caching and there is no decode request. + return self.model_input_cls() + + mrope_input_positions: Optional[List[List[int]]] = None + if any(inter_data.mrope_input_positions is not None + for inter_data in self.inter_data_list): + mrope_input_positions = [[] for _ in range(3)] + # calculate max position length for padding + input_position_lens = [ + len(inter_data.input_positions[0]) + for inter_data in self.inter_data_list + ] + max_pos_len = max(input_position_lens) + + for idx in range(3): + for inter_data in self.inter_data_list: + msections = inter_data.mrope_input_positions + if msections is None: + for _seq_input_positions in inter_data.input_positions: + # zero pad + _seq_input_positions.extend( + [0] * + (max_pos_len - len(_seq_input_positions))) + mrope_input_positions[idx].extend( + _seq_input_positions) + else: + for _seq_mrope_input_positions in msections: + # zero pad + _seq_mrope_input_positions[idx].extend( + [0] * (max_pos_len - + len(_seq_mrope_input_positions[idx]))) + mrope_input_positions[idx].extend( + _seq_mrope_input_positions[idx]) + input_positions = None + else: + input_positions = [ + flatten_2d_lists(inter_data.input_positions) + for inter_data in self.inter_data_list + ] + + seq_lens = [] + max_decode_seq_len = 0 + for inter_data in self.inter_data_list: + seq_lens.extend(inter_data.seq_lens) + if not inter_data.is_prompt: + max_decode_seq_len = max(max_decode_seq_len, + max(inter_data.seq_lens)) + query_lens = flatten_2d_lists( + [inter_data.query_lens for inter_data in self.inter_data_list]) + # Mapping from request IDs to sequence IDs. Used for Jamba models + # that manages the cache by itself. + request_ids_to_seq_ids = { + data.request_id: data.seq_ids + for data in self.inter_data_list + } + + batch_size = len(input_tokens) + + # If cuda graph can be used, pad tensors accordingly. + # See `capture_model` API for more details. + # vLLM uses cuda graph only for decoding requests. + cuda_graph_pad_size = -1 + + if self.inter_data_list[0].is_prompt: + input_tokens_tensor = make_tensor_with_pad( + input_tokens, 0, dtype=torch.int, device=self.runner.device) + input_tokens_tensor = torch.flatten(input_tokens_tensor) + if mrope_input_positions is not None: + mrope_input_positions_tensor = make_tensor_with_pad( + mrope_input_positions, + 0, + dtype=torch.int, + device=self.runner.device) + input_positions_tensor = torch.tensor( + mrope_input_positions_tensor, + dtype=torch.long, + device=self.runner.device) + else: + input_positions_tensor = make_tensor_with_pad( + input_positions, + 0, + dtype=torch.int, + device=self.runner.device) + input_positions_tensor = torch.flatten(input_positions_tensor) + + max_seq_len = max(seq_lens) + seq_lens = len(seq_lens) * [max_seq_len] + else: + input_tokens_tensor = torch.tensor(flatten_2d_lists(input_tokens), + dtype=torch.long, + device=self.runner.device) + if mrope_input_positions is not None: + input_positions_tensor = torch.tensor( + mrope_input_positions, + dtype=torch.long, + device=self.runner.device) + else: + input_positions_tensor = torch.tensor( + flatten_2d_lists(input_positions), + dtype=torch.long, + device=self.runner.device) + + # Sequence and query lengths. + seq_lens.extend([1] * cuda_graph_pad_size) + + # Attention metadata. + attn_metadata = self.attn_metadata_builder.build( + seq_lens, query_lens, cuda_graph_pad_size, batch_size) + + # LoRA data. + lora_requests = set() + lora_mapping = None + if self.enable_lora: + lora_requests = set(r for data in self.inter_data_list + for r in data.lora_requests) + lora_index_mapping = flatten_2d_lists([ + flatten_2d_lists(inter_data.lora_index_mapping) + for inter_data in self.inter_data_list + ]) + lora_index_mapping.extend([0] * cuda_graph_pad_size) + lora_prompt_mapping = flatten_2d_lists([ + flatten_2d_lists(inter_data.lora_prompt_mapping) + for inter_data in self.inter_data_list + ]) + lora_mapping = LoRAMapping( + **dict(index_mapping=lora_index_mapping, + prompt_mapping=lora_prompt_mapping, + is_prefill=not self.decode_only)) + + # Prompt adapter data. + prompt_adapter_requests: Set[PromptAdapterRequest] = set() + prompt_adapter_mapping = None + if self.enable_prompt_adapter: + prompt_adapter_requests = set( + data.prompt_adapter_request for data in self.inter_data_list + if data.prompt_adapter_request is not None) + prompt_adapter_index_mapping = flatten_2d_lists([ + inter_data.prompt_adapter_index_mapping + for inter_data in self.inter_data_list + ]) + prompt_adapter_index_mapping.extend([0] * cuda_graph_pad_size) + prompt_adapter_prompt_mapping = flatten_2d_lists([ + inter_data.prompt_adapter_prompt_mapping + for inter_data in self.inter_data_list + ]) + prompt_adapter_mapping = PromptAdapterMapping( + prompt_adapter_index_mapping, + prompt_adapter_prompt_mapping, + ) + + # Multi-modal data. + multi_modal_kwargs_list = [ + data.multi_modal_kwargs for data in self.inter_data_list + if data.multi_modal_kwargs is not None + ] + multi_modal_kwargs = MultiModalKwargs.batch(multi_modal_kwargs_list) + + return self.model_input_cls( + input_tokens=input_tokens_tensor, + input_positions=input_positions_tensor, + attn_metadata=attn_metadata, + seq_lens=seq_lens, + query_lens=query_lens, + lora_mapping=lora_mapping, + lora_requests=lora_requests, + multi_modal_kwargs=multi_modal_kwargs, + request_ids_to_seq_ids=request_ids_to_seq_ids, + finished_requests_ids=self.finished_requests_ids, + prompt_adapter_mapping=prompt_adapter_mapping, + prompt_adapter_requests=prompt_adapter_requests) + + class InterDataForSeqGroup: + """Intermediate data for the current sequence group.""" + + def simple_reinit(self): + self.input_tokens[0].clear() # type: ignore + self.input_positions[0].clear() # type: ignore + self.token_types[0].clear() # type: ignore + self.mrope_input_positions = None # type: ignore + self.seq_lens[0] = 0 # type: ignore + self.orig_seq_lens[0] = 0 # type: ignore + self.query_lens[0] = 0 # type: ignore + self.context_lens[0] = 0 # type: ignore + self.curr_sliding_window_blocks[0] = 0 # type: ignore + self.lora_index_mapping.clear() # type: ignore + self.lora_prompt_mapping.clear() # type: ignore + self.lora_requests.clear() # type: ignore + self.prompt_adapter_index_mapping.clear() # type: ignore + self.prompt_adapter_prompt_mapping.clear() # type: ignore + + def __init__( + self, + *, + # From sequence group metadata. + request_id: str, + seq_ids: List[int], + is_prompt: bool, + block_tables: Optional[Dict[int, List[int]]], + computed_block_nums: List[int], + n_seqs: int = 0, + + # Input tokens and positions. + input_tokens: Optional[List[List[int]]] = None, + input_positions: Optional[List[List[int]]] = None, + token_types: Optional[List[List[int]]] = None, + mrope_input_positions: Optional[List[List[List[int]]]] = None, + + # The sequence length (may be capped to the sliding window). + seq_lens: Optional[List[int]] = None, + # The original sequence length (before applying sliding window). + # This is used to compute slot mapping. + orig_seq_lens: Optional[List[int]] = None, + # The query length. + query_lens: Optional[List[int]] = None, + # The number of tokens that are already computed. + context_lens: Optional[List[int]] = None, + # The current sliding window block. + curr_sliding_window_blocks: Optional[List[int]] = None, + + # LoRA inputs. + lora_index_mapping: Optional[List[List[int]]] = None, + lora_prompt_mapping: Optional[List[List[int]]] = None, + lora_requests: Optional[Set[LoRARequest]] = None, + + # Prompt adapter inputs. + prompt_adapter_index_mapping: Optional[List[int]] = None, + prompt_adapter_prompt_mapping: Optional[List[int]] = None, + prompt_adapter_request: Optional[PromptAdapterRequest] = None, + + # Multi-modal inputs. + multi_modal_kwargs: Optional[MultiModalKwargs] = None, + multi_modal_placeholder_maps: Optional[Dict[ + str, MultiModalPlaceholderMap]] = None, + + # Whether the prefix cache is hit (prefill only). + prefix_cache_hit: bool = False, + reinit: bool = False, + reinit_use_defaults: bool = False, + encoder_seq_len: int = 0, + ): + if reinit: + assert len(self.seq_ids) == len(seq_ids) # type: ignore + for i, seq_id in enumerate(seq_ids): + self.seq_ids[i] = seq_id # type: ignore + else: + self.seq_ids = seq_ids + + self.request_id = request_id + self.is_prompt = is_prompt + self.block_tables = block_tables + self.computed_block_nums = computed_block_nums + self.n_seqs = n_seqs + self.encoder_seq_len = encoder_seq_len + + if reinit: + if len(self.seq_ids) == 1 and reinit_use_defaults: + self.simple_reinit() + else: + if input_tokens: + self.input_tokens = input_tokens + else: + for seq_id in range(len(self.seq_ids)): + self.input_tokens[seq_id].clear() + + if input_positions: + self.input_positions = input_positions + else: + for seq_id in range(len(self.seq_ids)): + self.input_positions[seq_id].clear() + + if token_types: + self.token_types = token_types + else: + for seq_id in range(len(self.seq_ids)): + self.token_types[seq_id].clear() + + self.mrope_input_positions = None + + if seq_lens: + self.seq_lens = seq_lens + else: + for seq_id in range(len(self.seq_ids)): + self.seq_lens[seq_id] = 0 + + if orig_seq_lens: + self.orig_seq_lens = orig_seq_lens + else: + for seq_id in range(len(self.seq_ids)): + self.orig_seq_lens[seq_id] = 0 + + if query_lens: + self.query_lens = query_lens + else: + for seq_id in range(len(self.seq_ids)): + self.query_lens[seq_id] = 0 + + if context_lens: + self.context_lens = context_lens + else: + for seq_id in range(len(self.seq_ids)): + self.context_lens[seq_id] = 0 + + if curr_sliding_window_blocks: + self.curr_sliding_window_blocks = \ + curr_sliding_window_blocks + else: + for seq_id in range(len(self.seq_ids)): + self.curr_sliding_window_blocks[seq_id] = 0 + + if lora_index_mapping: + self.lora_index_mapping = lora_index_mapping + else: + self.lora_index_mapping.clear() + + if lora_prompt_mapping: + self.lora_prompt_mapping = lora_prompt_mapping + else: + self.lora_prompt_mapping.clear() + + if lora_requests: + self.lora_requests = lora_requests + else: + self.lora_requests.clear() + + if prompt_adapter_index_mapping: + self.prompt_adapter_index_mapping = \ + prompt_adapter_index_mapping + else: + self.prompt_adapter_index_mapping.clear() + + if prompt_adapter_prompt_mapping: + self.prompt_adapter_prompt_mapping = \ + prompt_adapter_prompt_mapping + else: + self.prompt_adapter_prompt_mapping.clear() + + else: + self.input_tokens = input_tokens or [] + self.input_positions = input_positions or [] + self.token_types = token_types or [] + self.mrope_input_positions = mrope_input_positions or None + self.seq_lens = seq_lens or [] + self.orig_seq_lens = orig_seq_lens or [] + self.query_lens = query_lens or [] + self.context_lens = context_lens or [] + self.curr_sliding_window_blocks = \ + curr_sliding_window_blocks or [] + + self.lora_index_mapping = lora_index_mapping or [] + self.lora_prompt_mapping = lora_prompt_mapping or [] + self.lora_requests = lora_requests or set() + + self.prompt_adapter_index_mapping = ( + prompt_adapter_index_mapping or []) + self.prompt_adapter_prompt_mapping = ( + prompt_adapter_prompt_mapping or []) + + self.prompt_adapter_request = prompt_adapter_request + self.multi_modal_kwargs = multi_modal_kwargs + self.multi_modal_placeholder_maps = multi_modal_placeholder_maps + self.prefix_cache_hit = prefix_cache_hit + + self.n_seqs = len(self.seq_ids) + + if not reinit: + self.__post_init__() + + def __post_init__(self): + self.n_seqs = len(self.seq_ids) + + self.input_tokens = [[] for _ in range(self.n_seqs)] + self.input_positions = [[] for _ in range(self.n_seqs)] + self.token_types = [[] for _ in range(self.n_seqs)] + self.mrope_input_positions = None + self.seq_lens = [0] * self.n_seqs + self.orig_seq_lens = [0] * self.n_seqs + self.query_lens = [0] * self.n_seqs + self.context_lens = [0] * self.n_seqs + self.curr_sliding_window_blocks = [0] * self.n_seqs + + self.lora_index_mapping = [] + self.lora_prompt_mapping = [] + + +class NPUModelRunner(ModelRunner): + """ + NPU model runner with sampling step. + """ + _model_input_cls: Type[ModelInputForGPUWithSamplingMetadata] = ( + ModelInputForGPUWithSamplingMetadata) + _builder_cls: Type[ModelInputForNPUBuilder] = ModelInputForNPUBuilder + + def make_model_input_from_broadcasted_tensor_dict( + self, + tensor_dict: Dict[str, Any], + ) -> ModelInputForGPUWithSamplingMetadata: + model_input = \ + ModelInputForGPUWithSamplingMetadata.from_broadcasted_tensor_dict( + tensor_dict, + attn_backend=self.attn_backend, + ) + return model_input + + @current_platform.inference_mode() + def profile_run(self) -> None: + # Enable top-k sampling to reflect the accurate memory usage. + sampling_params = SamplingParams(top_p=0.99, top_k=self.vocab_size - 1) + max_num_batched_tokens = self.scheduler_config.max_num_batched_tokens + max_num_seqs = self.scheduler_config.max_num_seqs + # This represents the maximum number of different requests + # that will have unique loras, an therefore the max amount of memory + # consumption create dummy lora request copies from the lora request + # passed in, which contains a lora from the lora warmup path. + dummy_lora_requests: List[LoRARequest] = [] + dummy_lora_requests_per_seq: List[LoRARequest] = [] + if self.lora_config: + assert self.lora_manager is not None + with self.lora_manager.dummy_lora_cache(): + for idx in range(self.lora_config.max_loras): + lora_id = idx + 1 + dummy_lora_request = LoRARequest( + lora_name=f"warmup_{lora_id}", + lora_int_id=lora_id, + lora_path="/not/a/real/path", + ) + self.lora_manager.add_dummy_lora(dummy_lora_request, + rank=LORA_WARMUP_RANK) + dummy_lora_requests.append(dummy_lora_request) + dummy_lora_requests_per_seq = [ + dummy_lora_requests[idx % len(dummy_lora_requests)] + for idx in range(max_num_seqs) + ] + + # Profile memory usage with max_num_sequences sequences and the total + # number of tokens equal to max_num_batched_tokens. + seqs: List[SequenceGroupMetadata] = [] + # Additional GPU memory may be needed for multi-modal encoding, which + # needs to be accounted for when calculating the GPU blocks for + # vLLM blocker manager. + # To exercise the worst scenario for GPU memory consumption, + # the number of seqs (batch_size) is chosen to maximize the number + # of images processed. + + max_mm_tokens = self.mm_registry.get_max_multimodal_tokens( + self.model_config) + if max_mm_tokens > 0: + max_num_seqs_orig = max_num_seqs + max_num_seqs = min(max_num_seqs, + max_num_batched_tokens // max_mm_tokens) + if max_num_seqs < 1: + expr = (f"min({max_num_seqs_orig}, " + f"{max_num_batched_tokens} // {max_mm_tokens})") + logger.warning( + "Computed max_num_seqs (%s) to be less than 1. " + "Setting it to the minimum value of 1.", expr) + max_num_seqs = 1 + + batch_size = 0 + for group_id in range(max_num_seqs): + seq_len = (max_num_batched_tokens // max_num_seqs + + (group_id < max_num_batched_tokens % max_num_seqs)) + batch_size += seq_len + + dummy_data = self.input_registry \ + .dummy_data_for_profiling(self.model_config, + seq_len, + self.mm_registry) + + seq = SequenceGroupMetadata( + request_id=str(group_id), + is_prompt=True, + seq_data={group_id: dummy_data.seq_data}, + sampling_params=sampling_params, + block_tables=None, + lora_request=dummy_lora_requests_per_seq[group_id] + if dummy_lora_requests_per_seq else None, + multi_modal_data=dummy_data.multi_modal_data, + multi_modal_placeholders=dummy_data.multi_modal_placeholders, + ) + seqs.append(seq) + + # Run the model with the dummy inputs. + num_layers = self.model_config.get_num_layers(self.parallel_config) + # use an empty tensor instead of `None`` to force Dynamo to pass + # it by reference, rather by specializing on the value ``None``. + # the `dtype` argument does not matter, and we use `float32` as + # a placeholder (it has wide hardware support). + # it is important to create tensors inside the loop, rather than + # multiplying the list, to avoid Dynamo from treating them as + # tensor aliasing. + kv_caches = [ + torch.tensor([], dtype=torch.float32, device=self.device) + for _ in range(num_layers) + ] + finished_requests_ids = [seq.request_id for seq in seqs] + model_input = self.prepare_model_input( + seqs, finished_requests_ids=finished_requests_ids) + intermediate_tensors = None + if not get_pp_group().is_first_rank: + intermediate_tensors = self.model.make_empty_intermediate_tensors( + batch_size=batch_size, + dtype=self.model_config.dtype, + device=self.device) + self.execute_model(model_input, kv_caches, intermediate_tensors) + current_platform.synchronize() + return + + @current_platform.inference_mode() + def capture_model(self, kv_caches: List[List[torch.Tensor]]) -> None: + """NPU graph capture a model. + TODO: not support now + """ + pass + + def prepare_model_input( + self, + seq_group_metadata_list: List[SequenceGroupMetadata], + virtual_engine: int = 0, + finished_requests_ids: Optional[List[str]] = None, + ) -> ModelInputForGPUWithSamplingMetadata: + """Prepare the model input based on a given sequence group, including + metadata for the sampling step. + The API assumes seq_group_metadata_list is sorted by prefill -> decode. + The result tensors and data structure also batches input in prefill + -> decode order. For example, + - input_tokens[:num_prefill_tokens] contains prefill tokens. + - input_tokens[num_prefill_tokens:] contains decode tokens. + If cuda graph is required, this API automatically pads inputs. + """ + model_input = self._prepare_model_input_tensors( + seq_group_metadata_list, finished_requests_ids) + if get_pp_group().is_last_rank: + # Sampling metadata is only required for the final pp group + generators = self.get_generators(finished_requests_ids) + sampling_metadata = SamplingMetadata.prepare( + seq_group_metadata_list, + model_input.seq_lens, + model_input.query_lens, + self.device, + self.pin_memory, + generators, + self.sampling_metadata_cache, + # TODO (cmq): enable this after supported in vllm + # pad_for_invariant_seq_len=True, + ) + else: + sampling_metadata = None + is_prompt = (seq_group_metadata_list[0].is_prompt + if seq_group_metadata_list else None) + return dataclasses.replace(model_input, + sampling_metadata=sampling_metadata, + is_prompt=is_prompt, + virtual_engine=virtual_engine) + + def get_model(self) -> nn.Module: + return self.model diff --git a/vllm_ascend/ops/__init__.py b/vllm_ascend/ops/__init__.py new file mode 100644 index 000000000..bdc40cd5f --- /dev/null +++ b/vllm_ascend/ops/__init__.py @@ -0,0 +1,18 @@ +# +# Copyright (c) 2025 Huawei Technologies Co., Ltd. All Rights Reserved. +# This file is a part of the vllm-ascend project. +# +# 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 vllm_ascend.ops.layernorm # noqa diff --git a/vllm_ascend/ops/layernorm.py b/vllm_ascend/ops/layernorm.py new file mode 100644 index 000000000..719aa977d --- /dev/null +++ b/vllm_ascend/ops/layernorm.py @@ -0,0 +1,40 @@ +# +# Copyright (c) 2025 Huawei Technologies Co., Ltd. All Rights Reserved. +# This file is a part of the vllm-ascend project. +# +# 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. +# + +from typing import Optional, Tuple, Union + +import torch +from vllm.model_executor.layers.layernorm import RMSNorm + + +def forward_oot( + self, + x: torch.Tensor, + residual: Optional[torch.Tensor] = None, +) -> Union[torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]: + import torch_npu + + if residual is not None: + x, _, residual = torch_npu.npu_add_rms_norm(x, residual, self.weight, + self.variance_epsilon) + return x, residual + + x, residual = torch_npu.npu_rms_norm(x, self.weight, self.variance_epsilon) + return x + + +RMSNorm.forward_oot = forward_oot diff --git a/vllm_ascend/platform.py b/vllm_ascend/platform.py new file mode 100644 index 000000000..2b847de13 --- /dev/null +++ b/vllm_ascend/platform.py @@ -0,0 +1,115 @@ +# +# Copyright (c) 2025 Huawei Technologies Co., Ltd. All Rights Reserved. +# This file is a part of the vllm-ascend project. +# +# 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 +from typing import Optional, Tuple + +import torch + +try: + import torch_npu # noqa: F401 +except ImportError: + print("Failed to import torch_npu.") + +from vllm.config import VllmConfig +from vllm.platforms import Platform, PlatformEnum + +os.environ["RAY_EXPERIMENTAL_NOSET_ASCEND_RT_VISIBLE_DEVICES"] = "1" + + +def _device_id_to_physical_device_id(device_id: int) -> int: + if "ASCEND_RT_VISIBLE_DEVICES" in os.environ: + device_ids = os.environ["ASCEND_RT_VISIBLE_DEVICES"].split(",") + if device_ids == [""]: + raise RuntimeError("ASCEND_RT_VISIBLE_DEVICES is set to empty" + "string, which means Ascend NPU support is" + "disabled.") + physical_device_id = device_ids[device_id] + return int(physical_device_id) + else: + return device_id + + +class NPUPlatform(Platform): + + _enum = PlatformEnum.OOT + device_name: str = "npu" + device_type: str = "npu" + simple_compile_backend: str = "npu" + ray_device_key: str = "NPU" + device_control_env_var: str = "ASCEND_RT_VISIBLE_DEVICES" + + @classmethod + def get_device_capability(cls, device_id: int = 0): + return None + + @classmethod + def get_device_name(cls, device_id: int = 0) -> str: + physical_device_id = _device_id_to_physical_device_id(device_id) + return torch.npu.get_device_name(physical_device_id) + + @classmethod + def is_async_output_supported(cls, enforce_eager: Optional[bool]) -> bool: + return True + + @classmethod + def inference_mode(cls): + return torch.inference_mode() + + @classmethod + def set_device(cls, device: torch.device): + torch.npu.set_device(device) + + @classmethod + def empty_cache(cls): + torch.npu.empty_cache() + + @classmethod + def synchronize(cls): + torch.npu.synchronize() + + @classmethod + def mem_get_info(cls) -> Tuple[int, int]: + return torch.npu.mem_get_info() + + @classmethod + def check_and_update_config(cls, vllm_config: VllmConfig) -> None: + # Register ops when setup. + from vllm_ascend import ops # noqa: F401 + + parallel_config = vllm_config.parallel_config + if parallel_config.worker_cls == "auto": + parallel_config.worker_cls = "vllm_ascend.worker.NPUWorker" + cache_config = vllm_config.cache_config + if cache_config and cache_config.block_size is None: + cache_config.block_size = 16 + + @classmethod + def get_attn_backend_cls(cls, selected_backend, head_size, dtype, + kv_cache_dtype, block_size, use_v1, use_mla): + return "vllm_ascend.attention.AscendAttentionBackend" + + @classmethod + def get_current_memory_usage(cls, + device: Optional[torch.types.Device] = None + ) -> float: + torch.npu.reset_peak_memory_stats(device) + return torch.npu.max_memory_allocated(device) + + @classmethod + def get_device_communicator_cls(cls) -> str: + return "vllm_ascend.communicator.NPUCommunicator" diff --git a/vllm_ascend/worker.py b/vllm_ascend/worker.py new file mode 100644 index 000000000..8ddd5302e --- /dev/null +++ b/vllm_ascend/worker.py @@ -0,0 +1,481 @@ +# +# Copyright (c) 2025 Huawei Technologies Co., Ltd. All Rights Reserved. +# This file is a part of the vllm-ascend project. +# Adapted from vllm-project/vllm/vllm/worker/worker.py +# Copyright 2023 The vLLM team. +# +# 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 gc +from typing import Dict, List, Optional, Set, Tuple, Type, Union + +import torch +import torch.distributed +import torch_npu +from torch import nn +from vllm import envs +from vllm.config import ParallelConfig, VllmConfig +from vllm.distributed import (ensure_model_parallel_initialized, + init_distributed_environment, + set_custom_all_reduce) +from vllm.logger import init_logger +from vllm.lora.request import LoRARequest +from vllm.model_executor import set_random_seed +from vllm.model_executor.layers.sampler import SamplerOutput +from vllm.model_executor.model_loader.tensorizer import TensorizerConfig +from vllm.platforms import current_platform +from vllm.prompt_adapter.request import PromptAdapterRequest +from vllm.sequence import (ExecuteModelRequest, IntermediateTensors, + SequenceGroupMetadata, SequenceGroupMetadataDelta) +from vllm.utils import bind_kv_cache +from vllm.worker.cache_engine import CacheEngine +from vllm.worker.enc_dec_model_runner import EncoderDecoderModelRunner +from vllm.worker.model_runner_base import ModelRunnerBase +from vllm.worker.pooling_model_runner import PoolingModelRunner +from vllm.worker.worker_base import (LocalOrDistributedWorkerBase, WorkerBase, + WorkerInput) + +from vllm_ascend.model_runner import NPUModelRunner + +logger = init_logger(__name__) + + +class NPUWorker(LocalOrDistributedWorkerBase): + """A worker class that executes (a partition of) the model on a NPU. + Each worker is associated with a single NPU. The worker is responsible for + maintaining the KV cache and executing the model on the NPU. In case of + distributed inference, each worker is assigned a partition of the model. + """ + + def __init__( + self, + vllm_config: VllmConfig, + local_rank: int, + rank: int, + distributed_init_method: str, + is_driver_worker: bool = False, + model_runner_cls: Optional[Type[ModelRunnerBase]] = None, + ) -> None: + + WorkerBase.__init__(self, vllm_config=vllm_config) + # distribute related config + self.parallel_config.rank = rank + self.local_rank = local_rank + self.rank = rank + self.distributed_init_method = distributed_init_method + self.is_driver_worker = is_driver_worker + + if is_driver_worker: + assert rank % self.parallel_config.tensor_parallel_size == 0, \ + "Driver worker should be rank 0 of tensor parallel group." + if self.model_config.trust_remote_code: + # note: lazy import to avoid importing torch before initializing + from vllm.utils import init_cached_hf_modules + init_cached_hf_modules() + + # Return hidden states from target model if the draft model is an + # mlp_speculator + speculative_config = self.speculative_config + model_config = self.model_config + speculative_args = {} if speculative_config is None \ + or (speculative_config.draft_model_config.model == + model_config.model) \ + or (speculative_config.draft_model_config.hf_config.model_type + not in ["medusa", "mlp_speculator", "eagle"]) \ + else {"return_hidden_states": True} + + ModelRunnerClass: Type[ModelRunnerBase] = NPUModelRunner + if model_config.runner_type == "pooling": + ModelRunnerClass = PoolingModelRunner + elif self.model_config.is_encoder_decoder: + ModelRunnerClass = EncoderDecoderModelRunner + self.model_runner: ModelRunnerBase = ModelRunnerClass( + vllm_config=self.vllm_config, + kv_cache_dtype=self.cache_config.cache_dtype, + is_driver_worker=is_driver_worker, + **speculative_args, + ) + if model_runner_cls is not None: + self.model_runner = model_runner_cls(self.model_runner) + + # Uninitialized cache engine. Will be initialized by + # initialize_cache. + self.cache_engine: List[CacheEngine] + # Initialize gpu_cache as embedding models don't initialize kv_caches + self.gpu_cache: Optional[List[List[torch.Tensor]]] = None + self._seq_group_metadata_cache: Dict[str, SequenceGroupMetadata] = {} + + # Torch profiler. Enabled and configured through env vars: + # VLLM_TORCH_PROFILER_DIR=/path/to/save/trace + if envs.VLLM_TORCH_PROFILER_DIR: + torch_profiler_trace_dir = envs.VLLM_TORCH_PROFILER_DIR + logger.info("Profiling enabled. Traces will be saved to: %s", + torch_profiler_trace_dir) + + experimental_config = torch_npu.profiler._ExperimentalConfig( + export_type=torch_npu.profiler.ExportType.Text, + profiler_level=torch_npu.profiler.ProfilerLevel.Level0, + msprof_tx=False, + aic_metrics=torch_npu.profiler.AiCMetrics.AiCoreNone, + l2_cache=False, + op_attr=False, + data_simplification=False, + record_op_args=False, + gc_detect_threshold=None, + ) + + self.profiler = torch_npu.profiler.profile( + activities=[ + torch_npu.profiler.ProfilerActivity.CPU, + torch_npu.profiler.ProfilerActivity.NPU, + ], + with_stack=True, + profile_memory=True, + with_modules=True, + experimental_config=experimental_config, + on_trace_ready=torch_npu.profiler.tensorboard_trace_handler( + torch_profiler_trace_dir)) + else: + self.profiler = None + + def start_profile(self): + if self.profiler is None: + raise RuntimeError("Profiler is not enabled.") + self.profiler.start() + + def stop_profile(self): + if self.profiler is None: + raise RuntimeError("Profiler is not enabled.") + self.profiler.stop() + + def init_device(self) -> None: + if self.device_config.device.type == "npu": + # # This env var set by Ray causes exceptions with graph building. + # os.environ.pop("NCCL_ASYNC_ERROR_HANDLING", None) + self.device = torch.device(f"npu:{self.local_rank}") + current_platform.set_device(self.device) + + current_platform.empty_cache() + self.init_npu_memory = current_platform.mem_get_info()[0] + else: + raise RuntimeError( + f"Not support device type: {self.device_config.device}") + # Initialize the distributed environment. + init_worker_distributed_environment(self.parallel_config, self.rank, + self.distributed_init_method, + self.local_rank) + # Set random seed. + set_random_seed(self.model_config.seed) + + def load_model(self): + self.model_runner.load_model() + + def save_sharded_state( + self, + path: str, + pattern: Optional[str] = None, + max_size: Optional[int] = None, + ) -> None: + self.model_runner.save_sharded_state( + path, + pattern=pattern, + max_size=max_size, + ) + + def save_tensorized_model( + self, + tensorizer_config: TensorizerConfig, + ) -> None: + self.model_runner.save_tensorized_model( + tensorizer_config=tensorizer_config, ) + + @current_platform.inference_mode() + def determine_num_available_blocks(self) -> Tuple[int, int]: + """Profiles the peak memory usage of the model to determine how many + KV blocks may be allocated without OOMs. + The engine will first conduct a profiling of the existing memory usage. + Then, it calculate the maximum possible number of NPU and CPU blocks + that can be allocated with the remaining free memory. + .. tip:: + You may limit the usage of NPU memory + by adjusting the `gpu_memory_utilization` parameter. + """ + # Profile the memory usage of the model and get the maximum number of + # cache blocks that can be allocated with the remaining free memory. + current_platform.empty_cache() + + # Execute a forward pass with dummy inputs to profile the memory usage + # of the model. + self.model_runner.profile_run() + + # Calculate the number of blocks that can be allocated with the + # profiled peak memory. + free_npu_memory, total_npu_memory = current_platform.mem_get_info() + # NOTE(woosuk): Here we assume that the other processes using the same + # GPU did not change their memory usage during the profiling. + peak_memory = self.init_npu_memory - free_npu_memory + assert peak_memory > 0, ( + "Error in memory profiling. " + f"Initial free memory {self.init_npu_memory}, current free memory" + f" {free_npu_memory}. This happens when the NPU memory was " + "not properly cleaned up before initializing the vLLM instance.") + + cache_block_size = self.get_cache_block_size_bytes() + num_npu_blocks = int( + (total_npu_memory * self.cache_config.gpu_memory_utilization - + peak_memory) // cache_block_size) + num_cpu_blocks = int(self.cache_config.swap_space_bytes // + cache_block_size) + num_npu_blocks = max(num_npu_blocks, 0) + num_cpu_blocks = max(num_cpu_blocks, 0) + if self.model_runner.lora_manager: + self.model_runner.remove_all_loras() + gc.collect() + # TODO: don`t need impl this func after empty_cache in + # Worker.determine_num_available_blocks() unified` + current_platform.empty_cache() + return num_npu_blocks, num_cpu_blocks + + def initialize_cache(self, num_gpu_blocks: int, + num_cpu_blocks: int) -> None: + """Allocate NPU and CPU KV cache with the specified number of blocks. + """ + raise_if_cache_size_invalid(num_gpu_blocks, + self.cache_config.block_size, + self.cache_config.is_attention_free, + self.model_config.max_model_len) + + self.cache_config.num_gpu_blocks = num_gpu_blocks + self.cache_config.num_cpu_blocks = num_cpu_blocks + + self._init_cache_engine() + self._warm_up_model() + + def _init_cache_engine(self): + assert self.cache_config.num_gpu_blocks is not None + self.cache_engine = [ + CacheEngine(self.cache_config, self.model_config, + self.parallel_config, self.device_config) + for _ in range(self.parallel_config.pipeline_parallel_size) + ] + self.gpu_cache = [ + self.cache_engine[ve].gpu_cache + for ve in range(self.parallel_config.pipeline_parallel_size) + ] + bind_kv_cache(self.compilation_config.static_forward_context, + self.gpu_cache) + + def _warm_up_model(self) -> None: + # model capture is not supported, thus we just set seed here. + # Reset the seed to ensure that the random state is not affected by + # the model initialization and profiling. + set_random_seed(self.model_config.seed) + + @property + def do_metadata_broadcast(self) -> bool: + return self.parallel_config.tensor_parallel_size > 1 + + @property + def kv_cache(self) -> Optional[List[List[torch.Tensor]]]: + return self.gpu_cache + + @torch.inference_mode() + def prepare_worker_input( + self, execute_model_req: ExecuteModelRequest) -> WorkerInput: + virtual_engine = execute_model_req.virtual_engine + num_steps = execute_model_req.num_steps + num_seq_groups = len(execute_model_req.seq_group_metadata_list) + # `blocks_to_swap_in` and `blocks_to_swap_out` are cpu tensors. + # they contain parameters to launch cudamemcpyasync. + blocks_to_swap_in = torch.tensor(execute_model_req.blocks_to_swap_in, + device="cpu", + dtype=torch.int64).view(-1, 2) + blocks_to_swap_out = torch.tensor(execute_model_req.blocks_to_swap_out, + device="cpu", + dtype=torch.int64).view(-1, 2) + # `blocks_to_copy` is a gpu tensor. The src and tgt of + # blocks to copy are in the same device, and `blocks_to_copy` + # can be used directly within cuda kernels. + blocks_to_copy = torch.tensor(execute_model_req.blocks_to_copy, + device=self.device, + dtype=torch.int64).view(-1, 2) + + return WorkerInput( + num_seq_groups=num_seq_groups, + blocks_to_swap_in=blocks_to_swap_in, + blocks_to_swap_out=blocks_to_swap_out, + blocks_to_copy=blocks_to_copy, + virtual_engine=virtual_engine, + num_steps=num_steps, + ) + + def get_model(self) -> nn.Module: + return self.model_runner.get_model() + + @torch.inference_mode() + def execute_worker(self, worker_input: WorkerInput) -> None: + virtual_engine = worker_input.virtual_engine + # Issue cache operations. + if (worker_input.blocks_to_swap_in is not None + and worker_input.blocks_to_swap_in.numel() > 0): + self.cache_engine[virtual_engine].swap_in( + worker_input.blocks_to_swap_in) + if (worker_input.blocks_to_swap_out is not None + and worker_input.blocks_to_swap_out.numel() > 0): + self.cache_engine[virtual_engine].swap_out( + worker_input.blocks_to_swap_out) + if (worker_input.blocks_to_copy is not None + and worker_input.blocks_to_copy.numel() > 0): + self.cache_engine[virtual_engine].copy(worker_input.blocks_to_copy) + + def _get_cached_seq_group_metadata( + self, + seq_group_metadata_list: List[Union[SequenceGroupMetadata, + SequenceGroupMetadataDelta]], + finished_request_ids: List[str]) -> List[SequenceGroupMetadata]: + """Return a list of cached Sequence Group Metadata after updating its + state. + + It is used because scheduler only sends delta to workers to reduce + the data payload size. The function also cleans up cache based on + a given `finished_request_ids`. + """ + new_seq_group_metadata_list = [] + for metadata_or_delta in seq_group_metadata_list: + request_id = metadata_or_delta.request_id + if request_id not in self._seq_group_metadata_cache: + # The first prefill. + assert isinstance(metadata_or_delta, SequenceGroupMetadata) + self._seq_group_metadata_cache[request_id] = metadata_or_delta + else: + # The first prefill is already cached. + if isinstance(metadata_or_delta, SequenceGroupMetadataDelta): + self._seq_group_metadata_cache[request_id].apply_delta( + metadata_or_delta) + else: + # If metadata snapshot is sent again, it is + # preempted. Reset the cache because we need to start + # from scratch. + assert isinstance(metadata_or_delta, SequenceGroupMetadata) + self._seq_group_metadata_cache[ + request_id] = metadata_or_delta + + new_seq_group_metadata_list.append( + self._seq_group_metadata_cache[request_id]) + + # Clean up finished ids + for finished_id in finished_request_ids: + del self._seq_group_metadata_cache[finished_id] + + return new_seq_group_metadata_list + + def _execute_model_spmd( + self, + execute_model_req: ExecuteModelRequest, + intermediate_tensors: Optional[IntermediateTensors] = None, + ) -> Optional[List[SamplerOutput]]: + if execute_model_req is not None: + new_seq_group_metadata_list = self._get_cached_seq_group_metadata( + execute_model_req.seq_group_metadata_list, + execute_model_req.finished_requests_ids) + + execute_model_req.seq_group_metadata_list = ( + new_seq_group_metadata_list) + output = super()._execute_model_spmd(execute_model_req, + intermediate_tensors) + return output + + def add_lora(self, lora_request: LoRARequest) -> bool: + raise NotImplementedError( + "LoRA is not implemented for NPU backend currently.") + + def remove_lora(self, lora_id: int) -> bool: + raise NotImplementedError( + "LoRA is not implemented for NPU backend currently.") + + def pin_lora(self, lora_id: int) -> bool: + raise NotImplementedError( + "LoRA is not implemented for NPU backend currently.") + + def list_loras(self) -> Set[int]: + raise NotImplementedError( + "LoRA is not implemented for NPU backend currently.") + + def add_prompt_adapter( + self, prompt_adapter_request: PromptAdapterRequest) -> bool: + raise NotImplementedError( + "Prompt Adapter is not implemented for NPU backend currently.") + + def remove_prompt_adapter(self, prompt_adapter_id: int) -> bool: + raise NotImplementedError( + "Prompt Adapter is not implemented for NPU backend currently.") + + def pin_prompt_adapter(self, prompt_adapter_id: int) -> bool: + raise NotImplementedError( + "Prompt Adapter is not implemented for NPU backend currently.") + + def list_prompt_adapters(self) -> Set[int]: + raise NotImplementedError( + "Prompt Adapter is not implemented for NPU backend currently.") + + @property + def max_model_len(self) -> int: + return self.model_config.max_model_len + + @property + def vocab_size(self) -> int: + return self.model_runner.vocab_size + + def get_cache_block_size_bytes(self) -> int: + """Get the size of the KV cache block size in bytes. + """ + return CacheEngine.get_cache_block_size(self.cache_config, + self.model_config, + self.parallel_config) + + +def init_worker_distributed_environment( + parallel_config: ParallelConfig, + rank: int, + distributed_init_method: Optional[str] = None, + local_rank: int = -1, + backend: str = "hccl") -> None: + """Initialize the distributed environment.""" + set_custom_all_reduce(not parallel_config.disable_custom_all_reduce) + + init_distributed_environment(parallel_config.world_size, rank, + distributed_init_method, local_rank, backend) + + ensure_model_parallel_initialized(parallel_config.tensor_parallel_size, + parallel_config.pipeline_parallel_size) + + +def raise_if_cache_size_invalid(num_gpu_blocks, block_size, is_attention_free, + max_model_len) -> None: + if is_attention_free and num_gpu_blocks != 0: + raise ValueError("No memory should be allocated for the cache blocks " + f"for an attention-free model, but {num_gpu_blocks}" + "blocks are allocated.") + if not is_attention_free and num_gpu_blocks <= 0: + raise ValueError("No available memory for the cache blocks. " + "Try increasing `gpu_memory_utilization` when " + "initializing the engine.") + max_seq_len = block_size * num_gpu_blocks + if not is_attention_free and max_model_len > max_seq_len: + raise ValueError( + f"The model's max seq len ({max_model_len}) " + "is larger than the maximum number of tokens that can be " + f"stored in KV cache ({max_seq_len}). Try increasing " + "`gpu_memory_utilization` or decreasing `max_model_len` when " + "initializing the engine.")