Discover how Edgegap works

Discover how Edgegap works

You Are Your Own Noisy Neighbor: Containers, Multi-Tenancy and Guaranteed Resources

Published

Published

Published

Edgegap Insights Series banner: Noisy Neighbor Technical Deep Dive, with a diagram of what each game server owns and shares on one server.

Key Insights

Key Insights

Key Insights

Short answer: Noisy neighbors come from oversold resources, not from sharing a machine. A container platform that guarantees each game server its CPU and memory provides isolation equal to, and often stronger than, a dedicated bare-metal server running many matches of one game. Treating co-tenancy as the risk pushes studios toward idle dedicated fleets or away from authoritative servers toward peer-to-peer or relays, two costly answers to a problem guaranteed resources already solve.

  • You are your own noisy neighbor: A dedicated server runs dozens of matches at once, and the kernel treats your own busy matches exactly like another studio's.

  • Guaranteed resources remove most contention: With CPU and memory allocated through cgroups and no overcommit, a busy neighbor is held to its own limit, and Google's Heracles reached 90% average utilization with zero latency SLO violations by isolating each shared resource.

  • Some "noisy neighbor" incidents were misdiagnosed: At Indeed (a web service, not a game), latency blamed on noisy containers turned out to be the kernel's own CPU-quota handling, and fixing it cut worst-case response latency from over 2 seconds to 30 ms.

  • Bare metal does not escape shared hardware: L3 cache, memory bandwidth, I/O, power and SMT are shared by every match on a physical machine, whoever owns it, and most of these effects add only a few percent.

  • CPU wait time is the metric that reveals a real noisy neighbor: Utilization shows how busy a server is, not whether it is starved, while Linux Pressure Stall Information reports how long its threads waited for a core, which Edgegap monitors per deployment.

The fear of the "noisy neighbor" is one of the most common objections studios raise against running game servers in containers on shared infrastructure. The usual remedy proposed is single tenancy: rent a dedicated bare-metal machine so that no other company's workload sits next to yours.

The fear itself may be more myth than measurement. It largely took root on shared-core cloud VMs: cheap, deliberately oversubscribed instances built for low-traffic web servers, where a neighbor's spike really can take CPU time away from you. Game servers have very different needs, and Edgegap does not use that class of machine.

Single tenancy misses the point. A modern bare-metal server has 32, 64 or more cores, and no studio runs one match per machine. It packs dozens of match instances onto the same host, and every one of those instances is a neighbor to every other. If a large battle breaks out in match 17 while match 18 sits in a lobby, the physics of contention are identical whether match 18 belongs to the same studio or to another one. On a dedicated server, you are your own noisy neighbor.

Tenancy, in other words, is not the variable that matters. What matters is whether each workload has guaranteed resources that nobody else, not another studio and not your own other matches, can take away. This paper explains, from the CPU up, how contention actually happens, what guaranteed resources do and do not protect against, how large the residual effects are according to published research, and which metric a studio should actually watch.

1. How a CPU works: the kitchen

A CPU is a very fast, very literal cook. It does not understand a game, a match or a player. It executes tiny instructions, one after another, billions of times per second. Throughout this paper we will keep one picture in mind: a restaurant kitchen.

Diagram of one server: a scheduler run queue feeds CPU cores whose hardware threads go to individual game servers, while SMT execution units, L1/L2 and L3 cache, memory bandwidth, network, disk and the chip's power budget are shared.

The instruction loop

Every program compiles down to machine instructions: load a value, add two values, compare them, jump to another instruction if the result is zero. The CPU core runs a loop of fetch (read the next instruction), decode (work out what it means) and execute (do it). In the kitchen, this is a cook reading one line of a recipe, doing it, and reading the next. The cook never sees the whole dish, only the next line.

The clock

A core advances its work on each tick of a clock. A 3.5 GHz core ticks 3.5 billion times per second. Think of a metronome setting the pace of every chop. Modern CPUs also vary that pace dynamically (turbo boost), running faster when they have power and thermal headroom, and slower when they do not. We will come back to this.

