Two T4s, 31 Gigabytes of RAM, and the Myth of the VRAM Wall

Abhishek Dash9 min read
Two grey accelerator cards lie side by side on a dark workbench, the left one showing a single amber light and the right one dark, with a tall wall of stacked green memory modules behind them and a brass measuring tape stretched across its front and curling onto the bench.

In short

T4-Bench measured four campaigns on two free Kaggle Tesla T4s, 15 GiB each with 31 GiB host RAM and no BF16. FLUX.2 klein 4B led image throughput at 374 images an hour, LTX-Video 2B made warm 49-frame clips in about 27 seconds, and MiniMax-H3-Image rendered 4096 by 4096 on one card in 660 seconds. The wall was host RAM and fixed encoding cost, not GPU memory.

Key takeaways

  • MiniMax-H3-Image rendered a 4096 by 4096 image on one 15 GiB T4 in 659.7 seconds, with the second card at 3 MiB; the 32B text encoder configuration was killed before generation by host-RAM OOM.
  • FLUX.2 klein 4B reached 374 images an hour with batch 4 on each of the two T4s, and the highest mean CLIP alignment of the four image models at 0.3924.
  • Qwen-Image 2.1 Viggle 4-step took 64.0 seconds per image against 47.6 seconds for Z-Image-Turbo's 8 steps, because the text encoder and VAE decode dominate short samplers.
  • LTX-Video 2B distilled made a warm 49-frame clip in about 27 seconds; CogVideoX-2b scored higher prompt alignment at 0.2645 but needed 1053 seconds.
  • Unsloth cut 8B QLoRA memory to 7.1 GB from 14.9 GB by fusing the language head and cross entropy so the logits are never materialised.
  • Every chart, table and diagram is at t4b.sdad.pro, with the same numbers in plain text for agents.

A 33.1 billion parameter image model with roughly 126 gigabytes of weights rendered a 4096 by 4096 image on a 15 gigabyte Tesla T4 in 660 seconds. The second T4 was idle, drawing 3 megabytes. That single result is the cleanest statement of what four benchmark campaigns on two free Kaggle T4s kept finding: the wall was not GPU memory.

The campaigns live in four separate projects, image models, video generation, MiniMax-H3-Image, and language, agent and training workloads. They were merged into a single atlas because they all ran on the same machine with the same account of what was measured. The visual version is at t4b.sdad.pro, where each chart has a table beside it and the numbers are also published as plain text.

The machine and the question

The box had two Tesla T4s with 15360 MiB each, no NVLink, 31 GiB of host RAM, four vCPU, CUDA 13 and PyTorch 2.11. The T4 is a Turing card, compute capability 7.5, so FP16 and INT8 work and BF16 and FP8 do not. Kaggle gives this away for a limited session.

Most model comparisons assume something larger. T4-Bench asks a narrower question: on hardware anyone can get for free, what actually works, and how much does it cost in wall time? Every result records the prompt, seed, quantisation, resolution and timing method, and the raw CSVs and server logs are kept alongside the summaries. That matters because the interesting numbers here are the ones that disagree with the marketing.

One scoreboard per task

There is no honest way to merge these into one score. A chat model, a text-to-image pipeline and a video generator are not competing for the same thing, so the atlas names a winner per task.

Task Winner Measured
Chat, fastest LFM2.5-8B-A1B 119 tokens per second on one card
Small agent Spark 4B 3 of 3 hand-written agent tasks
Fine-tuning, leanest Unsloth NF4 7.1 GB against 14.9 GB stock
Image, best of both FLUX.2 klein 4B 374 images an hour, CLIP 0.3924
Image, highest alignment runner-up SDXL 1.0 base CLIP 0.3894, 107 images an hour
Video, best of both LTX-Video 2B distilled 27 seconds per warm 49-frame clip
Video, highest alignment CogVideoX-2b CLIP 0.2645, 1053 seconds for 49 frames

Two of those rows deserve a warning flag that the headline does not carry. Spark 4B passed three agent tasks, but the same report scored it 2 out of 5 on a small code-generation test and noted that it ran out of memory in long sessions. The three-task harness is a demonstration, not a general capability score. CLIP alignment is a proxy for whether an image matches its prompt, not a measure of beauty or correctness.

The wall was host RAM

MiniMax-H3-Image is the outlier that explains the whole machine. The model nominally needs about 126 gigabytes of weights. With a quantised DiT of 10 to 15 gigabytes, a 5.12 gigabyte text encoder and ggml streaming from host memory, it ran at native 4096 by 4096 in 659.7 seconds using 14653 MiB on the first card. Nothing was pooled across the two GPUs.

