lmcache 0.4.7__tar.gz → 0.4.8.dev24__tar.gz

lmcache-0.4.8.dev24/.buildkite/k3_tests/comprehensive/pipeline.yml

@@ -0,0 +1,143 @@
+# Comprehensive integration tests — one step per config, run in parallel.
+# Each step gets its own K8s pod with the exact GPU count it needs.
+# 2-GPU group is listed first so these heavier jobs get scheduled before 1-GPU jobs.
+
+x-perf-retry: &perf-retry
+  automatic:
+    - exit_status: -1
+      limit: 2
+    - exit_status: 1
+      limit: 2
+
+steps:
+  - group: ":test_tube: Comprehensive (2-GPU)"
+    steps:
+      - label: ":test_tube: pd"
+        command: .buildkite/k3_tests/comprehensive/run.sh pd.yaml
+        timeout_in_minutes: 30
+        retry: *perf-retry
+        agents: { queue: "k8s" }
+        plugins:
+          - kubernetes:
+              podSpec: &pod-2gpu
+                containers:
+                  - name: container-0
+                    image: lmcache/ci-base:latest
+                    imagePullPolicy: Never
+                    resources: { limits: { "nvidia.com/gpu": "2" } }
+                    volumeMounts: &vol-mounts
+                      - { name: hf-cache, mountPath: /root/.cache/huggingface }
+                      - { name: datasets, mountPath: /root/correctness }
+                volumes: &vols
+                  - { name: hf-cache, hostPath: { path: /data/huggingface, type: DirectoryOrCreate } }
+                  - { name: datasets, hostPath: { path: /data/datasets, type: DirectoryOrCreate } }
+        artifact_paths: ["*.log", "benchmarks/long_doc_qa/*.json"]
+
+      - label: ":test_tube: p2p"
+        command: .buildkite/k3_tests/comprehensive/run.sh p2p.yaml
+        timeout_in_minutes: 30
+        retry: *perf-retry
+        agents: { queue: "k8s" }
+        plugins: [{ kubernetes: { podSpec: *pod-2gpu } }]
+        artifact_paths: ["*.log", "benchmarks/long_doc_qa/*.json"]
+
+      - label: ":test_tube: p2p_with_v3"
+        command: .buildkite/k3_tests/comprehensive/run.sh p2p_with_v3.yaml
+        timeout_in_minutes: 30
+        retry: *perf-retry
+        agents: { queue: "k8s" }
+        plugins: [{ kubernetes: { podSpec: *pod-2gpu } }]
+        artifact_paths: ["*.log", "benchmarks/long_doc_qa/*.json"]
+
+  - group: ":test_tube: Comprehensive (1-GPU)"
+    steps:
+      - label: ":test_tube: local_cpu"
+        command: .buildkite/k3_tests/comprehensive/run.sh local_cpu.yaml
+        timeout_in_minutes: 30
+        retry: *perf-retry
+        agents: { queue: "k8s" }
+        plugins:
+          - kubernetes:
+              podSpec: &pod-1gpu
+                containers:
+                  - name: container-0
+                    image: lmcache/ci-base:latest
+                    imagePullPolicy: Never
+                    resources: { limits: { "nvidia.com/gpu": "1" } }
+                    volumeMounts: *vol-mounts
+                volumes: *vols
+        artifact_paths: ["*.log", "benchmarks/long_doc_qa/*.json"]
+
+      - label: ":test_tube: local_disk"
+        command: .buildkite/k3_tests/comprehensive/run.sh local_disk.yaml
+        timeout_in_minutes: 30
+        retry: *perf-retry
+        agents: { queue: "k8s" }
+        plugins: [{ kubernetes: { podSpec: *pod-1gpu } }]
+        artifact_paths: ["*.log", "benchmarks/long_doc_qa/*.json"]
+
+      - label: ":test_tube: async"
+        command: .buildkite/k3_tests/comprehensive/run.sh async.yaml
+        timeout_in_minutes: 30
+        retry: *perf-retry
+        agents: { queue: "k8s" }
+        plugins: [{ kubernetes: { podSpec: *pod-1gpu } }]
+        artifact_paths: ["*.log", "benchmarks/long_doc_qa/*.json"]
+
+      - label: ":test_tube: local_cpu_with_v3"
+        command: .buildkite/k3_tests/comprehensive/run.sh local_cpu_with_v3.yaml
+        timeout_in_minutes: 30
+        retry: *perf-retry
+        agents: { queue: "k8s" }
+        plugins: [{ kubernetes: { podSpec: *pod-1gpu } }]
+        artifact_paths: ["*.log", "benchmarks/long_doc_qa/*.json"]
+
+      - label: ":test_tube: local_disk_with_v3"
+        command: .buildkite/k3_tests/comprehensive/run.sh local_disk_with_v3.yaml
+        timeout_in_minutes: 30
+        retry: *perf-retry
+        agents: { queue: "k8s" }
+        plugins: [{ kubernetes: { podSpec: *pod-1gpu } }]
+        artifact_paths: ["*.log", "benchmarks/long_doc_qa/*.json"]
+
+      - label: ":test_tube: multi_device"
+        command: .buildkite/k3_tests/comprehensive/run.sh multi_device.yaml
+        timeout_in_minutes: 30
+        retry: *perf-retry
+        agents: { queue: "k8s" }
+        plugins: [{ kubernetes: { podSpec: *pod-1gpu } }]
+        artifact_paths: ["*.log", "benchmarks/long_doc_qa/*.json"]
+
+      - label: ":test_tube: layerwise"
+        command: .buildkite/k3_tests/comprehensive/run.sh layerwise.yaml
+        timeout_in_minutes: 30
+        retry: *perf-retry
+        agents: { queue: "k8s" }
+        plugins: [{ kubernetes: { podSpec: *pod-1gpu } }]
+        artifact_paths: ["*.log", "benchmarks/long_doc_qa/*.json"]
+
+  # Nightly baseline upload: only runs when NEED_UPLOAD=true (scheduled build).
+  # Collects date-stamped baseline artifacts from all config steps,
+  # prunes files older than 5 days, and pushes a single commit to benchmarks-main.
+  - wait: ~
+    if: build.env("NEED_UPLOAD") == "true"
+
+  - label: ":arrow_up: Upload rolling baselines"
+    if: build.env("NEED_UPLOAD") == "true"
+    command: .buildkite/k3_tests/comprehensive/scripts/upload-baselines.sh
+    timeout_in_minutes: 5
+    agents: { queue: "k8s" }
+    plugins:
+      - kubernetes:
+          podSpec:
+            containers:
+              - name: container-0
+                image: lmcache/ci-base:latest
+                imagePullPolicy: Never
+                resources: { limits: { cpu: "1", memory: "2Gi" } }
+                env:
+                  - name: GITHUB_TOKEN
+                    valueFrom:
+                      secretKeyRef:
+                        name: buildkite-git-creds
+                        key: GITHUB_TOKEN