Pipelining and speculation

A core does not wait for one instruction to finish before starting the next. It overlaps the stages, the way a cook reaches for the carrots while still finishing the onions. When the code branches ("if the player is in range, compute damage"), the core predicts the likely outcome and starts working on it before it knows the answer. A correct guess saves time; a wrong one means throwing the work away and redoing it. Modern predictors are right the vast majority of the time.

The memory hierarchy

A core can only work on data it has close at hand, and distance is everything:


Level

Kitchen equivalent

Typical access time

Registers

Ingredients in the cook's hands

under 1 ns

L1 / L2 cache (private to each core)

The cook's own cutting board

about 1 to 4 ns

L3 cache (shared by cores on the chip)

The shared spice rack

about 10 to 20 ns

RAM

The walk-in fridge across the kitchen

about 60 to 100 ns

SSD / network storage

The grocery store down the street

10,000 ns and up

A large part of CPU design is about predicting which ingredients the cook will need next and putting them on the counter before they are asked for. A cook who constantly walks to the fridge is a slow cook, no matter how fast their hands are. Note that the L3 cache and the path to RAM are shared between cores; this matters later.

Cores and hardware threads

A modern server CPU has many cores, which means many cooks in the same kitchen. They work in true parallel. Some CPUs also offer simultaneous multithreading (SMT, called Hyper-Threading by Intel): each physical cook presents themselves as two cooks to the restaurant, switching between two recipes whenever one is stalled waiting for an ingredient. This squeezes more work out of each cook, but two "cooks" on SMT share one pair of hands.

The scheduler

A server runs far more programs than it has cores. The operating system's scheduler is the expediter at the pass: it decides which ticket each cook works on and for how long. On Linux, the default scheduler (CFS, and since kernel 6.6 its successor EEVDF) gives each runnable task a fair slice of time, measured in milliseconds, then switches. When a task is runnable but no cook is free, it waits in a run queue. That waiting time is the single most important number in this paper.

Interrupts

When a network packet arrives or a timer fires, the hardware rings a bell at the pass. The cook pauses, handles the urgent event briefly, and resumes. For a game server, packet arrival is a constant stream of these bells.

2. Containers: sealed workstations in a shared kitchen

A container is not a small virtual machine. It is an ordinary Linux process that the kernel wraps in two sets of controls: namespaces, which decide what the process can see, and control groups (cgroups), which decide how much of the machine it can use.

Namespaces: the walls of the workstation

Namespaces give a process its own view of the filesystem, process IDs, network interfaces, hostname and users. A game server in a container sees only its own files and its own processes, and believes it has the machine to itself. In the kitchen, each container is a sealed workstation with its own labeled bins: the exact ingredients, utensils and recipe card one dish needs. The Thai station cannot reach into the Italian station's olive oil.

Images: the meal-kit template

A container image is a frozen, versioned package of everything the program needs: binaries, libraries, configuration. A running container is one workstation set up from that template. Ten identical workstations can be set up from one image in seconds, in any kitchen that accepts the same kits. This is why containers eliminate "it works on my machine" problems and why they start fast. Edgegap's image caching takes this further: Edgegap deploys a complete game server from cold start in a median of 2 seconds.

The shared kernel: same cooks, same building

Every container on a host shares the same Linux kernel, the same CPU cores and the same physical memory. A container does not bring its own cook; it brings its own pantry and its own rules. That is what makes containers lightweight, and it is also why the question of resource isolation exists at all.

cgroups: the rationing rules

cgroups are where the expediter writes down each station's allowance. The controllers that matter for game servers are:

  • cpu: a quota of CPU time per period (for example, 200 ms of CPU every 100 ms, equivalent to two cores), and a relative weight used when the machine is contended.

  • cpuset: pins a container to specific physical cores, so its cooks are its cooks and nobody else's.

  • memory: a hard ceiling on RAM, plus reservation and protection settings that keep the kernel from reclaiming a container's memory to feed another.

  • io: limits and weights on disk throughput and operations per second.

