[Perf] Further optimization for Qwen3-VL fast_pos_embed_interpolate

[Isotr0py]

Purpose

• Following PR for [MM][Perf] Minor Optimization on Qwen3-VL fast_pos_embed_interpolate #25337
• Just found that we can further optimize weights computation for fast_pos_embed_interpolate by reducing duplicated multiply.
• Also improve the readability for weights and indices computation with torch.meshgrid vectorization

Test Plan

vllm bench serve  --backend openai-chat   --endpoint-type openai-chat --model /home/mozf/LLM/Qwen3-VL-4B-Instruct/   --endpoint /v1/chat/completions   --dataset-name hf   --data
set-path "lmarena-ai/VisionArena-Chat"   --hf-split train   --num-prompts 500 --max-concurrency 64

Test Result

Main branch

============ Serving Benchmark Result ============
Successful requests:                     500       
Maximum request concurrency:             64        
Benchmark duration (s):                  85.76     
Total input tokens:                      34073     
Total generated tokens:                  61091     
Request throughput (req/s):              5.83      
Output token throughput (tok/s):         712.33    
Peak output token throughput (tok/s):    2431.00   
Peak concurrent requests:                82.00     
Total Token throughput (tok/s):          1109.62   
---------------Time to First Token----------------
Mean TTFT (ms):                          1301.41   
Median TTFT (ms):                        1037.53   
P99 TTFT (ms):                           6141.91   
-----Time per Output Token (excl. 1st token)------
Mean TPOT (ms):                          83.71     
Median TPOT (ms):                        81.09     
P99 TPOT (ms):                           375.42    
---------------Inter-token Latency----------------
Mean ITL (ms):                           77.71     
Median ITL (ms):                         28.33     
P99 ITL (ms):                            444.94    
==================================================

PR

============ Serving Benchmark Result ============
Successful requests:                     500       
Maximum request concurrency:             64        
Benchmark duration (s):                  84.81     
Total input tokens:                      34073     
Total generated tokens:                  61174     
Request throughput (req/s):              5.90      
Output token throughput (tok/s):         721.35    
Peak output token throughput (tok/s):    2367.00   
Peak concurrent requests:                81.00     
Total Token throughput (tok/s):          1123.13   
---------------Time to First Token----------------
Mean TTFT (ms):                          1212.60   
Median TTFT (ms):                        952.82    
P99 TTFT (ms):                           5926.17   
-----Time per Output Token (excl. 1st token)------
Mean TPOT (ms):                          82.54     
Median TPOT (ms):                        80.58     
P99 TPOT (ms):                           370.48    
---------------Inter-token Latency----------------
Mean ITL (ms):                           77.33     
Median ITL (ms):                         28.42     
P99 ITL (ms):                            437.87    
==================================================

---

Essential Elements of an Effective PR Description Checklist

• The purpose of the PR, such as "Fix some issue (link existing issues this PR will resolve)".
• The test plan, such as providing test command.
• The test results, such as pasting the results comparison before and after, or e2e results
• (Optional) The necessary documentation update, such as updating supported_models.md and examples for a new model.
• (Optional) Release notes update. If your change is user facing, please update the release notes draft in the Google Doc.

[gemini-code-assist]

Code Review

This pull request introduces a minor but effective optimization for the fast_pos_embed_interpolate function in Qwen3-VL's vision transformer. The changes involve refactoring the weight and index calculations for bilinear interpolation. By using torch.meshgrid, the code becomes more readable and vectorized. Furthermore, an algebraic simplification in the weight calculation reduces the number of multiplications, leading to a small but measurable performance improvement as shown in the provided benchmarks. The changes are correct and well-implemented. I have no major concerns.