lmcache-0.4.8.dev24/.buildkite/k3_tests/multiprocess/pipeline.yml

@@ -0,0 +1,221 @@
+# Multiprocess tests — one step per test, run in parallel.
+# Each step gets its own K8s pod with the exact GPU count it needs.
+# Tests are grouped by GPU requirement; the 2-GPU group is listed first so
+# these heavier jobs get scheduled before 1-GPU jobs.
+#   2-GPU: LMCache+vLLM on GPU 0, baseline on GPU 1 (or TP=2 across both).
+#   1-GPU: LMCache+vLLM on GPU 0 only (no baseline server).
+
+steps:
+  - group: ":compression: Multiprocess (2-GPU)"
+    steps:
+      - label: ":compression: vllm_bench"
+        command: .buildkite/k3_tests/multiprocess/run.sh vllm_bench
+        timeout_in_minutes: 30
+        agents: { queue: "k8s" }
+        plugins:
+          - kubernetes:
+              podSpec: &pod-2gpu
+                containers:
+                  - name: container-0
+                    image: lmcache/ci-base:latest
+                    imagePullPolicy: Never
+                    resources: { limits: { "nvidia.com/gpu": "2" } }
+                    volumeMounts: &vol-mounts
+                      - { name: hf-cache, mountPath: /root/.cache/huggingface }
+                volumes: &vols
+                  - { name: hf-cache, hostPath: { path: /data/huggingface, type: DirectoryOrCreate } }
+        artifact_paths: ["*.log"]
+
+      - label: ":compression: long_doc_qa"
+        command: .buildkite/k3_tests/multiprocess/run.sh long_doc_qa
+        timeout_in_minutes: 30
+        agents: { queue: "k8s" }
+        plugins: [{ kubernetes: { podSpec: *pod-2gpu } }]
+        artifact_paths: ["*.log"]
+
+      - label: ":compression: long_doc_qa_l2"
+        command: .buildkite/k3_tests/multiprocess/run.sh long_doc_qa_l2
+        timeout_in_minutes: 30
+        agents: { queue: "k8s" }
+        plugins: [{ kubernetes: { podSpec: *pod-2gpu } }]
+        artifact_paths: ["*.log"]
+
+      - label: ":compression: deadlock"
+        command: .buildkite/k3_tests/multiprocess/run.sh deadlock
+        timeout_in_minutes: 30
+        agents: { queue: "k8s" }
+        plugins: [{ kubernetes: { podSpec: *pod-2gpu } }]
+        artifact_paths: ["*.log"]
+
+  - group: ":compression: Multiprocess (1-GPU)"
+    steps:
+      - label: ":compression: lm_eval"
+        command: .buildkite/k3_tests/multiprocess/run.sh lm_eval
+        timeout_in_minutes: 30
+        agents: { queue: "k8s" }
+        plugins:
+          - kubernetes:
+              podSpec: &pod-1gpu
+                containers:
+                  - name: container-0
+                    image: lmcache/ci-base:latest
+                    imagePullPolicy: Never
+                    resources: { limits: { "nvidia.com/gpu": "1" } }
+                    volumeMounts: *vol-mounts
+                volumes: *vols
+        artifact_paths: ["*.log"]
+
+      # HMA correctness check on google/gemma-4-31B-it (a hybrid model whose KV
+      # cache groups get different block sizes). Runs gsm8k, resets vLLM's prefix
+      # cache (LMCache preserved), reruns served by LMCache, and asserts the two
+      # runs' scores match. Single GPU, no baseline.
+      - label: ":compression: hma_lm_eval_gemma4"
+        command: .buildkite/k3_tests/multiprocess/run.sh hma_lm_eval_gemma4
+        timeout_in_minutes: 60
+        env:
+          MODEL: "google/gemma-4-31B-it"
+          # Allow a small score difference between the two runs.
+          SCORE_TOLERANCE: "0.03"
+          ATTENTION_BACKEND: "auto"
+          GPU_MEMORY_UTILIZATION: "0.85"
+          # 31B load + CUDA-graph capture is slow; raise the readiness timeout
+          # above the 300s default.
+          MAX_WAIT_SECONDS: "600"
+          # Cap samples and enlarge the CPU pool so the retrieve run stays
+          # cache-served (31B's per-token KV is large).
+          LIMIT: "100"
+          CPU_BUFFER_SIZE: "200"
+        agents: { queue: "k8s" }
+        plugins: [{ kubernetes: { podSpec: *pod-1gpu } }]
+        artifact_paths: ["*.log"]
+
+      - label: ":compression: fault_tolerance"
+        command: .buildkite/k3_tests/multiprocess/run.sh fault_tolerance
+        timeout_in_minutes: 30
+        agents: { queue: "k8s" }
+        plugins: [{ kubernetes: { podSpec: *pod-1gpu } }]
+        artifact_paths: ["*.log"]
+
+      - label: ":compression: restart_recovery"
+        command: .buildkite/k3_tests/multiprocess/run.sh restart_recovery
+        timeout_in_minutes: 30
+        agents: { queue: "k8s" }
+        plugins: [{ kubernetes: { podSpec: *pod-1gpu } }]
+        artifact_paths: ["*.log"]
+
+      - label: ":compression: cache_stats"
+        command: .buildkite/k3_tests/multiprocess/run.sh cache_stats
+        timeout_in_minutes: 30
+        agents: { queue: "k8s" }
+        plugins: [{ kubernetes: { podSpec: *pod-1gpu } }]
+        artifact_paths: ["*.log"]
+
+      - label: ":compression: http_api"
+        command: .buildkite/k3_tests/multiprocess/run.sh http_api
+        timeout_in_minutes: 30
+        agents: { queue: "k8s" }
+        plugins: [{ kubernetes: { podSpec: *pod-1gpu } }]
+        artifact_paths: ["*.log"]
+
+      - label: ":compression: gds_smoke_test"
+        command: .buildkite/k3_tests/multiprocess/run.sh gds_smoke_test
+        timeout_in_minutes: 30
+        agents: { queue: "k8s" }
+        plugins:
+          - kubernetes:
+              podSpec:
+                containers:
+                  - name: container-0
+                    image: lmcache/ci-base:latest
+                    imagePullPolicy: Never
+                    resources: { limits: { "nvidia.com/gpu": "1" } }
+                    volumeMounts:
+                      - { name: hf-cache, mountPath: /root/.cache/huggingface }
+                      - { name: scratch, mountPath: /scratch }
+                      - { name: udev, mountPath: /run/udev, readOnly: true }
+                volumes:
+                  - { name: hf-cache, hostPath: { path: /data/huggingface, type: DirectoryOrCreate } }
+                  - { name: scratch, hostPath: { path: /data/gds-scratch, type: DirectoryOrCreate } }
+                  - { name: udev, hostPath: { path: /run/udev, type: Directory } }
+        artifact_paths: ["*.log"]
+
+  - group: ":compression: Multiprocess (CPU-only)"
+    steps:
+      - label: ":compression: cpu_e2e_validation (shm)"
+        command: bash .github/scripts/run-cpu-e2e-validation.sh
+        timeout_in_minutes: 30
+        agents: { queue: "k8s" }
+        plugins:
+          - kubernetes:
+              podSpec:
+                containers:
+                  - name: container-0
+                    image: lmcache/ci-base:latest
+                    imagePullPolicy: Never
+                    resources:
+                      requests:
+                        cpu: "8"
+                        memory: "256Gi"
+                      limits:
+                        cpu: "8"
+                        memory: "256Gi"
+                    volumeMounts:
+                      - { name: hf-cache, mountPath: /root/.cache/huggingface }
+                      - { name: dshm, mountPath: /dev/shm }
+                volumes:
+                  - { name: hf-cache, hostPath: { path: /data/huggingface, type: DirectoryOrCreate } }
+                  - { name: dshm, emptyDir: { medium: Memory, sizeLimit: 4Gi } }
+
+      - label: ":compression: cpu_e2e_validation (pickle)"
+        command: bash .github/scripts/run-cpu-e2e-validation.sh
+        env:
+          LMCACHE_SHM_NAME: ""
+        timeout_in_minutes: 30
+        agents: { queue: "k8s" }
+        plugins:
+          - kubernetes:
+              podSpec:
+                containers:
+                  - name: container-0
+                    image: lmcache/ci-base:latest
+                    imagePullPolicy: Never
+                    resources:
+                      requests:
+                        cpu: "8"
+                        memory: "256Gi"
+                      limits:
+                        cpu: "8"
+                        memory: "256Gi"
+                    volumeMounts:
+                      - { name: hf-cache, mountPath: /root/.cache/huggingface }
+                      - { name: dshm, mountPath: /dev/shm }
+                volumes:
+                  - { name: hf-cache, hostPath: { path: /data/huggingface, type: DirectoryOrCreate } }
+                  - { name: dshm, emptyDir: { medium: Memory, sizeLimit: 4Gi } }
+
+      - label: ":compression: cpu_e2e_validation (server-side copy)"
+        command: bash .github/scripts/run-cpu-e2e-validation.sh
+        env:
+          LMCACHE_MP_TRANSFER_MODE: "lmcache_driven"
+        timeout_in_minutes: 30
+        agents: { queue: "k8s" }
+        plugins:
+          - kubernetes:
+              podSpec:
+                containers:
+                  - name: container-0
+                    image: lmcache/ci-base:latest
+                    imagePullPolicy: Never
+                    resources:
+                      requests:
+                        cpu: "8"
+                        memory: "256Gi"
+                      limits:
+                        cpu: "8"
+                        memory: "256Gi"
+                    volumeMounts:
+                      - { name: hf-cache, mountPath: /root/.cache/huggingface }
+                      - { name: dshm, mountPath: /dev/shm }
+                volumes:
+                  - { name: hf-cache, hostPath: { path: /data/huggingface, type: DirectoryOrCreate } }
+                  - { name: dshm, emptyDir: { medium: Memory, sizeLimit: 4Gi } }