Most studios first meet containers through Docker on their development machines, where it is a convenient way to build and test a game server image. Docker, however, is a packaging and tooling layer; the isolation itself comes from the kernel's namespaces and cgroups. Edgegap's engine plugins (its automated build tools) use Docker to package a studio's build into a container image, and studios can run that image locally with Docker to test it. Once the image is uploaded, Edgegap deploys it on the studio's behalf without Docker, configuring those kernel controls directly through its own orchestration.

Linux has two generations of cgroups. Version 1 (2008) let each controller live in its own separate hierarchy, which produced inconsistent accounting and some well-known pathologies. Version 2 (stable since kernel 4.5, the default in all major distributions since roughly 2021) unifies everything in a single tree, fixes memory and I/O accounting, and adds Pressure Stall Information (PSI), a direct measurement of how long tasks waited for CPU, memory or I/O. We return to both points in the conclusion.

Virtual machines, for comparison

A virtual machine is a different approach: instead of a workstation inside the shared kitchen, you build a whole kitchen inside the building, with its own copy of the house rules (its own kernel) running on a hypervisor. VMs are heavier and slower to start. They are also not automatically better isolated from noisy neighbors: on shared-core and burstable tiers, a cloud VM's "vCPU" is a time slice of a physical core shared with other customers, and the hypervisor runs exactly the same kind of scheduler described above.

Orchestration

Running containers across a fleet requires a manager that decides which kitchen hosts which workstation, opens more when demand spikes, closes them when it falls, and routes orders away from a kitchen in trouble. That is the role of an orchestrator, and for game servers it is what Edgegap does: placing each match on a host close to its players, with a defined resource allocation.

3. What a noisy neighbor actually does

A noisy neighbor is any workload whose sudden demand degrades another workload on the same machine. In the kitchen: the station next to yours gets a party of forty, and its cook starts grabbing burners you were not using "right now", borrowing the cooks' time, and crowding the fridge doorway. Your dish did nothing wrong, but it comes out late.

Technically, the degradation happens through four mechanisms.

1. CPU run-queue contention

If more threads are runnable than there are cores available to them, some wait in the scheduler's run queue. For a game server ticking at 30 or 60 Hz (its tick rate), each tick has a budget of 33 or 16.7 ms. A few milliseconds of queueing at the wrong moment pushes a tick past its deadline, and players feel it as rubber-banding or hit-registration errors. This is the classic noisy neighbor, and it exists only when the machine has promised more CPU than it physically has.

2. Quota throttling

When a container has a CPU limit (a cgroup quota), the kernel stops scheduling it once it has used its quota for the current period, even if cores sit idle. A bursty, multi-threaded game server can burn its quota early in a 100 ms period and then be frozen for the rest of it. This is not caused by a neighbor at all, but it looks exactly like one in a latency graph, and it is responsible for a large share of "noisy neighbor" reports in practice (see the conclusion for the kernel bug that made this much worse between 2018 and 2019).

3. Memory pressure

If the machine's RAM is oversold and every workload grows at once, the kernel starts reclaiming pages: evicting file caches, compressing memory, or swapping to disk. A game server whose working set gets pushed out to disk suffers stalls of milliseconds to seconds. In the kitchen, someone has packed up your ingredients and sent them back to the grocery store.

4. Shared hardware contention

Even with dedicated cores and dedicated RAM, some hardware is physically shared: the L3 cache, memory bandwidth, the network card, the disk, the chip's power budget, and, with SMT, the execution units of a physical core. Section 5 quantifies these.

You are your own noisy neighbor

Notice that none of these mechanisms cares who owns the neighboring workload. The kernel scheduler has no concept of "studio". A run queue does not ask whose thread is ahead of yours; an L3 cache does not know whose data it is evicting.

Consider a studio that rents a dedicated 64-core bare-metal server and runs 40 matches on it. On a Friday evening, ten of those matches hit their end-game phase at once: more players alive in a smaller zone, more projectiles, more physics. If the studio has packed those 40 matches using CPU shares or overcommitted limits (which is common, because packing is how dedicated servers pay for themselves), the ten busy matches will steal CPU time from the other 30 through exactly the same run-queue and cache mechanisms described above.

