◆
Scale, then release
A large amount of capacity for as long as the job runs, and nothing afterwards.
Serious computation has an awkward profile: enormous demand, intermittently. Owning for the peak means idling for most of the year, and queueing for a shared cluster means the question gets smaller to fit.
Used for simulation, modelling, rendering, analysis and batch computation.
What this looks like in practice
A large amount of capacity for as long as the job runs, and nothing afterwards.
You stop shrinking a problem to fit a cluster allocation.
Your job does not wait behind another team’s. The ordering problem goes away rather than being managed.
What a computation cost, so deciding whether to run it again is informed.
The most expensive consequence of fixed HPC capacity is invisible: the analyses that were scoped down, deferred or never attempted because the allocation would not take them.
The real cost of a fixed cluster is paid in the questions that were quietly made smaller. Researchers and engineers learn the allocation and design within it, and the compromise becomes invisible because it happens before anything is written down.
Models run at the resolution the physics needs rather than the resolution that fits.
Media and visual workloads completing on the schedule the production needs.
Parameter exploration broad enough to be conclusive.
Large batch work that does not displace somebody else’s job.
We ran a sweep in two days that we had been deferring for a year because it would have taken our whole allocation for a month.
Enough that the job defines the size rather than the allocation. For specific requirements, tell us the shape of the workload and we will answer concretely instead of in adjectives.
No. The shared-allocation ordering problem is what this removes rather than schedules more fairly.
For intermittent demand, usually and substantially, because you stop paying for the idle majority of the year. For genuinely continuous saturated load, owning can still win — we will tell you if that is your case.
Yes, per job. That makes the decision to repeat an expensive computation a judgement rather than a guess.
Start on something that will still be right at a hundred times your size, and pay now what a startup should pay.
Move in stages with the old arrangement still running, and cut over only once the replacement has carried real traffic.
Get capacity when the experiment is ready, keep what produced a result, and put models in front of users without a separate platform.
Keep everything at full fidelity, query it without a project, and stop deciding today what you will want to ask next year.
Ship the application your users touch, on an address that stays put, with every version one click behind you.
Build the tools your own teams need, at a cost that makes small improvements worth doing.
Begin with one workload. Keep what you have running. Decide whether to continue once you have seen it carry something real.
No migration required to begin. Nothing to tear down if you stop.