lmcache-0.4.8.dev24/.buildkite/k3_tests/sglang/pipeline.yml

@@ -0,0 +1,54 @@
+# SGLang + LMCache MP integration tests.
+# 1) Correctness: LMCache does not change output, and is actually exercised.
+# 2) Performance: LMCache makes TTFT smaller.
+
+steps:
+  - label: ":test_tube: SGLang+LMCache — Correctness"
+    command: .buildkite/k3_tests/sglang/run.sh correctness
+    timeout_in_minutes: 15
+    agents: { queue: "k8s" }
+    plugins:
+      - kubernetes:
+          podSpec:
+            containers:
+              - name: container-0
+                image: lmcache/ci-base:latest
+                imagePullPolicy: Never
+                resources:
+                  limits:
+                    nvidia.com/gpu: "1"
+                volumeMounts:
+                  - { name: hf-cache, mountPath: /root/.cache/huggingface }
+            volumes:
+              - { name: hf-cache, hostPath: { path: /data/huggingface, type: DirectoryOrCreate } }
+    artifact_paths:
+      - "*.log"
+      - "*.json"
+
+  - label: ":zap: SGLang+LMCache — Performance"
+    command: .buildkite/k3_tests/sglang/run.sh perf
+    timeout_in_minutes: 15
+    retry:
+      automatic:
+        - exit_status: -1
+          limit: 2
+        - exit_status: 1
+          limit: 2
+    agents: { queue: "k8s" }
+    plugins:
+      - kubernetes:
+          podSpec:
+            containers:
+              - name: container-0
+                image: lmcache/ci-base:latest
+                imagePullPolicy: Never
+                resources:
+                  limits:
+                    nvidia.com/gpu: "1"
+                volumeMounts:
+                  - { name: hf-cache, mountPath: /root/.cache/huggingface }
+            volumes:
+              - { name: hf-cache, hostPath: { path: /data/huggingface, type: DirectoryOrCreate } }
+    artifact_paths:
+      - "*.log"
+      - "*.json"