Single tenancy changes the name on the invoice of the neighbor. It does not remove the neighbor. The same is true if you run your own Kubernetes cluster with Agones on your own servers: every game server pod on a node is a neighbor to every other, and without pinned cores and guaranteed resource requests you remain your own noisy neighbor. A studio that is genuinely concerned about contention should be asking a different question: are my matches' resources guaranteed, or are they shared on a bet that not everyone will be busy at once?

4. How guaranteed resources remove the bulk of the problem

Guaranteed resources means the platform never sells more than the hardware has. Each container gets a CPU allocation enforced by the kernel's cgroups, a memory reservation that cannot be reclaimed for someone else, and no CPU quota tight enough to throttle normal bursts. In the kitchen: each station's burner time is reserved for it, even when idle, and the restaurant never booked more stations than it has burners.

This directly eliminates mechanisms 1 and 3 from Section 3, and, configured properly, mechanism 2:

  • No run-queue contention from others: Because no host is allocated beyond its thread count, every container's CPU allocation exists in hardware, and a busy neighbor is held to its own limit instead of taking the CPU your server was given. It can still share a physical core's execution units with whatever runs on the sibling thread (Section 5.4).

  • No memory reclaim from others: A reserved memory allocation is not taken back to feed a neighbor, so the game server's working set stays in RAM.

  • No throttling surprises: Without an overcommitted quota, a burst consumes threads the container already owns.

Assumption used in this paper

One vCPU equals one hardware thread, not one physical core. No host is allocated beyond its thread count, and memory is reserved. Because each physical core has two threads, a container's work may share a physical core with another container.

The evidence points consistently in one direction:

Finding

Source

Google colocated latency-critical services (web search, a key-value store, ML clustering) with batch jobs and reached 90% average server utilization with zero latency SLO violations, by combining core pinning with cache, memory bandwidth, network and power isolation. With only container priorities (shares) and no pinning, the same colocations violated latency targets even at low load.

Lo et al., Heracles, ISCA 2015 [1][2]

In Heracles, pinning latency-critical and batch tasks to separate cores with cpuset was by itself sufficient to eliminate same-core scheduling interference and hyperthread interference.

Lo et al. [1], summarized by Luu [3]

A large-scale review of public-cloud performance studies concluded that CPU-bound performance depends mostly on the hardware actually allocated, while I/O-bound workloads are the ones sensitive to noisy neighbors.

Leitner and Cito, ACM TOIT 2016 [4], summarized in Duet Benchmarking [5]

A 2025 study running a realistic stream-processing benchmark on AWS for more than three months found throughput variability to be less pronounced than often assumed, with a coefficient of variation below 3.7%.

Stream-processing variability study, arXiv 2025 [6]

When Indeed traced its "noisy" container latency to the kernel's CPU-quota handling (not to neighbors), fixing it cut worst-case response latency from over 2 seconds to 30 ms.

Chiluk, Indeed Engineering, 2019 [7]

The last row matters more than it looks. Some of what teams have historically labeled "noisy neighbor" was never a neighbor: it was quota throttling inside their own container, caused by configuration or a kernel bug. Guaranteed allocations, without tight quotas, remove that class of problem entirely. Edgegap has been in business long enough to have seen thousands of games and server configurations, and that history has raised both the team's expertise and the quality of how the platform is configured and used.

What remains after CPU, memory and quota contention are removed is the set of genuinely shared hardware components. They are real, they are measurable, and they are much smaller.

5. Caveats and limitations

Guaranteed CPU and memory do not make a server perfectly isolated, and we would rather state the residual effects than sound biased. Five shared components can still transmit some interference between containers on the same host, including between a studio's own matches on its own dedicated server (so this could impact you whether you run on Edgegap or your own container based architecture):

1. The shared spice rack: last-level (L3) cache

