Will running Strata wear out your SSD?
On two Arc Pro B60s, eight warm Strata requests recorded 16.0 MB of reads and 0.70 MB of writes on the model SSD. Here’s how to measure your own setup.
Putting part of a local AI model on an SSD can get it running on hardware you already own. But if the drive gets busy every time you ask a question, is it reading model data or writing to swap because the machine is short on RAM? The write count is what you want to check if you’re worried about wearing out the drive.
On our two Intel Arc Pro B60s, the SSD handled 16.0 MB of reads and 0.70 MB of writes across eight short replies, with zero swap activity during those replies. Startup recorded more I/O, and the drive also wrote during idle. We saw little write activity during this short chat test. You can check your own machine with separate measurements for idle, startup, and a warm batch.
What the SSD did during startup and chat
We put a 28.8 GB embedding table on a 1 TB Intel 660p NVMe SSD and left the native model shards on a separate ZFS pool. The SSD also held the operating system and its swap file. The table includes all host I/O to the SSD, including background traffic. The swap counters cover the whole machine. Intel 660p drive identification
| Phase | Time | SSD reads | SSD writes | Swap in / out | SSD temperature |
|---|---|---|---|---|---|
| Idle | 60.0 s | 0.66 MB | 10.24 MB | 8 KiB / 0 | 41.9 → 36.9 °C |
| Startup | 434.2 s | 1.83 GB | 63.07 MB | 88 KiB / 48 KiB | 36.9 → 37.9 °C |
| Warm batch 1 | 3.70 s | 11.49 MB | 0.70 MB | 0 / 0 | 37.9 → 39.9 °C |
| Warm batch 2 | 3.42 s | 4.54 MB | 0 | 0 / 0 | 39.9 → 40.9 °C |
All eight requests completed. The four requests in each batch took a median of 0.60 and 0.56 seconds, respectively, from send to completion. The two warm batches together lasted just over seven seconds. To estimate a typical write rate, repeat the measurements over a longer period that reflects your usual workload. This test cannot establish an SSD’s lifespan.
Which Strata build and settings we used
The successful run used a retained October Strata SYCL build and Qwen3.8-Flash-Next IQ2_XS. We used an 8,192-token context limit, split the model across two B60s, and selected direct I/O for the embedding table with --ple-io direct. Strata reported that all experts were resident across the two GPUs. These measurements cover SSD access with the experts in VRAM. An offload configuration that fetches experts from storage needs its own test.
Two corrected attempts with Strata v0.2.13 stopped at startup while filling the second GPU’s cache, including one with a nine-minute readiness limit. The October build completed startup and served both batches. Its binary SHA-256 is 115eeb36697f3db4cfc6b769957381f32dcfaef40fbe4dbd0fbe6ff4daef18ae. Strata v0.2.13 release notes
Each warm batch sent four short prompts one at a time with a 64-token cap per reply. The prompts covered text copying, arithmetic, JSON output, and a short explanation. We measured completed replies and device counters. We left answer quality and long-prompt performance for separate tests.
How to check your own SSD
1. Find the devices holding the model and swap
Get the loaded shard and prepared pack paths from your Strata startup log and substitute them below. In lsblk, follow the partition’s parent to the whole NVMe device. Use swapon to see whether swap shares that drive. If the model spans drives, take readings for each relevant device.
findmnt -T /path/to/model-shard.gguf findmnt -T /path/to/prepared-pack lsblk -o NAME,PKNAME,TYPE,MOUNTPOINTS swapon --show
2. Take separate idle and startup readings
Save measure.py and replace nvme0n1 with the device you found. Download and prepare the model before taking readings so installation activity stays outside the test. If possible, save the measurement files on another drive.
python3 measure.py snapshot nvme0n1 > idle-before.json sleep 60 python3 measure.py snapshot nvme0n1 > idle-after.json python3 measure.py delta idle-before.json idle-after.json
Before launching Strata, repeat the snapshot command and save it as startup-before.json. When the local server comes up, replace 8080 with its loopback port and check that loaded is true and the model and context match your settings. Then take another snapshot as startup-after.json. Strata health handler
PORT=8080 curl --noproxy '*' --fail --silent --show-error --max-time 5 "http://127.0.0.1:$PORT/health" | python3 -m json.tool
3. Run the same prompts twice
Save warm_batch.py and summarize.py beside measure.py. Use the model ID and port from your test server. Run the commands from the directory with your snapshots. To compare settings, keep the prompts and token cap the same and record the setting you changed.
MODEL='your-local-model-id' python3 warm_batch.py nvme0n1 "$PORT" "$MODEL" > warm-1.json && python3 warm_batch.py nvme0n1 "$PORT" "$MODEL" > warm-2.json python3 summarize.py . > summary.json
What to change if writes are high
If writes and swap-out rise together, check the swap location from step 1. On the Strata Intel Arc engine, lower --max-context in the test instance’s launch settings, confirm the new value on /health, and rerun the warm batches. If writes rise with flat swap counters, check where your runtime saves logs and caches. If you have a second drive, point the test’s log and cache settings there and repeat the measurement.
If the drive mainly reads and you’re concerned about responsiveness, compare batch completion times and temperature across otherwise identical runs. To compare write rates, divide the bytes written by elapsed seconds. Take longer idle and workload readings before treating a brief burst as a typical rate.
Linux counts host reads and writes in 512-byte sectors. These counters measure bytes transferred by the host. Measuring writes to the SSD’s internal NAND would require separate device telemetry. The temperature readings show the start and end of each interval. Linux block statistics
Download the measurement summary for exact byte counts and request times. Add the two warm intervals’ byte deltas to reproduce the headline totals.