The levers that looked like they should matter did not. Q5_K_M was not slower than UD-Q4_K_XL at 1024 pixels, 114.7 seconds against 117.0, and the two were effectively tied at 2048. Dropping the VRAM cap from 12 GiB to 8 GiB lowered peak usage without a measurable latency penalty. The host-RAM streaming was close to free at that resolution.

Then the team tried the larger text encoder. The 32B Q4_K_M encoder alone was 18.22 GB, plus 13.61 GB of DiT and 1.17 GB of VAE, which is more than 31 GiB before a token was generated. The process died with signal 9 during tensor loading while the GPU peaked at only 13337 MiB. That is the boundary: not the card, but the memory feeding it.

There is a quality wrinkle worth keeping. BF16 cannot run on this hardware, so the upstream LPIPS comparison against a BF16 reference could not be reproduced. Using Q5_K_M seed 42 as the local reference, Q3_K_M scored 16.99 dB PSNR and UD-Q4_K_XL 20.89 dB, which is consistent with the published ordering but is not the same experiment.

Fixed costs beat step counts

The image campaign held the engine constant. All four models ran through one stable-diffusion.cpp build with CUDA and architecture 75, at 1024 by 1024, with fixed seeds and one cold process per run. Any difference was model, quantisation or component, not runtime.

Step count did not predict latency. FLUX.2 klein 4B took 23.7 seconds for four steps. Z-Image-Turbo took 47.6 seconds for eight. Qwen-Image 2.1 Viggle, also four steps, took 64.0 seconds. SDXL took 63.5 seconds for thirty. The 4-step Qwen model was slower than the 8-step Z-Image model because its 8B text encoder and a 15.9 second VAE decode dominate a sampler that barely runs.

Throughput changed the ranking in a useful way. Batching four images in one process and splitting two per GPU gave 374 images an hour for FLUX, 150 for Qwen, 147 for Z-Image and 107 for SDXL. The gain came from amortising the text pass, which is why encoder-heavy models benefited and SDXL and Z-Image did not. Peak VRAM per card did not change under batching. Dual-GPU execution delivered 1.8 to 2.0 times a single card.

Two published claims failed to reproduce. Qwen-Image 2.1 at 23 to 30 seconds per image did not happen on this cold, single-image protocol, and SDXL at 15 to 20 seconds did not happen with the base fp16 checkpoint. Both could be true in a warm ComfyUI server with different quantisation. They are not true here, and the report says so rather than quietly dropping the rows.

Two GPUs are not two machines

The video campaign found the limit in a different place. LTX-Video 2B distilled produced a warm 49-frame clip in 27.4 seconds at four steps, using about 11 GiB of VRAM. CogVideoX-2b scored higher prompt alignment at 0.2645 but took 1053 seconds for the same 49 frames, roughly 38 times longer. For a single best-looking clip with no time pressure, CogVideoX wins. For anything repetitive, LTX wins.

Attempting to put two LTX processes on two cards failed twice. The first attempt sent both to GPU 0 because CUDA_VISIBLE_DEVICES had been applied only to the monitoring call. After fixing that, both were killed for memory because each process needed about 20 GB of host RAM and two copies exceed 31 GiB. The second T4 helps image models, whose working sets fit in the VRAM and leave the host alone. It does not help this video model unless it is sharded.

The largest video model never finished. LTX-Video 13B distilled NF4 downloaded 57 gigabytes of roughly 93 before the container writable layer went read-only, and the remaining space could not be freed. The report records it as abandoned, not as a result.

The engine decides the memory bill

Fine-tuning produced the most decision-relevant number in the whole atlas. An 8B QLoRA run on Unsloth peaked at 7.1 GB. The same training through stock transformers peaked at 14.9 GB, and a variant with Unsloth blocked ran out of memory at 14.8 GB. That is 2.09 times, and on a 15 GB card it is the difference between fitting and not fitting.

The cause is specific. Unsloth fuses the language model head and cross entropy so a logits tensor shaped 1 by 1024 by 128256 is never materialised. The stock path creates it in fp32 at roughly a gigabyte a copy. There is no new science in the result; it is a question of where the memory goes. The leanest measured setup combined Soup's configuration ergonomics with Unsloth as the backend and kept the 7.1 GB figure.

What the harness can and cannot tell you

Several failures were measurement problems rather than model failures. Gemma 4 12B returned an empty response to a plain generate call because every token went into its thinking block. Setting the think flag to false produced the answer at 21 tokens per second. A harness that forgets that flag scores a working model at zero. LFM2.5-8B-A1B wraps reasoning in think tags even with a no-think prefix, which is harmless at 119 tokens per second but has to be parsed.