For game servers, a non-issue: a match's hot state fits within the L3 cache each core gets, keeping the impact in the low single digits of percent.

Cores on the same chip share the L3 cache. A neighbor streaming through large amounts of data can evict your data, forcing extra trips to RAM. The effect is real: in Intel's own benchmark of an interrupt-latency task running beside a heavy memory-traffic antagonist, average latency was 4.53 µs without cache partitioning and 1.62 µs with it [3][8]. But typical server workloads gain little beyond 4 to 6 MB of L3 [3][9], and current AMD EPYC 9004-series server CPUs provide 4 MB of L3 per core [10]. For a game server whose hot state (entity positions, physics broadphase) fits comfortably in that budget, the expected impact under normal colocation is in the low single digits of percent.

2. The fridge doorway: memory bandwidth

For game servers, a non-issue: modern platforms have bandwidth to spare, and game servers are not the memory-streaming workloads that saturate it.

Every core reaches RAM through the same memory controllers. Early studies, published in 2011 on processors that are now about 19 years old and used a shared front-side bus, measured performance swings of up to 25% for web search and 40% for other applications depending on thread placement [11]. Server architecture has changed fundamentally since then. Modern platforms are far wider: AMD's EPYC 9004 series provides up to 460.8 GB/s per socket across 12 DDR5 channels [10], and Google's fleet measurements found the 90th-percentile memory bandwidth utilization to be only 31% [3][12]. Bandwidth saturation requires many neighbors running memory-streaming workloads simultaneously, which is not the profile of a game server.

3. The loading dock: disk and network I/O

For game servers, a non-issue: small UDP packets at a fixed tick rate use a tiny fraction of the network card, and per-container shaping keeps any one workload from taking the link.

Shared NICs and disks are, according to the public-cloud literature, the component most sensitive to noisy neighbors [4][5]. Game servers, however, do little disk I/O after startup, and their network traffic consists of small UDP packets at a fixed tick rate, a tiny fraction of a 25 or 100 Gbps NIC. Traffic shaping (Linux qdisc) and per-container limits keep one workload from monopolizing the link, as demonstrated in Heracles [1].

4. Two cooks sharing one pair of hands: SMT

Handled by placement and monitoring: busy siblings rarely peak together, per-deployment CPU wait time shows when they do, and allocating both threads of a core to one game server removes the effect.

This is the largest residual effect, and it applies equally to a multi-tenant container platform and to a studio's own bare-metal servers with SMT enabled. Each physical core exposes two hardware threads, and with one vCPU counted as one thread, the sibling of your game server's thread may be running another container. When both siblings are busy at once, they compete for the core's execution units, and one kernel mailing-list contributor described a 100 ms request stretching to 165 ms because of a loaded sibling [13]. Game servers are bursty, so both siblings rarely peak at the same moment and the typical effect is far smaller than that worst case. When it does happen, it shows up directly in CPU wait time, which Edgegap monitors per deployment (see the conclusion). Allocating vCPUs in sibling pairs, so both threads of a core belong to the same game server, removes the effect; Heracles showed that keeping siblings within one workload eliminates hyperthread interference [1][3].

5. Kitchen heat: power and thermal limits

Not a multi-tenancy issue: a fully loaded server CPU gives up about 4% of clock speed, and a packed dedicated server pays the same.

When every core is busy, a CPU lowers its clock to stay within its power budget. On a current AMD EPYC server CPU, the maximum single-core boost is 3.7 GHz and the all-core boost is 3.55 GHz [10], a difference of about 4%. That is the ceiling of the effect when the entire chip is fully loaded, and it is a property of the hardware, not of multi-tenancy: a fully packed dedicated server pays exactly the same 4%. The effect can be larger on the high-frequency desktop-class CPUs often sold for bare-metal game hosting. AMD's Ryzen 7000 chips, for example, are "designed to consume all available thermal headroom to provide faster performance": in Tom's Hardware's testing, the Ryzen 9 7950X peaked at 90°C under load against a 95°C safe operating limit [20]. On a chip built to run at its thermal limit, all-core clock speed depends on how well the host is cooled.

