The Tool Desk
Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →iTechGuides is reader-supported. When you buy through links on our site, we may earn an affiliate commission. As an Amazon Associate I earn from qualifying purchases. Learn more
Benchmark this in separate tracks: first measure the useful compute work each sandbox completes, then measure how quickly the platform creates, schedules, serves, and removes sandboxes. Increase concurrency until throughput plateaus or your latency objective is missed. A VM boot time, controller request rate, or single compute score cannot answer how many agent tasks one server can run reliably.
The protocol below gives you a reproducible CPU-capacity result, a lifecycle-capacity result, and an interference result. It also shows how to report cold creation, warm-pool acquisition, bursts, and sustained churn without confusing provisioning overhead with processor speed.
What this benchmark should answer
Write down the decision before running tests. “CPU performance” can mean several different things, and each requires a different unit of work.
Maximum useful compute throughput
How many fixed agent-like work units can the host complete per second when execution is the only variable? This is the CPU-capacity track. Use the same input, software, sandbox CPU allocation, and output validation at every concurrency level.
#1 Best Overall
- The world’s fastest gaming processor, built on AMD ‘Zen5’ technology and Next Gen 3D V-Cache.
- 8 cores and 16 threads, delivering +~16% IPC uplift and great power efficiency
- 96MB L3 cache with better thermal performance vs. previous gen and allowing higher clock speeds, up to 5.2GHz
- Drop-in ready for proven Socket AM5 infrastructure
- Cooler not included
Per-task completion latency
How long does one task take at a specified number of active sandboxes? Report the median and tail percentiles, not just an average. A platform that maintains good throughput but produces occasional very slow tasks may not meet an interactive agent service objective.
Concurrent capacity at a service objective
How many active tasks can meet a stated target, such as a maximum p95 completion time? The answer is the highest tested concurrency before that objective is missed, not the point at which the machine first becomes busy.
Provisioning capacity
How quickly can the control plane create, claim, start, and delete environments? This is a lifecycle and controller track. It must be reported separately from CPU execution because a fast create rate does not prove that workloads execute quickly.
PC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11Outdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchDefine the workload and pass criteria
Use a fixed, representative agent task
Choose a deterministic tool sequence that resembles production work: for example, a fixed compile and test, a repeatable data transformation, or a scripted set of local tools. Pin the input, dependency versions, output checks, and workload version. The task should perform enough CPU work to measure execution rather than only process startup, but it should not hide storage or network delays.
If an agent normally reads a workspace, state whether the workspace is local, mounted, or remote. Run a CPU-focused variant with data already available locally, then a production-like variant that exercises the real workspace path. Docker documentation warns that network-attached or remote workspace access through filesystem passthrough adds latency; treat that delay as a separate factor instead of attributing it to the processor.
Choose one primary success objective
- Throughput objective: completed and validated work units per second.
- Latency objective: task completion time at each offered concurrency, reported as median, p95, and p99 when the run is long enough to make the tail meaningful.
- Capacity objective: the largest concurrency at which the selected latency and error targets hold.
- Provisioning objective: request-to-ready, claim, scheduling, start, and teardown rates and latencies.
State the objective and its threshold before looking at results. Intel’s CubeSandbox example uses a 200 millisecond creation target, but that is a target in that vendor-published methodology, not a universal sandbox SLA.
Define what counts as a completed unit
A completion should require the expected exit status and a content or checksum check. Record failures, timeouts, retries, and cancellations separately. Never count a process that started but produced invalid output as useful CPU throughput.
Record the platform and isolation boundary
Configuration is part of the result. A number without the following details cannot be reproduced or compared fairly.
Rank #2
- Can deliver fast 100 plus FPS performance in the world's most popular games, discrete graphics card required
- 6 Cores and 12 processing threads, bundled with the AMD Wraith Stealth cooler
- 4.2 GHz Max Boost, unlocked for overclocking, 19 MB cache, DDR4-3200 support
- For the advanced Socket AM4 platform
| Area | Record | Why it changes the result |
|---|---|---|
| Host CPU | Processor model, physical-core count, SMT policy, frequency and power policy when available | Core count, scheduling topology, boost behavior, and power limits affect throughput and tail latency. |
| Memory and storage | Total memory, memory speed if known, storage type, free capacity, and workspace location | Paging, cache pressure, image extraction, and filesystem latency can look like CPU slowdown. |
| Host software | Operating system, kernel, hypervisor or runtime version, and relevant scheduler settings | Kernel scheduling, quota enforcement, and runtime changes alter interference and startup behavior. |
| Isolation boundary | Container sharing the host kernel, cgroups with pinning, microVM with a guest kernel, or another boundary | These models have different scheduling, threat, memory, and startup characteristics; they are not interchangeable. |
| Sandbox allocation | vCPU count, memory, CPU quota, cpuset or affinity, oversubscription ratio, and whether throttling is enabled | The same host can deliver very different results under dedicated, pinned, or oversubscribed allocation. |
| Images and state | Guest or container image digest, runtime dependencies, image-cache state, and workspace contents | Cold image pulls and cache misses add lifecycle time and can consume host CPU. |
| Load | Other services, background CPU pressure, memory pressure, and intended co-tenant arrangement | Quiet-host results are not sufficient if production agents share the machine. |
Firecracker documents cgroup CPU quotas and CPU or node affinity for microVMs and notes that the operator chooses the oversubscription degree. Record those settings rather than reporting only the nominal vCPU count.
Build a repeatable test harness
- Freeze the software. Capture image digests, workload source or package versions, runtime versions, kernel version, and benchmark harness revision. For Firecracker, record a release or commit because its documentation follows the rolling main branch.
- Prepare equivalent images. Keep the guest or container image, dependencies, and workspace data identical across isolation modes. Separate image-pull and extraction time from execution time.
- Instrument every phase. Timestamp request acceptance, scheduling, sandbox creation, readiness, workload start, workload completion, result validation, and teardown. Use a clock source consistent across the controller and workers, or document how clock offsets are handled.
- Verify allocation. At startup, record the effective CPU quota, affinity or cpuset, visible vCPU count, memory limit, and throttling counters. A requested allocation is not proof that the runtime applied it.
- Establish a quiet baseline. Run the workload directly on the host or in the least isolated reference available, at low concurrency. This baseline is a comparison point, not a claim that production should run without isolation.
- Repeat each condition. Use a disclosed number of repetitions and duration long enough to expose run-to-run variation. Do not keep only the fastest run. If a run is discarded, record the reason and show how many were discarded.
- Collect host telemetry. At minimum capture CPU utilization by core, frequency where available, throttling, run queue or scheduler pressure, memory pressure, storage activity, and controller queue depth. Preserve raw timestamps so latency distributions can be recalculated.
Track A: measure CPU execution performance
Run a compute-only baseline
Execute the fixed workload with one active sandbox or one host worker. Measure completed work per second and task latency after warm-up. Then run the same workload in each isolation class with the same allocated CPU. If you compare a guest with bare metal, label the ratio with the exact workload, image, vCPU allocation, and host configuration.
Firecracker’s project specification states that compute-only guest CPU performance is greater than 95% of equivalent bare-metal performance for its specified setup, while marking the integration test as pending. Present this as a project-published claim with that qualification, not as an independently reproduced result or a universal guarantee.
Quick wins for a faster PC:
Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Repair Windows errors before they cause bigger problemsFix Now →Scan for outdated or missing drivers - takes under a minuteDriver Scan →Increase active work gradually
Start at one active task, then increase simultaneous CPU-bound tasks through a documented ramp until throughput stops increasing, latency crosses the service objective, or failures begin. Keep the offered concurrency distinct from the number of tasks that actually completed. At every step record:
- offered and active concurrency;
- completed work units and throughput;
- median, p95, and p99 task latency;
- CPU utilization, frequency, throttling, and run-queue pressure;
- memory pressure, I/O activity, and error or timeout counts.
Plot throughput against concurrency and latency percentiles against concurrency. The useful capacity point is the knee: the first sustained region where additional concurrency produces little or no throughput gain while latency or throttling rises.
Keep execution and lifecycle clocks separate
For CPU performance, start the execution timer when the workload begins inside a ready sandbox and stop it after output validation. Do not include image pulls, guest boot, queueing, or deletion in this number. Report a second end-to-end task time if users experience those phases, but label it clearly.
Track B: measure lifecycle and controller performance
Capture separate lifecycle intervals
Record these intervals independently whenever telemetry permits:
- request submitted to scheduler acceptance;
- acceptance to sandbox allocation or claim;
- allocation to sandbox-ready signal;
- ready signal to workload start;
- workload execution and result validation;
- completion to teardown finished.
This decomposition shows whether a regression is in CPU execution, queueing, image handling, runtime startup, scheduling, or deletion. Aggregate request-to-ready latency only after the component intervals have been retained.
Rank #3
- AMD Ryzen 9 9950X3D Gaming and Content Creation Processor
- Max. Boost Clock : Up to 5.7 GHz; Base Clock: 4.3 GHz
- Form Factor: Desktops , Boxed Processor
- Architecture: Zen 5; Former Codename: Granite Ridge AM5
Cold creation
Evict or otherwise invalidate the state that your production cold path lacks, including image-cache and warm-pool state where appropriate. Measure create-to-ready and then run the fixed task. State exactly what was cold; “cold” is not a universal condition.
Warm-pool acquisition
Pre-create a documented number of idle sandboxes, claim them under load, and measure claim-to-ready and claim-to-workload-start. A warm pool can reduce visible startup latency while shifting CPU and memory cost to pool replenishment. Measure replenishment and exhaustion rather than reporting only the fast claim path.
Bursts, ramps, and sustained churn
Use at least three lifecycle patterns:
- Burst: submit a short, simultaneous wave and observe queueing and tail latency.
- Ramp: increase request concurrency or arrival rate in steps and find the throughput plateau.
- Churn: create, run, and delete continuously for a sustained period to expose leaks, fragmentation, image-cache contention, and controller backlogs.
The Kubernetes SIG Agent Sandbox guide documents startup, claim-readiness, scheduling-throughput, creation-throughput, warm-pool, burst, ramp, and churn recipes. Its script defaults include 1,000 claims per burst, 1,000 requests per second, 10 bursts, and a warm pool of 1,000; it also describes 400 as a conservative starting burst size and 400 requests per second. These are documented test defaults and guidance, not observed capacity results.
Interpret vendor-published provisioning numbers carefully
Intel’s CubeSandbox methodology increases concurrent provisioning requests from 100 to 350 and evaluates average and tail behavior against its 200 millisecond creation target. Identify it as vendor-published work using a CubeSandbox-specific method. Do not generalize that target, concurrency range, or any result from it to every runtime or agent workload.
Track C: measure interference and isolation effects
Repeat representative CPU and lifecycle runs with controlled background CPU load and with the co-tenant arrangement expected in production. Compare the quiet baseline with each isolation mode you might deploy. Keep the background workload, placement, duration, and intensity fixed across the comparison.
A 2025 study listed in the TU Berlin repository examined cgroups and CPU pinning, Docker, and Firecracker with a noise generator. Its abstract reports differences in latency distributions and different isolation effects. Use that finding as a reason to test interference and tails, not as proof that one runtime is universally best.
Report whether pinning protects the measured task, whether it merely moves contention to unpinned work, and whether quotas cause periodic throttling. Include both average utilization and the latency distribution; a high average CPU percentage can coexist with unacceptable tail delays.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Design the concurrency sweep
Use a documented sequence
Begin with a quiet single-task point, then double or otherwise step up concurrency while the system is below saturation. Near the knee, use smaller increments so the service-limit crossing is not hidden. Continue beyond the knee long enough to show whether throughput plateaus, degrades, or recovers after queue drain.
Rank #4
- Pure gaming performance with smooth 100+ FPS in the world's most popular games
- 6 Cores and 12 processing threads, based on AMD "Zen 5" architecture
- 5.4 GHz Max Boost, unlocked for overclocking, 38 MB cache, DDR5-5600 support
- For the state-of-the-art Socket AM5 platform, can support PCIe 5.0 on select motherboards
- Cooler not included
Run the same sweep for CPU execution and lifecycle provisioning. A controller may sustain a high create rate while the host cannot execute all claimed tasks, or it may have excellent CPU headroom while its scheduler queue grows.
Record offered load and achieved work
For every point, record arrival rate or requested concurrency, active sandboxes, queue depth, successful completions, failed requests, and test duration. A short burst and a 30-minute steady run can have the same average rate but very different tail behavior; disclose the duration and pattern.
Identify the knee explicitly
Mark both of these points:
- the first point where throughput no longer rises materially with added offered load;
- the first point where the selected latency, error, or throttling objective is missed.
If those points differ, report both. The sustainable service capacity is constrained by the earlier business or reliability limit, not by whichever number looks larger.
Do these 3 things before closing this tab:
1Clear out junk files and repair common Windows errors2Scan for outdated or missing drivers - takes under a minute3Repair Windows errors before they cause bigger problemsReport distributions, not a single score
| Result | Minimum reporting | Interpretation |
|---|---|---|
| CPU execution | Work units per second, task count, median/p95/p99 execution latency, concurrency, duration | Useful compute delivered by ready sandboxes. |
| Request-to-ready | Median/p95/p99, cold or warm state, offered request rate, image-cache state | Provisioning experience before work starts. |
| Scheduling and claim | Claim throughput, queue depth, scheduling latency, failures | Controller and allocator capacity. |
| Teardown | Delete latency distribution, cleanup failures, sustained churn duration | Whether the platform can recycle capacity without accumulating debt. |
| Interference | Quiet versus co-tenant results, background load, pinning/quota settings | Performance stability under realistic contention. |
Include the repetition count, run duration, warm-up policy, variation or confidence method, and discarded-run reasons. The cited methods do not prescribe one universal sample count or percentile set; choose a defensible protocol for your workload and disclose it.
Understand the published Firecracker figures without overgeneralizing
| Figure | What it measures | Limit to state with it |
|---|---|---|
| 8 CPU milliseconds | Firecracker VMM startup to API-socket availability under the project’s documented conditions | Not guest boot and not end-to-end agent readiness. |
| 6–60 milliseconds wall-clock, typically about 12 milliseconds | Observed VMM process startup range in the same specification | Condition-specific project documentation, not a universal startup promise. |
| At most 5 MiB | VMM thread memory overhead for the stated one-vCPU, 128 MiB microVM configuration | Workload-dependent caveats apply; this is not total microVM memory. |
| At most 125 milliseconds | InstanceStart API call to guest /sbin/init for the specified minimal kernel and root filesystem |
Not an agent task readiness measurement. |
| Greater than 95% | Project-published compute-only guest CPU performance relative to equivalent bare metal | The integration test is marked pending; do not present it as independent validation. |
| 5 microVMs per host core per second | Minimal-kernel, single-core, 128 MiB configuration in Firecracker design documentation | Narrow configuration, not general sandbox capacity. |
| 180 microVMs per second | Example given for a 36-physical-core host | Same narrow project scenario; it does not describe agent execution throughput. |
| 200 milliseconds | Creation service-level target in Intel’s CubeSandbox methodology | Vendor-specific target, not an industry-wide SLA. |
| 100–350 concurrent requests | Provisioning concurrency range in that Intel comparison | Method-specific comparison, not a universal sizing rule. |
Compare isolation models on the same axes
Do not declare one model fastest in the abstract. Compare the boundary that your security and operations design actually uses.
| Axis | Questions to answer |
|---|---|
| Isolation and threat model | Does the workload share the host kernel, use cgroups and pinning, or run with a guest kernel in a microVM? What escape and co-tenant assumptions apply? |
| CPU work | How many validated work units per second are delivered at low load and near the knee? |
| Provisioning | What are cold create, warm claim, burst, ramp, and delete distributions? |
| Interference | How do p95 and p99 latency change under the same background load? |
| Controls | Can you enforce quotas, affinity, pinning, and oversubscription, and do telemetry confirm enforcement? |
| Memory and workspace | What is the idle and active overhead, and does the workspace path introduce storage or network delay? |
| Repeatability | Can another operator reproduce the result from the recorded versions, image digests, topology, and settings? |
Common mistakes and how to correct them
Calling boot speed CPU speed
Symptom: a short VMM or container startup is presented as processor performance. Correction: report startup in the lifecycle track and run a ready-sandbox compute workload for CPU capacity.
Using one concurrency point
Symptom: a benchmark at one arbitrary load is used to size the whole host. Correction: perform a ramp, add bursts and sustained churn, and identify the throughput and latency knees.
Recommended Free Tools
Counting requests instead of useful work
Symptom: create or claim requests per second are called agent tasks per second. Correction: report controller throughput separately and count only validated task completions in the CPU track.
Best Value
- Processor provides dependable and fast execution of tasks with maximum efficiency.Graphics Frequency : 2200 MHZ.Number of CPU Cores : 8. Maximum Operating Temperature (Tjmax) : 89°C.
- Ryzen 7 product line processor for better usability and increased efficiency
- 5 nm process technology for reliable performance with maximum productivity
- Octa-core (8 Core) processor core allows multitasking with great reliability and fast processing speed
- 8 MB L2 plus 96 MB L3 cache memory provides excellent hit rate in short access time enabling improved system performance
Letting warm pools hide replenishment cost
Symptom: claim latency looks excellent until the pool empties. Correction: measure pool fill, depletion, replenishment, and cold fallback during the same workload.
Ignoring quotas and placement
Symptom: two runs with the same vCPU label have different results. Correction: capture effective quota, affinity, SMT placement, throttling, and oversubscription.
Blaming remote workspace latency on the CPU
Symptom: a file-heavy task slows when the workspace is mounted remotely. Correction: run a local-data CPU variant and a production-like I/O variant, and report the storage path separately.
Reporting only averages
Symptom: an acceptable mean conceals timeouts or long tails. Correction: publish median and tail percentiles with run count, duration, and offered load.
Choosing the quietest run
Symptom: the result cannot be reproduced under ordinary background activity. Correction: disclose all repetitions, include controlled co-tenant pressure, and explain any exclusions.
Publication checklist
- State whether the headline result is CPU execution, task capacity, or provisioning capacity.
- Name the isolation boundary and threat-model assumptions.
- List CPU topology, SMT policy, memory, storage, OS/kernel, runtime, image, vCPU, quota, affinity, and oversubscription.
- Describe the fixed workload, input, validation rule, and workspace path.
- Show cold and warm conditions where both can occur in production.
- Include a concurrency ramp, burst test, and sustained churn test for lifecycle behavior.
- Report throughput, median, tail percentiles, errors, throttling, queue depth, duration, and repetition count.
- Mark the throughput plateau and the latency or error objective crossing.
- Keep project specifications, vendor-published methods, and your own measurements clearly distinguished.
- Preserve raw timestamps and configuration artifacts so the result can be reproduced after software or kernel updates.
How to turn the results into a sizing decision
Choose the capacity number from the workload and service objective that matter to your deployment. If the goal is batch throughput, use the sustainable plateau under the intended co-tenant load. If the goal is interactive agents, use the highest concurrency that keeps the selected tail latency and error targets. If startup dominates user experience, size the controller, image cache, and warm pool from lifecycle results rather than from CPU-only throughput.
Repeat the benchmark after changing processor generation, SMT policy, runtime, kernel, image, quota, or workspace architecture. Any of those changes can move the knee even when the nominal vCPU count is unchanged. A useful result is therefore a complete configuration-plus-distribution record, not a single benchmark score.
Free tools Windows power users keep installed
One-click scans. No signup required.