The language results are also specific about context. Ternary Bonsai 2 27B ran at 15.1 tokens per second on one card and 22.9 on two, and the full 262144 token context loaded across both cards using 26.2 GB of VRAM. Two agents running concurrently produced 92 tokens per second in aggregate against 71 for one, though the one-agent wall time was load-dominated. These are useful facts and they are not general intelligence scores.

Where to look

The whole atlas is at t4b.sdad.pro. It is a static site with no framework, no chart library and no build step, about 660 kilobytes in total. Metric tabs switch between throughput, prompt alignment and peak VRAM. Eight short diagrams play in view and pause offscreen, with poster frames for anyone who has reduced motion enabled. Every chart has a matching table, and the site publishes llms.txt and a complete plain-text version so the measurements are readable without a browser.

That is the point of the visual layer. The tab that switches a chart from images per hour to CLIP score changes which model looks best, and seeing the two side by side makes the trade-off harder to misremember than a paragraph of numbers. If you want to watch the comparison rather than read it, that is the place.

Where this could be wrong

All of this is one machine, one driver generation and one set of prompts. The image ranking could change with a different engine, a warm process, another resolution or a different quantisation stack, and the reports say so. CLIP cosine measures prompt alignment, not aesthetics, realism or accuracy, and the difference between 0.3924 and 0.3894 is small enough to be prompt-dependent.

The agent result rests on three hand-written tasks and a five-problem microbenchmark. That is far too small to support a claim about general agent quality. The fine-tuning comparison is one 8B run with one data set and seed. Video used short clips at each model's own preset, so the two rows are not the same workload.

Some campaigns were extracted from research notes rather than re-run for the atlas. The largest H3 text encoder, several ComfyUI and diffusers tracks, and the 13B video model were abandoned with recorded causes, and absences in the tables are not evidence about those configurations. No human preference study was run, and no claim here is about which model a person would prefer to look at.

The one claim I would defend is the narrow one. On this box, with these quantisations and these prompts, the thing that stopped work was usually host RAM or a fixed encode cost, not the 15 gigabytes on the card. That is a useful thing to know before buying a bigger GPU.

On this page

Sources

  1. T4-Bench: Kaggle 2x Tesla T4 benchmark resultsT4-Bench, 2026
  2. Source notes and published reportsSDAD Writes, 2026
  3. Unified benchmark indexT4-Bench, 2026
  4. FLUX.2-klein-4BBlack Forest Labs, 2026
  5. Z-Image-TurboTongyi MAI, 2026
  6. MiniMax-H3-ImageMiniMaxAI, 2026
  7. LTX-Video-2b-0.9.8-distilled-HFIEHugging Face, 2026
  8. CogVideoX-2bTHUDM, 2026
  9. stable-diffusion.cppleejet, 2026
  10. LFM2.5-8B-A1B-GGUFLiquid AI, 2026

Frequently asked questions

What is T4-Bench?

Four benchmark campaigns run on one Kaggle machine with two Tesla T4s, 15 GiB of VRAM each, 31 GiB of host RAM and no BF16 or FP8. Each campaign records its prompt, seed, quant, resolution and timing method, and keeps the raw CSVs and server logs. The visual version is at t4b.sdad.pro.

Which image model is fastest on two T4s?

FLUX.2 klein 4B, by a wide margin. It took 23.7 seconds per 1024 by 1024 image in a cold single-image run and reached 374 images an hour with batch 4 on each card. It also had the highest mean CLIP prompt alignment of the four models measured, 0.3924.

Why is a four-step model slower than an eight-step model?

Sampling is only one part of the wall time. Qwen-Image 2.1 Viggle needs an 8B text encoder and a 15.9 second VAE decode, which made its four steps take 64.0 seconds. Z-Image-Turbo uses a 4B encoder and took 47.6 seconds for eight steps. Batching helps encoder-heavy models because it amortises that fixed cost.

Can a 33B image model really run on a 15 GB card?

Yes, with a quantised DiT, a small text encoder and host-RAM streaming. MiniMax-H3-Image ran at native 4096 by 4096 in 659.7 seconds with a peak 14653 MiB on the first card. Replacing the 4B encoder with the 32B one pushed total memory past 31 GiB and the process was killed while loading.

Does a second T4 double video throughput?

Not for the 2B LTX model. Each process needs about 20 GB of host RAM, so two copies exceed 31 GiB and were OOM-killed. The second card helps image models, where the working set fits, but video generation was host-RAM bound instead.

Where can I see the results visualised?

At t4b.sdad.pro. It is a static site with metric tabs, bar charts, eight short diagrams and tables that mirror every chart. It also publishes llms.txt and a plain-text version of every measurement.