How Edgegap handles these

Edgegap applies the following controls on its fleet:

  • Guaranteed CPU allocations enforced through cgroups, with no CPU overcommit on game-server hosts.

  • Hard memory reservations, with no memory overcommit on game-server hosts.

  • No tight CPU quotas on game-server containers, eliminating quota throttling as a source of jitter.

  • Per-container network shaping and placement rules that spread heavy workloads across hosts.

  • Continuous monitoring of per-container CPU pressure, described in the conclusion.

Edgegap typically uses smaller machines, which puts less load on the shared components above. Constant CPU and RAM monitoring also lets the platform know whether a given machine can take more game servers.

6. Estimated impact: container versus bare metal

Both charts assume the same hardware with SMT enabled, so the shared-hardware effects (SMT siblings, cache, memory bandwidth, I/O, power) are identical. The only difference between them is configuration: whether each game server has a guaranteed CPU allocation, and whether the host is packed beyond its thread count.

Chart of estimated added tick time on a container with guaranteed resources: run-queue contention, quota throttling and memory reclaim eliminated; SMT sibling sharing about 10%, up to 65%; cache, memory bandwidth, I/O and power 0.5 to 2%, up to 5%.

Illustrative estimates derived from the ranges in Section 5 and references [3], [8] to [13]; not measured on a specific game

Chart of estimated added tick time on bare metal with packed matches: run-queue contention about 5%, up to 25%; SMT sibling sharing about 10%, up to 65%; cache, memory bandwidth, I/O and power identical to the container setup.

Illustrative estimates; run-queue ceiling follows from 25% packing above core count, SMT ceiling from the kernel report in [13]

The one row that differs is run-queue contention, which comes from packing more busy matches than the host has threads. That practice is common on dedicated servers because packing is how they pay for themselves. A bare-metal server configured like the container (each match given a guaranteed allocation, no packing beyond thread count) produces the first chart instead. Both setups carry the same SMT exposure, which disappears only when vCPUs are allocated in sibling pairs or SMT is disabled. These figures are estimates assembled from published ranges.

Conclusion: a fear built on old kernels

The noisy-neighbor fear, as it is usually expressed by studios, is rooted far more in history than in how modern Linux behaves on a properly run platform.

The first source: shared-core cloud VMs

Public clouds sell two very different kinds of virtual machine. Dedicated-vCPU types reserve each vCPU for one VM. Shared-core and burstable types are deliberately oversubscribed to keep prices low: Google's e2-micro, e2-small and e2-medium share a physical core and are positioned as a cost-effective way to run small, low-intensity apps [17], and AWS T-series instances guarantee only a baseline and rely on CPU credits to burst above it [18]. A t3.nano's baseline is 5% of a vCPU, and in standard mode, once its credits run out it is held at that level [19]. These tiers exist for low-traffic websites, development environments and intermittent jobs. They are also the environment most developers picture when they describe a noisy neighbor, and a game server placed on one will indeed suffer. Edgegap does not use shared-core or burstable virtual machines anywhere in its cloud offering. Every deployment runs on dedicated resources.

The second source: old kernels

Much of the folklore dates from the cgroups v1 era. Separate controller hierarchies produced inconsistent accounting, memory and I/O isolation were weak, and there was no direct way to measure how long a container was waiting for resources. On top of that, a CFS bandwidth-control regression introduced in 2018 (Linux 4.18) caused multi-threaded containers to be throttled heavily while using only a fraction of their CPU quota. It hit Kubernetes and Mesos users hard, became known as the "$1.5 million bug", and was fixed in Linux 5.4 in 2019 [7][14][15]. Many engineers who were burned during that period concluded "containers are noisy", when the real culprit was a kernel bug in quota handling. cgroups v2, now the default across major distributions, unified the hierarchy, fixed memory and I/O accounting, and added Pressure Stall Information [16].

What is true today

