Hardware Dan SoftWare Komputer
Mengenal prangkat-perangkat lunak serta keras dalam teknology dunai komputer
#Weareplay: dengan lebih dari 3 miliar unduhan, temui orang -orang di belakang Amanotes
Diposting oleh Robbie McLachlan – Pengembang Pemasaran Dalam film #Weareplay terbaru kami, yang merayakan orang -orang di balik aplikasi dan permainan di …
#Weareplay
Pengembang Android
Tes pada armada perangkat fisik dengan streaming perangkat Android, sekarang dengan laboratorium perangkat mitra android
Diposting oleh Adarsh Fernando – Group Product Manager, Android Studio, dan Grant Yang – Manajer Produk Sr, Omnilab Hari Ini, Kami Mantan …
#AndroidDeviceStreaming #Androidstudio
Pengujian aplikasi
Computer-Aided Engineering (CAE) membentuk tulang punggung untuk pengembangan produk modern di seluruh industri, dari merancang pesawat yang lebih aman hingga mengoptimalkan sistem energi terbarukan. Itu berarti kecepatan dan akurasi komputasi sangat penting untuk keputusan rekayasa, memerlukan prototyping dan inovasi yang cepat. Namun, penghalang untuk masuk untuk ekosistem CAE saat ini dan pemecah telah tinggi.
Aplikasi CAE tradisional mengandalkan bahasa tingkat rendah seperti C ++ dan Fortran untuk memenuhi persyaratan throughput dan skalabilitas yang menuntut. Python, sementara itu, telah muncul sebagai bahasa de facto untuk pengembangan AI/ML. Ini secara historis belum digunakan untuk aplikasi CFD skala besar, karena keterbatasan kinerja yang terkait dengan sifat tingkat tinggi dan ditafsirkan. Munculnya pembelajaran mesin berbasis fisika telah menciptakan permintaan yang semakin besar untuk pemecah CAE berbasis Python yang berintegrasi dengan ekosistem AI/mL namun mempertahankan kinerja bahasa tingkat rendah.
Autodesk Research mengembangkan perpustakaan kisi Boltzmann (XLB) yang dipercepat untuk menjembatani kesenjangan ini antara pemecah CAE dan ekosistem AI/mL. Ini adalah pemecah dinamika fluida komputasi open source (CFD) berdasarkan metode kisi Boltzmann (LBM), yang digunakan oleh tim peneliti Autodesk untuk eksplorasi dan eksperimen penelitian yang sedang berlangsung. Implementasi asli Python membuatnya sangat mudah diakses oleh pengembang. Dan arsitekturnya yang dapat dibedakan memungkinkan integrasi alami dengan kerangka pemodelan AI-Physics modern, sub-bidang yang berkembang pesat dalam CAE dan domain komputasi ilmiah.
Dengan memanfaatkan NVIDIA WARP dalam hubungannya dengan GH200 Grace Hopper Superchip, XLB mencapai perkiraan ~ 8x speedup dibandingkan dengan backend JAX yang dipercepat GPU pada konfigurasi perangkat keras tertentu dan kasus pembandingan yang ditentukan oleh tim peneliti Autodesk. Memanfaatkan strategi komputasi di luar inti, Autodesk Research juga dapat skala pemecah backend Warp XLB menjadi sekitar 50 miliar sel komputasi.
NVIDIA WARP, kerangka kerja Python open source untuk simulasi kinerja tinggi dan komputasi spasial, menggabungkan aksesibilitas Python dengan kemampuan komputasi kinerja tinggi CUDA (HPC). Pada saat yang sama, Superchip GH200 membahas persyaratan CAE inti: menjalankan simulasi kesetiaan tinggi pada throughput dan skala maksimum.
Sementara kode CFD yang diimplemen Python secara tradisional dipandang sebagai kompromi kinerja, XLB membuktikan WARP dapat memberikan kinerja alur kerja CFD transformatif dalam praktiknya. Gambar 1 di bawah ini membandingkan kinerja, diukur dalam jutaan pembaruan kisi per detik (MLUPS), antara Solver Backend Warp Backend berbasis OpenCL FluidX3D dan XLB untuk simulasi aliran rongga yang digerakkan oleh LID 512³. Angka -angka ini didasarkan pada data yang tersedia untuk umum dan pembandingan internal yang dilakukan oleh tim peneliti Autodesk. Hasilnya menunjukkan bahwa kode Python XLB yang diakelerasi Warp mencapai kinerja yang sebanding (sekitar 95% mirip) dengan solver FluidX3D berbasis OpenCL yang diimplementasikan dalam C ++ untuk simulasi aliran rongga yang digerakkan oleh LID.
Pada saat yang sama, Warp menawarkan kemampuan keterbacaan yang sangat baik dan kemampuan prototipe cepat melalui antarmuka Python-nya, berbeda dengan backend berbasis C ++ dan OpenCL dari kode FluidX3D.
Kesetaraan kinerja ini membahas tantangan lama dalam penelitian CFD. Secara tradisional, para peneliti menghadapi pertukaran antara produktivitas pengembangan dan kinerja komputasi, memilih antara aksesibilitas Python atau efisiensi implementasi yang dioptimalkan dalam bahasa seperti C ++ atau Fortran. Dengan menggunakan Warp, XLB memungkinkan para peneliti untuk memanfaatkan ekosistem perpustakaan numerik Python, alat visualisasi, dan kerangka kerja pembelajaran mesin sambil mempertahankan kinerja throughput tinggi.
Warp juga dapat memanfaatkan arsitektur GH200 Grace Hopper Superchip. Selama kolaborasi bersama antara Autodesk Research dan NVIDIA, tim XLB menskalakan pemecah backend XLB XLB ke konfigurasi multi-node yang dapat melakukan simulasi CFD hingga sekitar 50 miliar elemen komputasi.
Tim menerapkan strategi komputasi di luar inti di mana domain komputasi dan variabel aliran terkait berada di memori CPU dan secara sistematis ditransfer ke GPU untuk diproses. Ini diaktifkan oleh interkoneksi NVLink-C2C GH200, dengan bandwidth CPU-GPU 900 GB/s. Itu membuat strategi komputasi di luar inti sangat praktis dengan memungkinkan streaming data yang cepat karena ubin komputasi ditukar masuk dan keluar dari memori GPU. Koherensi memori NVLink-C2C mendukung transfer data yang mulus untuk pendekatan di luar inti, menghilangkan bottleneck CPU-GPU tradisional dalam simulasi skala besar.
Gambar 2 Di atas secara kuantitatif menunjukkan penskalaan mendekati linear dengan meningkatnya jumlah simpul untuk ukuran simulasi maksimum (kiri) dan throughput komputasi (kanan) untuk pemecah backend Warp XLB. Cluster GH200 delapan simpul memungkinkan simulasi dengan sekitar 50 miliar sel kisi sambil mencapai ~ 8x speedup dibandingkan dengan sistem GH200 simpul tunggal.
Prestasi ini menandai titik balik di mana CFD asli Python tidak lagi menjadi kompromi tetapi keunggulan inovasi.
“XLB, yang ditenagai oleh NVIDIA WARP, membantu para peneliti dengan cepat membuat prototipe dan menguji ide -ide baru tanpa diperlambat oleh kemacetan kinerja,” kata Mehdi Ataei, ilmuwan riset utama AI di Autodesk Research. “Kelincahan ini telah menyebabkan pengembangan beberapa prototipe penelitian kami sedang dalam proses penerbitan.”
Di bagian ini, kami mengeksplorasi beberapa fitur utama yang membuat warp unik cocok untuk mengembangkan alat simulasi CAE yang dapat diskalakan.
NVIDIA WARP menyediakan jembatan yang kuat antara CUDA dan Python untuk pengembang simulasi (Gambar 3). Ini memungkinkan pengembang untuk menulis kernel GPU secara langsung di Python yang hanya dalam waktu (JIT)-dikompilasi menjadi kode CUDA asli. Warp menawarkan kemampuan simulasi yang kaya, seperti Warp.fem untuk analisis elemen hingga, membedakannya dari perpustakaan Python-Cuda yang ada seperti Numba. Yang penting, kernel warp dapat dibedakan berdasarkan desain, memungkinkan integrasi tanpa batas dengan kerangka kerja pembelajaran yang mendalam seperti Pytorch dan Jax. Warp juga mempertahankan interoperabilitas dengan banyak kerangka kerja yang ada, termasuk Numpy, Cupy, dan Jax, yang memungkinkan pengguna untuk memanfaatkan kekuatan masing -masing kerangka masing -masing.
Gambar 4 di atas membandingkan throughput komputasi (dalam MLUP) dan konsumsi memori antara Backend Warp dan Jax XLB. Untuk konfigurasi perangkat keras spesifik yang digunakan oleh tim peneliti Autodesk dan tolok ukur aliran rongga yang digerakkan oleh tutup, Warp mengungguli JAX dalam hal throughput dan penggunaan memori (Gambar 4). Pemecah backend Warp XLB memberikan speedup ~ 8x di atas solver backend JAX pada satu GPU A100 sambil mencapai efisiensi memori yang lebih baik dua hingga tiga kali pada GPU yang sama, untuk aliran rongga yang digerakkan oleh tutup.
Peningkatan kinerja yang substansial (plot kiri pada Gambar 4) berasal dari desain yang dioptimalkan simulasi Warp dan model pemrograman kernel eksplisit. Warp memungkinkan pengembang untuk menulis kernel CUDA khusus domain dan fungsi perangkat secara langsung di Python. Pendekatan eksplisit ini menghilangkan overhead komputasi dan memungkinkan kinerja yang lebih dapat diprediksi untuk simulasi CAE. Selain itu, Warp's JIT Compiler melakukan optimasi agresif, termasuk loop Unslolling dan eliminasi cabang, lebih lanjut meningkatkan kecepatan eksekusi.
Keuntungan efisiensi memori (plot yang tepat pada Gambar 4) mencerminkan filosofi manajemen memori eksplisit Warp. Warp mengharuskan pengembang untuk pra-pengalokasian input dan output array, menghilangkan alokasi memori tersembunyi dan buffer menengah. Pendekatan langsung ini, sambil membutuhkan perhatian pengembang, menghasilkan jejak memori yang lebih ramping yang dapat diprediksi dengan ukuran masalah.
Pertukaran historis antara produktivitas pengembangan dan kekuatan komputasi mentah tidak lagi menjadi kompromi yang diperlukan. Perpustakaan XLB – dikembangkan oleh Autodesk Research dan dipercepat oleh NVIDIA WARP – mengeksekrifikasi paradigma baru ini. Ini membuktikan bahwa kerangka kerja asli Python dapat memberikan kinerja yang setara dengan kode tingkat rendah yang sangat dioptimalkan sambil mempertahankan aksesibilitas dan siklus pengembangan yang cepat dari ekosistem Python.
Mulailah dengan Autodesk Research XLB dan NVIDIA WARP untuk proyek CFD Anda menggunakan tautan di bawah ini:
Autodesk Research membawa kecepatan warp ke dinamika fluida komputasi pada NVIDIA GH200
Pemrosesan video yang dipercepat perangkat keras di Python menjadi lebih mudah. Pynvvideocodec adalah perpustakaan yang berbasis di NVIDIA Python untuk pengkodean video, decoding, dan transcoding yang dipercepat GPU. Dibangun langsung di atas NVIDIA Video Codec SDK tingkat rendah, Pynvvideocodec ringan, berlisensi MIT, dan mudah dipasang menggunakan PIP. Kinerja setara dengan SDK asli.
Pynvvideocodec 2.0 adalah peningkatan besar pada bagaimana pengembang, peneliti, dan insinyur membangun jaringan pipa video berkinerja tinggi menggunakan bahasa Python yang akrab dan fleksibel.
Apakah Anda sedang mengerjakan analisis video, preprocessing AI, transcoding media, atau streaming waktu-nyata, Pynvvideocodec 2.0 memberikan kecepatan C ++ dan kemudahan Python-sekarang dengan lebih banyak fitur, kinerja yang lebih baik, dan dukungan CODEC yang diperluas. Baca terus untuk mempelajari lebih lanjut.
software-stack-625×529-png.webp” alt=”Diagram berlapis yang menunjukkan tumpukan perangkat lunak untuk pemrosesan video yang dipercepat GPU menggunakan Pynvvideocodec. Lapisan atas mencakup aplikasi python tingkat pengguna, yang berinteraksi dengan API Pynvvideocodec. Antarmuka API ini dengan NVIDIA Video Codec SDK. Di dasar tumpukan adalah GPU NVIDIA, yang melakukan pemrosesan video yang dipercepat perangkat keras.” class=”wp-image-105822″ srcset=”https://developer-blogs.nvidia.com/wp-content/uploads/2025/09/pynvvideocodec-gpu-accelerated-video-processing-software-stack-625×529-png.webp 625w, https://developer-blogs.nvidia.com/wp-content/uploads/2025/09/pynvvideocodec-gpu-accelerated-video-processing-software-stack-300×254-png.webp 300w, https://developer-blogs.nvidia.com/wp-content/uploads/2025/09/pynvvideocodec-gpu-accelerated-video-processing-software-stack-136×115-png.webp 136w, https://developer-blogs.nvidia.com/wp-content/uploads/2025/09/pynvvideocodec-gpu-accelerated-video-processing-software-stack-645×546-png.webp 645w, https://developer-blogs.nvidia.com/wp-content/uploads/2025/09/pynvvideocodec-gpu-accelerated-video-processing-software-stack-355×300-png.webp 355w, https://developer-blogs.nvidia.com/wp-content/uploads/2025/09/pynvvideocodec-gpu-accelerated-video-processing-software-stack-106×90-png.webp 106w, https://developer-blogs.nvidia.com/wp-content/uploads/2025/09/pynvvideocodec-gpu-accelerated-video-processing-software-stack-362×306-png.webp 362w, https://developer-blogs.nvidia.com/wp-content/uploads/2025/09/pynvvideocodec-gpu-accelerated-video-processing-software-stack-130×110-png.webp 130w, https://developer-blogs.nvidia.com/wp-content/uploads/2025/09/pynvvideocodec-gpu-accelerated-video-processing-software-stack-638×540-png.webp 638w, https://developer-blogs.nvidia.com/wp-content/uploads/2025/09/pynvvideocodec-gpu-accelerated-video-processing-software-stack-png.webp 728w” sizes=”(max-width: 625px) 100vw, 625px”/>
Rilis PynvVideocodec 2.0 memperkenalkan beberapa fitur kuat yang dirancang untuk mengoptimalkan alur kerja video untuk AI, siaran, multimedia, dan aplikasi streaming. Ini termasuk peningkatan untuk decode, encode, dan transcode.
Peningkatan Decode Baru untuk Pynvvideocodec 2.0 termasuk yang berikut:
Encode Enhancements Baru untuk Pynvvideocodec 2.0 termasuk yang berikut:
Peningkatan Transcode Baru untuk Pynvvideocodec 2.0 termasuk yang berikut:
Instal Pynvvideocodec dengan kode berikut. Proses ini tidak berubah dari versi sebelumnya.
pip install PyNvVideoCodec
Untuk akses dan kustomisasi kode sumber lengkap (mengaktifkan profil NVTX, misalnya), unduh dari NVIDIA NGC dan instal:
pip install PyNvVideoCodec.zip
Untuk menyesuaikan internal atau membangun dari sumber, gunakan kode berikut:
unzip PyNvVideoCodec.zip
cd PyNvVideoCodec
pip install .
Pynvvideocodec 2.0 memberikan kinerja nvidia video codec SDK kepada pengembang Python – dengan kesederhanaan, fleksibilitas, dan daya mentah.
Untuk membuat Anda bangun dan berjalan dengan cepat, sampel aplikasi Python dan dokumentasi Pynvvideocodec yang komprehensif dibundel dalam paket PYPI dan NGC. Dari skrip Decode dan Re-Enkode sederhana hingga transkode berbasis tersegmentasi, contoh-contoh ini dirancang untuk mencolokkan langsung ke alur kerja Anda.
Untuk mulai membangun aplikasi video generasi berikutnya lebih cepat dari sebelumnya, kunjungi PYPI atau NVIDIA NGC.
Apa yang Baru di Pynvvideocodec 2.0 untuk pemrosesan video yang dipercepat GPU Python
Yang terbaru untuk devs dari made by google, pembaruan ke Gemini di Android Studio, ditambah androidify baru: episode musim panas kami dari The Android Show
Diposting oleh Matthew McCullough – VP manajemen produk, pengembang Android dalam ekosistem yang dinamis dan kompleks ini, komitmen kami adalah untuk …
blog Pengembang Android
Deploying large language models (LLMs) poses a challenge in optimizing inference efficiency. In particular, cold start delays—where models take significant time to load into GPU memory—can impact user experience and scalability. Increasingly, complex production environments highlight the need for efficient model loading. These models often require tens to hundreds of gigabytes of memory, causing latency and resource challenges when scaling to meet unpredictable demand. Cold start delays impact end-user experience and operational efficiency.
This post introduces the NVIDIA Run:ai Model Streamer, an open source Python SDK designed to mitigate these issues by concurrently reading model weights from storage and streaming them directly into GPU memory. We benchmarked it against the vLLM default Hugging Face (HF) Safetensors Loader and CoreWeave Tensorizer on local SSDs and Amazon S3.
The experiments explained in this post show that the NVIDIA Run:ai Model Streamer significantly reduces model loading times, lowering cold start latency even in cloud environments. It also remains compatible with the Safetensor format, avoiding weight conversion. Our findings emphasize storage choice and concurrent streaming for efficient LLM deployment. Specifically, to improve inference performance, use the NVIDIA Run:ai Model Streamer to reduce cold-start latency, saturate your storage throughput, and accelerate time-to-inference.
To provide some background information, this section explains the two main steps involved in loading a machine learning model into GPU memory for inference: reading weights from storage into CPU memory, and transferring them to the GPU. Understanding this process is key to optimizing inference latency, especially in large-scale or cloud-based deployments.
Loading models from cloud-based storage such as Amazon S3 often involves an extra step: the weights are first downloaded to local disk before being moved into CPU and then GPU memory.
Traditionally, these steps occur sequentially, making model loading times one of the most significant bottlenecks when scaling inference.
Model Streamer is an SDK with a high-performance C++ backend designed to accelerate model loading into GPUs from various storage sources (for example, network file systems, cloud, local disks, and so on). It uses multiple threads to read tensors concurrently from a file in object or file storage, to a dedicated buffer in the CPU memory. Each tensor has an identifier, enabling simultaneous reading and transfer: while some tensors are read from storage to CPU, others are moved from CPU to GPU.
The tool takes full advantage of the fact that GPU and CPU have separate subsystems. GPUs access CPU memory directly through PCIe without CPU intervention, allowing real-time overlap of storage reads and memory transfers. Experiments were run on an AWS g5.12xlarge instance with NVIDIA A10G GPUs and 2nd Gen AMD EPYC CPUs—offering balanced architecture for high-throughput parallel data handling.
Key features of the Model Streamer include:
For more details about setup and usage, see the Model Streamer documentation.
The HF Safetensors Loader is an open source utility that provides a safe and fast format for saving and loading multiple tensors. It uses a memory-mapped file system to minimize data copying. On a CPU, tensors are directly mapped into memory. On a GPU, it creates an empty tensor with PyTorch, then moves the tensor data using cudaMemcpy, facilitating a zero-copy loading process.
CoreWeave Tensorizer is an open source tool that serializes model weights and their corresponding tensors into a single file. Instead of loading an entire model into RAM before moving it to the GPU, Tensorizer streams the model data tensor by tensor from an HTTP/HTTPS or S3 source.
Model serving is not complete without an inference engine. There are many inference engines and servers that one can utilize. This post focuses on vLLM and its model loading capabilities. For the benchmarking study, we only utilized vLLM.
The vLLM framework uses the HF safetensors model loading as default. Additionally, it supports CoreWeave Tensorizer to load models from S3 endpoints. However, note that the Tensorizer library requires converting weights from safetensors format to tensorizer format.
We compared the performance of different model loaders (NVIDIA Run:ai Model Streamer, CoreWeave Tensorizer, and HF Safetensors Loader) across three storage types:
All tests ran under cold-start conditions to avoid cache effects. For S3, a minimum two-minute wait between tests ensured accuracy. Tensorizer experiments used models serialized per the Tensorizer recipe, and benchmarking followed their benchmarking recipe, both without optional hashing.
The experiments were conducted using the setup outlined in Table 1.
| Model |
| Llama 3 8B, an LLM weighing 15 GB, stored in a single Safetensors format |
| Hardware |
| AWS g5.12xlarge instance featuring four NVIDIA A10G GPUs (only one GPU was used for all tests to maintain consistency) |
| software stack |
| CUDA 12.4 vLLM 0.5.5 (Transformers 4.44.2) NVIDIA Run:ai Model Streamer 0.6.0 Tensorizer 2.9.0 Transformers 4.45.0.dev0 Accelerate 0.34.2 |
| Storage types |
| GP3 SSD: 750 GB, 16K IOPS, 1,000 MiB/s IO2 SSD: 500 GB, 100K IOPS, 4,000 MiB/s Amazon S3: Same AWS region as instance to minimize latency |
For the experiments involving Tensorizer, the same model was serialized into the Tensorizer proprietary tensor format using the recipe provided by the Tensorizer framework.
In this initial experiment, we compared the loading performance of different model loaders using GP3 SSD storage. We evaluated the impact of concurrency on the Model Streamer (Figure 1) and examined how the number of workers affected Tensorizer. For Model Streamer, increasing concurrency—the number of concurrent threads reading from storage into CPU memory—led to a notable decrease in model loading time.
At concurrency 1, Model Streamer loaded the model in 47.56 seconds, slightly slower than HF Safetensors Loader at 47.99 seconds. With concurrency 16, loading time dropped to 14.34 seconds, maintaining throughput of ~1 GiB/s, the max for GP3 SSD. Beyond that, storage throughput limited further gains.
Tensorizer showed similar behavior. With one worker, loading time was 50.74 seconds, close to Safetensors Loader. With 16 workers, it achieved 16.11 seconds and 984.4 MiB/s throughput—also nearing GP3 SSD bandwidth.
The storage throughput limit of GP3 SSD became the bottleneck for both Model Streamer and Tensorizer, limiting performance. This motivated testing a higher-throughput storage solution in Experiment #2.
| Model Streamer | Safetensors Loader | |
| Concurrency | Time to load model to GPU (sec.) | Time to load model to GPU (sec.) |
| 1 | 47.56 | 47.99 |
| 4 | 14.43 | |
| 8 | 14.42 | |
| 16 | 14.34 | |
| Tensorizer | |
| Number of readers | Time to load model to GPU (sec.) |
| 1 | 50.74 |
| 4 | 17.38 |
| 8 | 16.49 |
| 16 | 16.11 |
| 32 | 17.18 |
| 64 | 16.44 |
| 100 | 16.81 |
For the second experiment, we used IO2 SSD, which offers significantly higher throughput than GP3 SSD. As before, we analyzed the effect of concurrency on Model Streamer (Figure 3) and the number of workers on Tensorizer.
At concurrency 1, Model Streamer and HF Safetensors Loader showed similar loading times of 43.71 seconds and 47 seconds, respectively. However, as we increased concurrency, Model Streamer showed much more pronounced gains compared to GP3 SSD. With concurrency 8, the model was loaded in just 7.53 seconds, making it around 6x faster than the HF Safetensors Loader, which took 47 seconds.
For Tensorizer, the performance also improved significantly. The optimal result was observed with eight workers, achieving a model loading time of 10.36 seconds (Figure 4). Beyond that, adding more workers did not yield further performance improvements, likely due to storage throughput limitations.
Despite the theoretical maximum throughput of 4 GiB/s for IO2 SSD, our experiments consistently hit a ceiling at around 2 GiB/s with Model Streamer and 1.6 GiB/s with Tensorizer. This suggests practical throughput limitations on the AWS infrastructure, rather than the loaders themselves.
| Model Streamer | Safetensors Loader | |
| Concurrency | Time to load model to GPU (sec.) | Time to load model to GPU (sec.) |
| 1 | 43.71 | 47 |
| 4 | 11.19 | |
| 8 | 7.53 | |
| 16 | 7.61 | |
| 20 | 7.62 | |
| Tensorizer | |
| Number of readers | Time to load model to GPU (sec.) |
| 1 | 43.85 |
| 4 | 14.44 |
| 8 | 10.36 |
| 16 | 10.61 |
| 32 | 10.95 |
For cloud storage, Experiment #3 compared the performance of Model Streamer and Tensorizer using Amazon S3 as the storage medium. Since HF Safetensors Loader does not support S3, it was not included in this benchmarking experiment. For the Tensorizer experiments, we used different numbers of workers and chose the best result for Figure 6, which was achieved with 16 workers in this case.
The results showed that Model Streamer outperformed Tensorizer at all tested concurrency levels. At concurrency 4, Model Streamer loaded the model in 28.24 seconds. As concurrency increased, Model Streamer continued to improve, reaching a load time of 4.88 seconds at concurrency 32, compared to 37.36 seconds for Tensorizer’s best result with 16 workers. This shows that the Model Streamer demonstrates superior efficiency in loading from cloud-based storage.
Note that during these experiments, we observed unexpected caching behavior on AWS S3. When experiments were repeated in quick succession, the model load times significantly improved, likely due to some form of S3 caching mechanism. To ensure consistency and avoid benefiting from this “warm cache,” we introduced at least a 3-minute wait between each test run. The results presented here reflect the times recorded after these intervals, ensuring they represent cold-start conditions.
| Model Streamer | |
| Concurrency | Time to load model to GPU (sec.) |
| 4 | 28.24 |
| 16 | 8.45 |
| 32 | 4.88 |
| 64 | 5.01 |
| Tensorizer | |
| Number of readers | Time to load model to GPU (sec.) |
| 8 | 86.05 |
| 16 | 37.36 |
| 32 | 48.67 |
| 64 | 41.49 |
| 80 | 41.43 |
This experiment integrated different model loaders into vLLM to measure the total time from model loading to readiness for inference. Model Streamer, Safetensors Loader, and Tensorizer were tested on local storage (GP3 SSD and IO2 SSD), while Hugging Face Safetensors was excluded from S3 since it doesn’t support S3 loading. Tensorizer was tested with vLLM on S3 and compared to Model Streamer.
For each vLLM plus Model Streamer experiment, we used the most optimal concurrency levels determined from earlier experiments. Specifically:
Similarly, for the Tensorizer plus vLLM integration, we used the most optimal number of workers determined in previous experiments. Specifically:
Model Streamer reduced total readiness time to 35.08 seconds on GP3 SSD and 28.28 seconds on IO2 SSD, compared to HF Safetensors Loader at 66.13 seconds and 62.69 seconds, respectively. Tensorizer took 36.19 seconds on GP3 and 30.88 seconds on IO2 SSD, similarly cutting times roughly in half versus Safetensors. On S3, Model Streamer achieved 23.18 seconds total readiness, while Tensorizer required 65.18 seconds.
| vLLM with different loaders | |
| Loader | Total time until vLLM engine is ready for requests (sec.) |
| Safetensors Loader | 66.13 |
| Model Streamer | 35.08 |
| Tensorizer | 36.19 |
| vLLM with different loaders | |
| Loader | Total time until vLLM engine is ready for requests (sec.) |
| Safetensors Loader | 62.69 |
| Model Streamer | 28.28 |
| Tensorizer | 30.88 |
| vLLM with different loaders | |
| Loader | Total time until vLLM engine is ready for requests (sec.) |
| Model Streamer | 23.18 |
| Tensorizer | 65.18 |
Cold start latency remains a key bottleneck in delivering responsive, scalable LLM inference, especially in dynamic or cloud-native environments. Our benchmarks demonstrate that the NVIDIA Run:ai Model Streamer significantly accelerates model loading times across local and remote storage, outperforming other common loaders. By enabling concurrent weight loading and GPU memory streaming, it offers a practical and high-impact solution for production-scale inference workloads.
If you’re building or scaling inference systems, especially with large models or cloud-based storage, these results offer immediate takeaways: use the Model Streamer to reduce cold-start latency, saturate your storage throughput, and accelerate time-to-inference. With easy integration into frameworks like vLLM and support for high-concurrency, multi-storage environments, it’s a drop-in optimization that can yield measurable gains. Boost your model loading performance with the NVIDIA Run:ai Model Streamer.
Reducing Cold Start Latency for LLM Inference with NVIDIA Run:ai Model Streamer