Product 2 · Ball tracking
One measured job · honest about the rest
BallTrack AI — GPU performance
BallTrack AI runs a neural network on every frame, so the GPU sets the
pace. Here is what one real match cost on the reference machine, and an
honest account of what a different card would change.
One card has been measured: the RTX 3090
Every timing on this page is from one real job on an
RTX 3090. A ~30 minute match segment
(53,466 frames at 4354×1748) on an RTX 3090 with a
Ryzen 9 5900X, TensorRT FP16, 3 detection workers:
detection 76.7 min at 11.6 fps,
smoothing 15 seconds,
render ~28 min —
~1 h 45 min total. No other card has
been run, so this page doesn’t quote per-card times it can’t
stand behind.
Only the detection pass scales with the GPU.
Smoothing is a fixed ~15 second CPU cost, and the render pass is
decode- and CPU-bound rather than encoder-bound — on the measured run
NVENC had roughly 6× headroom over the rate the
render actually sustained. So a faster card shortens detection and
little else, and a second NVENC encoder does nothing here.
How many workers the app runs is set by your VRAM, not by
you. The app reads the card’s memory and picks the
worker count — 16 GB runs 2, 24 GB runs 5 — and there is one
detection model with nothing to tune. Because workers are the main
speed lever, a card’s VRAM tier matters as much as its raw speed.
Why VRAM matters more than raw speed
BallTrack AI reads your card’s memory and
sets the number of detection workers for you — there
is no slider and no model to choose. More VRAM means more parallel
workers, and workers are the main speed lever: the same count also
drives the render pass. So memory size, not clock speed, is
the spec that decides how fast a match finishes — and more
of it genuinely helps here, right up to the point the app stops
adding workers.
VRAM
Workers the app runs
What that means
16 GB
2 workers — the supported floor.
Runs the whole pipeline, but with fewer workers than the validated
card, so a match takes longer.
24 GB
5 workers — the app’s maximum.
The validated tier — the reference
RTX 3090, and the only card actually measured.
Below 16 GB
1 worker — experimental. The app
starts and runs a single worker, but this tier is
unvalidated and much slower.
The app sets the worker count from your card’s
memory — you never pick it, and there is only one detection model, so
there is nothing to trade off. A worker is a separate process holding
its own copy of that model on the GPU.
A worker is a whole copy of the model
Each detection worker is a separate process with its own copy of
the network resident on the GPU. Measured on the reference card:
about 1.2 GB of allocated memory and ~3 GB
reserved per worker, including its TensorRT execution
context, on top of the parent process. That reserved footprint is
why the app is conservative about how many it runs.
More workers is the real win
The GPU serves one worker at a time, and a worker spends more time
on the GPU than on the CPU per frame — so extra workers keep it
busy and going 1 → 3 is a large win.
That is exactly why a 24 GB card (5 workers) finishes a match
meaningfully faster than a 16 GB card (2 workers): here, more
memory really does buy more speed.
One model, chosen for you
Earlier plans let you pick the detector and trade model size
against worker count. The shipped app doesn’t: it runs a
single model, tuned for this job, so the only thing your VRAM
decides is how many workers run in parallel. Nothing to configure,
nothing to get wrong.
The
honest caveat: only the 24 GB tier has actually been
measured — five workers plus the parent process occupying
about 11 GB on a 24 GB card. 16 GB is the supported
floor, in the app’s own automatic cap and on paper, but
24 GB is what has been run end to end. Anything
below 16 GB is experimental.
Supported minimum
16 GB, RTX 20 series or newer
Runs the full pipeline at 2 detection workers · slower than the 24 GB tier (unmeasured)
16 GB is the floor the app supports. It clears both hard gates —
a GPU modern enough for TensorRT to load, and enough memory for the
app to run 2 detection workers beside the parent
process. It works, and it’s a fine card to leave running; it is
simply slower than the validated 24 GB card, which runs five
workers. Cards below 16 GB still start, but on a single worker
and as experimental, unvalidated territory — and
anything older than the RTX 20 series won’t load
TensorRT at all.
Honesty note: no card below 24 GB has been benchmarked. A
16 GB card is supported and will finish matches, but its time
is an estimate until one is measured.
The validated card
RTX 3090 · 24 GB
~1 h 45 min for a 30-minute half · measured
The reference machine, and the one card every number on this page was
actually run on. 24 GB is what lets the app run its full
five detection workers, which is where the pipeline
is fastest. Because more workers is the real lever here, a 24 GB
card finishes a match meaningfully sooner than a 16 GB one —
more memory genuinely buys speed, up to the app’s five-worker
ceiling. A newer 24 GB card (an RTX 4090) should match or
slightly beat it; a second NVENC encoder does not help, because the
render pass is limited by CPU decode, not encoding.
More than 24 GB
buys nothing: the app caps at five workers, which 24 GB already
covers.
The one measured run
The reference RTX 3090 · TensorRT FP16 · 53,466 frames at 4354×1748
·Ryzen 9 5900X class CPU
Why there is no per-card
table: the app sets the worker count from your VRAM (16 GB runs
2, 24 GB runs 5), so a card’s time depends on that tier, not
just its raw speed — and only the 24 GB tier has been
measured. Publishing per-card estimates would mean inventing numbers
for worker counts and cards nobody has run. When a 16 GB card is
measured, its real figures go here.
The uncomfortable part of these numbers
A large share of the
work isn’t on the GPU at all: video decoding, masking, tracking
and smoothing all run on the CPU. The render pass alone is a measured
28 minutes that barely moves with the graphics card,
so on this hardware the pipeline cannot go below roughly 35
minutes total no matter how fast the card is. Detection —
the part the GPU actually accelerates — is the only pass a better
card shortens.
Practical
consequence: on this workload, VRAM tier (how many workers the app
runs) matters more than raw chip speed, and past the 24 GB /
five-worker ceiling more GPU buys nothing. The remaining big wins are
software-side, and they’re on our list.
What’s measured and what isn’t: the times above are one real
run on the reference RTX 3090 — detection 76.7 min,
smoothing 15 s, render 28.2 min. Every figure for other cards
would be an estimate, and because the app sets the worker count from your
VRAM (16 GB runs 2 workers, 24 GB runs 5), a card’s time
depends on that tier and not just its raw speed — so we don’t
publish per-card guesses. Real times also vary with match length, footage
resolution and quality, and the rest of your PC — the CPU matters
more than people expect. When a 16 GB card is measured, its real
numbers replace this note.