lmcache-0.4.8.dev24/.github/scripts/cpu_device_test.sh

@@ -0,0 +1,156 @@
+#!/usr/bin/env bash
+# SPDX-License-Identifier: Apache-2.0
+#
+# CPU device test: runs both server bench and vLLM e2e tests
+# in the same environment to avoid repeated vLLM installation.
+#
+# Usage: cpu_device_test.sh [mode]
+#   mode: server_bench, vllm_e2e, or all (default)
+#
+# Environment variables:
+#   LMCACHE_BENCH_TRANSFER_MODE  engine_driven|lmcache_driven
+#                                (default: engine_driven)
+#   LMCACHE_E2E_TRANSPORT_MODE   engine_driven|lmcache_driven|shm|pickle
+#                                (default: engine_driven)
+#   LMCACHE_E2E_DATA_MODE        shm|pickle (default: shm)
+#   LMCACHE_HTTP_PORT_BENCH      HTTP port for bench (default: 18080)
+#   LMCACHE_ZMQ_PORT_BENCH       ZMQ port for bench (default: 15555)
+#   LMCACHE_HTTP_PORT_E2E        HTTP port for e2e (default: 18081)
+#   LMCACHE_ZMQ_PORT_E2E         ZMQ port for e2e (default: 15557)
+#   VLLM_PORT_E2E                HTTP port for vLLM (default: 18000)
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+OS="$(uname -s)"
+TEST_MODE="${1:-all}"
+
+echo "==> CPU device test (OS: ${OS}, Mode: ${TEST_MODE})"
+echo "    Python: $(python3 --version 2>&1 || true)"
+
+# Configuration
+BENCH_TRANSFER_MODE="${LMCACHE_BENCH_TRANSFER_MODE:-engine_driven}"
+E2E_TRANSPORT_MODE="${LMCACHE_E2E_TRANSPORT_MODE:-engine_driven}"
+E2E_DATA_MODE="${LMCACHE_E2E_DATA_MODE:-shm}"
+HTTP_PORT_BENCH="${LMCACHE_HTTP_PORT_BENCH:-18080}"
+ZMQ_PORT_BENCH="${LMCACHE_ZMQ_PORT_BENCH:-15555}"
+HTTP_PORT_E2E="${LMCACHE_HTTP_PORT_E2E:-18081}"
+ZMQ_PORT_E2E="${LMCACHE_ZMQ_PORT_E2E:-15557}"
+VLLM_PORT_E2E="${VLLM_PORT_E2E:-18000}"
+
+# Validate modes
+case "${BENCH_TRANSFER_MODE}" in
+  lmcache_driven|engine_driven) ;;
+  *)
+    echo "!! Unknown LMCACHE_BENCH_TRANSFER_MODE='${BENCH_TRANSFER_MODE}'"
+    exit 1
+    ;;
+esac
+
+# Map user-facing LMCACHE_E2E_TRANSPORT_MODE to internal representation.
+# shm/pickle are aliases for lmcache_driven mode with sub-mode selection.
+case "${E2E_TRANSPORT_MODE}" in
+  lmcache_driven|engine_driven)
+    MAPPED_TRANSPORT_MODE="${E2E_TRANSPORT_MODE}"
+    MAPPED_DATA_MODE="${E2E_DATA_MODE}"
+    ;;
+  shm)
+    MAPPED_TRANSPORT_MODE="engine_driven"
+    MAPPED_DATA_MODE="shm"
+    ;;
+  pickle)
+    MAPPED_TRANSPORT_MODE="engine_driven"
+    MAPPED_DATA_MODE="pickle"
+    ;;
+  *)
+    echo "!! Unknown LMCACHE_E2E_TRANSPORT_MODE='${E2E_TRANSPORT_MODE}'"
+    echo "   Valid values: engine_driven, lmcache_driven, shm, pickle"
+    exit 1
+    ;;
+esac
+
+echo "    Bench transfer mode: ${BENCH_TRANSFER_MODE}"
+echo "    E2E transport mode: ${E2E_TRANSPORT_MODE}"
+echo "    Ports: bench=${HTTP_PORT_BENCH}/${ZMQ_PORT_BENCH}, e2e=${HTTP_PORT_E2E}/${ZMQ_PORT_E2E}/${VLLM_PORT_E2E}"
+
+# Reap any LMCache/vLLM children started by this run on exit so the
+# next workflow step does not collide on default ZMQ/HTTP ports.
+cleanup_processes_safe() {
+    local rc=$?
+    set +e
+    # Kill child processes started by this shell first (e.g. lmcache server
+    # backgrounded by the shared validation script).
+    pkill -P $$ 2>/dev/null || true
+    sleep 1
+    pkill -9 -P $$ 2>/dev/null || true
+    return $rc
+}
+trap cleanup_processes_safe EXIT
+
+# Function to run server bench test
+run_server_bench() {
+    echo ""
+    echo "==> Running CPU server bench test"
+    
+    # Set environment for bench test
+    export LMCACHE_BENCH_TRANSFER_MODE="${BENCH_TRANSFER_MODE}"
+    export LMCACHE_HTTP_PORT="${HTTP_PORT_BENCH}"
+    export LMCACHE_ZMQ_PORT="${ZMQ_PORT_BENCH}"
+    export LMCACHE_LOG_FILE="/tmp/cpu_device_bench_${BENCH_TRANSFER_MODE}_lmcache.log"
+    export BENCH_OUTPUT_LOG="/tmp/cpu_device_bench_${BENCH_TRANSFER_MODE}_output.log"
+    export LMCACHE_HEALTHCHECK_TIMEOUT="30"
+    export BENCH_NUM_REQUESTS="3"
+    export BENCH_NUM_TOKENS="512"
+    
+    # Run bench test
+    bash "${SCRIPT_DIR}/cpu_server_bench_test.sh"
+    
+    echo "==> CPU server bench test completed successfully"
+}
+
+# Function to run vLLM e2e test
+run_vllm_e2e() {
+    echo ""
+    echo "==> Running CPU vLLM e2e test"
+    
+    # Set environment for e2e test
+    export LMCACHE_TRANSPORT_MODE="${MAPPED_TRANSPORT_MODE}"
+    export LMCACHE_DATA_MODE="${MAPPED_DATA_MODE}"
+    export LMCACHE_HTTP_PORT="${HTTP_PORT_E2E}"
+    export LMCACHE_ZMQ_PORT="${ZMQ_PORT_E2E}"
+    export VLLM_PORT="${VLLM_PORT_E2E}"
+    export LMCACHE_LOG_FILE="/tmp/cpu_device_e2e_${E2E_TRANSPORT_MODE}_lmcache.log"
+    export VLLM_LOG_FILE="/tmp/cpu_device_e2e_${E2E_TRANSPORT_MODE}_vllm.log"
+    export LMCACHE_HEALTHCHECK_TIMEOUT="30"
+    export VLLM_READY_TIMEOUT="300"
+    
+    # Run e2e test
+    bash "${SCRIPT_DIR}/cpu_vllm_e2e_test.sh"
+    
+    echo "==> CPU vLLM e2e test completed successfully"
+}
+
+# Determine which tests to run
+case "${TEST_MODE}" in
+    "server_bench")
+        run_server_bench
+        ;;
+    "vllm_e2e")
+        run_vllm_e2e
+        ;;
+    "all")
+        run_server_bench
+        run_vllm_e2e
+        ;;
+    *)
+        echo "!! Unknown test mode: ${TEST_MODE}"
+        echo "    Supported modes: server_bench, vllm_e2e, all"
+        exit 1
+        ;;
+esac
+
+echo ""
+echo "==> CPU device test passed for modes:"
+echo "    Test mode: ${TEST_MODE}"
+echo "    Server bench: ${BENCH_TRANSFER_MODE}"
+echo "    vLLM e2e: ${E2E_TRANSPORT_MODE}"