With guaranteed, non-overcommitted resources, CPU and memory contention between containers is eliminated by construction. What remains is a set of shared-hardware effects, typically a few percent, that apply identically to a studio's own matches on a dedicated server. Being alone on a machine does not protect you from these effects; guaranteed allocations do.

Edgegap's position

Edgegap's orchestration is built directly on cgroups, and resource isolation is a core competency of the platform rather than a setting left at its defaults. We give studios tools and analytics to see resource usage per deployment, including the signals that reveal a genuine noisy neighbor.

The right metric: CPU wait time

CPU utilization alone cannot tell you whether a game server is being starved. The metric that matters is CPU wait time: how long the server's threads were ready to run but waiting for a core. Linux exposes this directly through PSI, whose cpu.pressure file reports the share of time in which at least some of a container's tasks were stalled waiting for CPU, averaged over 10, 60 and 300 seconds [16]. A small amount of wait time is normal and expected on any multi-threaded system: threads wake up together, the scheduler takes microseconds to place them, and interrupts briefly preempt work. Edgegap does not alert on that baseline. We monitor for wait-time spikes that are both larger and longer than normal thresholds, because those, and not a momentary blip, are what translate into missed ticks and degraded player experience.

What the fear costs

The noisy-neighbor objection pushes studios toward overprovisioned dedicated fleets that sit mostly idle outside peak hours, or toward avoiding authoritative servers entirely in favor of peer-to-peer or relay architectures that are cheaper on paper but weaker against cheating and worse for fairness. Both outcomes are expensive. A studio that replaces the question "who else is on this machine?" with "are my resources guaranteed, and can I see my CPU wait time?" can capture large infrastructure savings and still give every player a server-authoritative experience.

—

References

  1. Lo, Cheng, Govindaraju, Ranganathan, Kozyrakis. Heracles: Improving Resource Efficiency at Scale. ISCA 2015.

  2. Heracles project page, Stanford University.

  3. Dan Luu. Why Intel added cache partitioning (summary of Heracles, Kanev et al. and Intel CAT benchmarks).

  4. Leitner and Cito. Patterns in the Chaos: A Study of Performance Variation and Predictability in Public IaaS Clouds. ACM Transactions on Internet Technology, 2016.

  5. Duet Benchmarking: Improving Measurement Accuracy in the Cloud. ICPE 2020.

  6. Studying Cloud Performance Variability for the Case of Stream Processing Applications. arXiv, 2025.

  7. Dave Chiluk. Unthrottled: Fixing CPU Limits in the Cloud. Indeed Engineering, 2019.

  8. Intel. Cache Allocation Technology white paper, April 2015.

  9. Ferdman et al. Clearing the Clouds: A Study of Emerging Scale-out Workloads on Modern Hardware. ASPLOS 2012.

  10. AMD. AMD EPYC 9654 specifications.

  11. Tang, Mars, Vachharajani, Hundt, Soffa. The Impact of Memory Subsystem Resource Sharing on Datacenter Applications. ISCA 2011.

  12. Kanev et al. Profiling a Warehouse-Scale Computer. ISCA 2015.

  13. Linux kernel mailing list. Real-time scheduling policies and hyper-threading, April 2014.

  14. Dave Chiluk. Unthrottled: How a Valid Fix Becomes a Regression. Indeed Engineering, 2019.

  15. Phoronix. The Linux Kernel Seeing Backport Progress Finally For The "$1.5 Million Dollar Bug".

  16. Linux kernel documentation. PSI: Pressure Stall Information.

  17. Google Cloud. Machine families resource and comparison guide: shared-core machine types.

  18. AWS. Burstable performance instances.

  19. AWS. Standard mode examples for burstable instances.

  20. Paul Alcorn, Tom's Hardware. AMD Ryzen 9 7900X Review: Zen 4 Has a Pricing Problem. October 2022 (power, temperature and overclocking page).

Written by

Mathieu Duperré (founder & CEO)

Sources and/or content collaboration with

Gabriel Parent (Director) for illustrations and formatting.

Get your Game Online Easily & in Minutes

Start Integrating Now!

Get your Game Online Easily
& in Minutes