io.github.farssaadeldin7-ux/predictive-resource-allocation

Open the Stripe billing portal to change plan, update the card, or cancel the Predictive Resource Allocation subscription.

Apply the discriminating tests' thresholds to measured readings you supply — halve-the-work timings, VRAM occupancy against GPU utilisation, cold against warm cache, clock-scaling sensitivity — and count the agreement. Names a class only when two findings agree; otherwise it says insufficient or conflicting and which test would settle it. Threshold checks over your numbers, not a profiler — it measures nothing itself. Requires a paid plan.

Farm and cloud arithmetic from one measured frame time and one measured per-frame overhead: the 10x-overhead dispatch rule, the batching band, how the work type scales across nodes, and optionally the Young–Daly checkpoint interval for spot instances. It does not estimate cost or pick a provider. Requires a paid plan.

Per-application bottleneck profile: what usually binds, the governing scaling law, and the settings that move it most — for GPU path tracing (Cycles, Redshift, Octane), Houdini FLIP and Pyro, Nuke, After Effects and model training. Table data from the references, not advice about your scene. Omit domain to list all of them.

The local estimate log that closes the loop: log a prediction (action "log"), record the measured actual against it once the job has run (action "record_actual"), or review the tally of how past estimates landed against the stated factor-of-two band (action "review"). Counting only — the review makes no new claim. Requires a paid plan. Nothing leaves this machine.

Check an estimate against this machine's actual memory: takes a snapshot internally, runs the same arithmetic as vram_estimate or training_memory_estimate (pass the same inputs in the render or training block; vram_gb may be omitted when an NVIDIA card is measurable), and reports fits / thin / does_not_fit against the MEASURED free memory — free VRAM via nvidia-smi for resource gpu_vram, allocatable system RAM for resource system_ram — with the references' 10–15% reserve applied to the real number. When it does not fit, the machine's largest measured memory consumers are listed as the concrete background tasks to close. Every figure is labelled measured or estimated. Requires a paid plan.

Store and activate a Predictive Resource Allocation licence key on this machine. Use when the user pastes a licence key, or after a purchase completes.

Check the Predictive Resource Allocation licence on this machine: plan, included capabilities, remaining quota and seat usage. Call this when a paid tool reports a licence problem, or when the user asks what their plan includes.

List the available Predictive Resource Allocation plans, prices and what each one includes.

The fixed remedy order — change a setting, change the data layout, change the algorithm, buy hardware — with typical cost and gain per rank, the four reasons hardware is last, and the one honest exception (the capacity cliff). Static reference; it does not rank remedies for a specific job.

Begin a Predictive Resource Allocation purchase. Returns a Stripe Checkout link. Call list_plans first if the user has not chosen a plan.

Measured host telemetry from this machine, via Node built-ins and a probed nvidia-smi: total and free RAM (plus MemAvailable on Linux), logical cores and CPU model, 1/5/15-minute load averages (reported as unsupported on Windows rather than shown as zeros), platform and architecture, NVIDIA GPU name and memory when nvidia-smi answers — otherwise gpu is reported unavailable, never guessed, so AMD, Intel and Apple GPUs show as unavailable — and the top resident-memory processes on Linux. Every figure is measured; a snapshot is a point in time, not a profile over a job, and nothing leaves this machine. Requires a paid plan.

Training capacity arithmetic: static state from the bytes-per-parameter table (16 for mixed precision with Adam, 10 for 8-bit Adam or SGD, LoRA and inference variants), transformer activations at layers x batch x seq x hidden x 34 bytes, against the card's usable budget. When static state alone exceeds the card it says so and lists the algorithmic remedies — lowering the batch size cannot fix that case. Arithmetic only; it does not predict step time or convergence. Requires a paid plan.

The four constraint classes (plus the two non-resource patterns), the four discriminating tests with their readings, the symptom index, the bandwidth ladder and the minimum intake the method demands before predicting. Reference data only — it names no class for your job; classify_bottleneck does that from measured readings. Omit section to get everything.

GPU rendering capacity arithmetic against a card's usable budget (nominal minus the 10–15% reserve): geometry at 50–100 bytes per triangle, BVH at 1.3–2x geometry, textures with the 1.33x mip chain, framebuffer with AOVs, engine overhead. Returns the breakdown and a fits / thin / does_not_fit verdict with a plus-or-minus 20% band. Arithmetic over your reported scene only — it does not read the scene file and does not predict render time. Requires a paid plan.