Fine-Grained Contention Analysis

• Fine-Grained Contention Analysis is a method of examining conflicts at the precise level of semantic components, moving beyond coarse aggregate metrics.
• The approach uses refined metadata, targeted analytical units, and formal models to replace monolithic conflict analyses for improved accuracy and performance.
• Empirical studies across databases, transactional memory, and runtime systems show that fine-grained analysis reduces false conflicts, lowers abort rates, and enhances throughput.

Searching arXiv for recent and foundational work relevant to fine-grained contention analysis across databases, systems, memory hierarchies, runtimes, and concurrent algorithms. Fine-grained contention analysis is the study of contention at the level at which interference is actually created, propagated, and observed, rather than at a coarse aggregate level such as an entire row, resource class, or execution history. Across transaction processing, shared-memory concurrency, multicore timing analysis, cluster diagnosis, GPU communication overlap, FPGA sharing, and network allocation, the common problem is that coarse metadata or coarse observation can inflate apparent contention and thereby mischaracterize both performance loss and mitigation opportunity. In this sense, the field is concerned not only with contention itself, but with the granularity at which “a conflict” is defined, measured, and attributed (Huang et al., 2018, Yang, 2018, Carletti et al., 2023, Oltchik et al., 2020).

1. Conceptual basis: true contention, false contention, and avoidable contention

A central theme in the literature is that many observed conflicts are not logically necessary. In optimistic concurrency control, a single version per row can cause a transaction to abort even when another transaction modified only a disjoint field of the same record; the paper on timestamp granularity treats these as false conflicts induced by coarse metadata rather than by true logical dependence (Huang et al., 2018). In fine-grained concurrency verification, the corresponding distinction is between arbitrary internal races and effect races: only the latter are the internal steps whose precedence orders cause different visible histories (Yang, 2018). In shared-memory HeSoCs, the assumption that a read-only, no-cache synthetic workload universally represents worst-case memory contention is shown to be unsafe, because the worst interference-producing traffic pattern is hardware dependent (Carletti et al., 2023). In torus networks, equal-sized partitions can expose substantially different internal bisection bandwidths, so part of the observed communication slowdown is avoidable contention created by suboptimal partition geometry rather than by the inherent size of the allocation (Oltchik et al., 2020).

These results collectively shift the meaning of contention analysis. The relevant question is often not simply whether two activities overlap, but whether the overlap occurs on the same semantic component, cache set, queue, link cut, or resource-acquisition path. A plausible implication is that contention analysis is best understood as a representation problem as much as a scheduling or synchronization problem: the choice of metadata, abstraction, and observable determines what the system will count as a conflict.

2. Analytical units and formal models

Different subfields instantiate fine-grained analysis with different analytical units, but they share the goal of replacing monolithic conflict models with structured ones.

Domain	Fine-grained unit	Representative formalization
OCC	Record component $c_i$	$\text{ver}(R,c_i)$ instead of one $\text{ver}(R)$ (Huang et al., 2018)
Transactional memory	Window transaction and conflict-graph degree	$W$, $G=(V,E)$, congestion $C$ (Sharma et al., 2010)
Shared cache WCET	Memory reference and contention region	$r^k=(\omega^k,\delta^k,age^k)$, $\rho^k=\kappa-age^k$ (Zhao et al., 19 Aug 2025)
Cluster diagnosis	Task–resource–host blame path	RATP and ProtoGraph (Kalmegh et al., 2017)
Metric-driven system identification	Metric node and task head	$G=(V,E)$, $Z_k=g_k(H)$, $\text{ver}(R,c_i)$0 (Yang et al., 28 Jan 2026)

In OCC, the standard validation rule can be written as

$\text{ver}(R,c_i)$1

whereas fine-grained validation replaces one record version with component versions and validates only the components actually read: $\text{ver}(R,c_i)$2 This makes contention component-specific rather than row-wide (Huang et al., 2018).

In window-based transactional memory scheduling, the analysis is parameterized by an $\text{ver}(R,c_i)$3 execution window, a conflict graph $\text{ver}(R,c_i)$4, and congestion

$\text{ver}(R,c_i)$5

where $\text{ver}(R,c_i)$6 is the degree of transaction $\text{ver}(R,c_i)$7 in the conflict graph. The important refinement is that the schedule length is expressed in terms of in-window conflict structure rather than a coarse global serialization assumption (Sharma et al., 2010).

In inter-core cache contention analysis for WCET, the fine-grained object is a memory reference

$\text{ver}(R,c_i)$8

and the eviction threshold for that reference is

$\text{ver}(R,c_i)$9

A remote access pattern must provide one remote access to each of $\text{ver}(R)$0 unique addresses to force a miss on that reference (Zhao et al., 19 Aug 2025).

In high-dimensional system environments, the fine-grained object is no longer an individual lock or cache line but a graph-structured metric state. The framework for multi-task contention identification begins from

$\text{ver}(R)$1

introduces a graph

$\text{ver}(R)$2

and then decouples contention types through

$\text{ver}(R)$3

with adaptive multi-task loss

$\text{ver}(R)$4

Here granularity is expressed as metric dependency structure and task-specific discrimination rather than as direct lock or queue contention (Yang et al., 28 Jan 2026).

3. Transaction processing and fine-grained concurrency

In transaction processing, the literature shows that contention behavior can change qualitatively when versioning or scheduling is refined. The timestamp-granularity study argues that timestamp granularity is itself a major concurrency-control parameter. In TPC-C, a New-order transaction reads a District row to obtain the tax rate, while a concurrent Payment transaction updates the YTD field in the same row; with one timestamp per row, OCC treats this as a conflict even though the read and write are disjoint at the application level. By assigning different timestamps to disjoint components, the system reduces false conflicts. On TPC-C, OCC with fine-grained timestamps becomes the fastest mechanism at almost all measured core counts; its abort rate at 128 threads falls from 30.91% to 1.75%; OCC with fine-grained timestamps outperforms TicToc with coarse-grained timestamps by 1.37x at 96 threads; and even when both use fine-grained timestamps, OCC still beats TicToc by as much as 1.14x at 128 threads (Huang et al., 2018). This result is especially significant because previous work had reported TicToc having 1.8x higher throughput than OCC at 80 hyperthreads.

Strife approaches the same high-contention OLTP problem by exploiting structure in the workload rather than by refining per-record metadata. It partitions a batch into conflict-free clusters $\text{ver}(R)$5 and a residual set $\text{ver}(R)$6, executes each conflict-free cluster serially on its own core without concurrency control, and then executes the residual cluster with conventional concurrency control. The clustering heuristic is built on an access graph $\text{ver}(R)$7 and proceeds through spot, allocate, and merge stages, with a residual bound $\text{ver}(R)$8 and $\text{ver}(R)$9 in the experiments. The paper reports throughput improvements of up to $W$0 over traditional protocols on both TPC-C and YCSB, and up to $W$1 or $W$2 in especially high-skew YCSB settings, while also showing that at low contention Strife can be worse than 2PL baselines because the analysis overhead outweighs the benefit (Prasaad et al., 2018).

For transactional memory, window-based greedy contention management makes the granularity explicit through the $W$3 execution window and the maximum in-window conflict degree $W$4. The paper shows that a trivial greedy contention manager can require $W$5 time, but that randomized greedy algorithms yield much better schedules. Offline-Greedy achieves a schedule length $W$6 with high probability, while Online-Greedy achieves $W$7 with high probability and does not require knowledge of the conflict graph (Sharma et al., 2010). The analysis here is fine-grained because the scheduler is parameterized by conflict degree inside a window rather than by a single system-wide load parameter.

Lock-free data structures present a related but distinct view. Their performance model separates hardware conflicts, due to concurrent calls to atomic primitives, from logical conflicts, caused by simultaneous operations on the shared data structure. In the cyclic steady state of the model, throughput is

$W$8

where $W$9 is the number of failed retries per thread between successive successes. The paper also derives that the maximum number of wasted retries is $G=(V,E)$0 (Atalar et al., 2015). At the semantic level, the effect-race paper argues that the correct unit of fine-grained analysis is not every internal race but the effect race relation $G=(V,E)$1, which is symmetric, irreflexive, and non-transitive, and which identifies the internal steps whose precedence orders generate different histories. In that formulation, linearization points are formalized as typical effect race relations rather than as merely informal proof annotations (Yang, 2018). Together these works show that fine-grained contention analysis in concurrent objects spans both performance and correctness: it concerns which conflicts reduce throughput and which internal races actually matter to observable behavior.

4. Memory hierarchies, runtimes, and accelerator systems

At the architecture level, fine-grained contention analysis often means replacing universal worst-case assumptions with hardware- and state-aware characterizations. For heterogeneous SoCs, the study of worst-case memory contention shows that READ_MISS is not universally the worst-case interference pattern. On the Xilinx ZU9EG, MEMSET generates the highest interference, with slowdown reaching about $G=(V,E)$2, while READ_MISS peaks around $G=(V,E)$3; on the NVIDIA TX2, MEMCPY generates the highest interference. Relying on READ_MISS can therefore underestimate worst observed slowdown by more than $G=(V,E)$4, and in some combined FPGA/CPU scenarios slowdown can exceed $G=(V,E)$5 (Carletti et al., 2023). In multicore WCET analysis, a further refinement uses contention regions and dynamic programming to compute shared-cache interference from actual cache age and access multiplicity. Compared to prior methods, the proposed analysis reduces inter-core cache interference by 52.31% on average and WCET estimations by 8.94% on average, with complexity $G=(V,E)$6 (Zhao et al., 19 Aug 2025).

Runtime systems exhibit the same phenomenon. In OpenMP tasking, Taskgraph identifies contention on shared runtime resources such as task queues and dependency-tracking hash tables, and reduces it by precomputing or recording a task dependency graph. On a synthetic benchmark with $G=(V,E)$7 tasks, LLVM + taskgraph shows 132.2 ms overhead versus 466.2 ms for LLVM, while GCC + taskgraph shows 345.3 ms versus 3582.6 ms for GCC (Yu et al., 2022). For tensor-parallel Transformer execution, T3 argues that naïve overlap of producer GEMM and all-reduce causes contention on compute units and memory bandwidth. Its track-and-trigger design moves tracking to the memory controller, uses remote_map and dma_map, and offloads reduction to compute-enhanced memories. The paper reports 30% geomean speedup on communication-heavy sublayers, with a maximum of 47%, and 22% geomean reduction in data movement, with a maximum of 36% (Pati et al., 2024).

FireGuard extends the same logic to fine-grained security analysis on real OoO superscalar cores. It identifies contention at commit-stage data extraction, PRF access, LSQ access, FTQ access, ROB commit paths, and broadcast-style distribution, and mitigates these with a buffer-free data-forwarding channel, superscalar mini-filters, paired FIFO queues, and a broadcast-free mapper. It reports that feasibility studies on Apple’s M1-Pro, Huawei’s Kirin-960, and Intel’s i7-12700F require less than 1% SoC area overhead (Jiang et al., 2 Apr 2025). VersaSlot analyzes contention introduced by dynamic partial reconfiguration on FPGA clusters, especially the fact that PCAP can load only one partial bitstream at a time. Its Big.Little slot architecture, dual-core split between scheduling and PR handling, and cross-board switching reduce both partial reconfiguration contention and task execution blocking, achieving up to 13.66x lower average response time than traditional temporal FPGA multiplexing and up to 2.19x average response time improvement over prior spatio-temporal sharing systems (Gu et al., 7 Mar 2025). These results suggest that at the architecture and runtime layers, fine-grained contention analysis is often inseparable from queueing topology, datapath width, and reconfiguration granularity.

5. Attribution, diagnosis, and learned contention identification

Another branch of the literature treats fine-grained contention analysis as an attribution problem. ProtoXplore is designed for multi-tenant cluster frameworks and asks whether a slowdown is actually due to concurrent queries, and if so, which concurrent queries are responsible. Its quantitative core is Resource Acquire Time Penalty, which measures how much time a task spends waiting relative to the amount of resource it acquires, and its explanation engine is ProtoGraph, a multi-level directed acyclic graph spanning target query, target stages, resources, resource-host pairs, blame explanations, source stages, and source queries. The system distinguishes concurrency-induced slowdown from known non-concurrency causes and unknown causes, and the paper emphasizes that simple overlap is insufficient for blame because a highly overlapping source query may itself have been blocked during the same interval (Kalmegh et al., 2017).

In high-dimensional system monitoring, the graph-structured deep learning framework addresses a different diagnosis task: contention type identification from multivariate metric sequences. The contention types include CPU contention, I/O conflicts, memory pressure, network bottlenecks, and cross-resource hybrid contention. The model constructs system state representations from high-dimensional metric sequences, captures latent dependencies among metrics with graph-based modeling, and decouples contention types through multiple parallel prediction heads. On the Alibaba Cluster Trace 2018 dataset, it reports Accuracy 0.932, Recall 0.918, Precision 0.907, and F1 0.912, outperforming the strongest listed baseline, GAT, by +0.029 Accuracy, +0.030 Recall, +0.026 Precision, and +0.028 F1 (Yang et al., 28 Jan 2026).

The contrast between these two approaches is instructive. ProtoXplore is host-, task-, and resource-aware and is designed for blame assignment in a running cluster. The graph-structured multi-task model is metric-graph-aware and is designed for contention type recognition in a high-dimensional monitoring space. This suggests that “fine-grained” can refer either to causal granularity in an execution graph or to representational granularity in a learned state space.

6. Limits, model dependence, and broader implications

The literature also emphasizes that fine-grained contention analysis is highly sensitive to model assumptions. The survey on adversarial contention resolution shows that the achievable latency, throughput, and stability depend sharply on whether arrivals are static or dynamic, whether feedback is ternary or binary, whether collision detection is available, whether the number of participants is known, and whether the adversary can jam the resource. In the static setting, Binary Exponential Backoff has makespan $G=(V,E)$8, while Sawtooth-Backoff and TSTB achieve $G=(V,E)$9; in dynamic adversarial settings, protocols that appear satisfactory under static analysis can become unstable or achieve only weak rates (Banicescu et al., 2024). The broader lesson is that fine-grained analysis does not remove assumption sensitivity; it makes that sensitivity explicit.

The same point appears in concurrent-object construction. Under the stochastic CRQW model, contention-resolving read/write registers and CAS registers can achieve $C$0 latency with high probability while using $C$1 shared words, and the resulting constructions compose to LL/SC, fetch-and-increment, bounded max registers, and counters. But the paper also proves a space–latency trade-off: any implementation using space $C$2 and latency at most $C$3 with high probability must have expected latency at least $C$4 (Bender et al., 16 Apr 2026). Fine-grained mitigation therefore coexists with lower bounds.

At the network level, the paper on partitioning and avoidable contention shows that scheduler policy can create or remove contention independently of machine size. For contention-bound workloads, reshaping a torus partition to maximize internal bisection bandwidth can yield up to a $C$5 speedup, and the benchmarking results on Mira and JUQUEEN track that prediction closely (Oltchik et al., 2020). This reinforces a broader misconception addressed across the literature: equal resource quantity does not imply equal contention behavior.

Taken together, these works establish a common principle. Fine-grained contention analysis is not a single algorithmic technique but a methodological stance: contention must be resolved at the granularity of semantic components, conflict graphs, metric dependencies, cache references, queue interactions, network cuts, or resource-acquisition paths that actually generate interference. When analysis remains coarse, systems may overestimate conflict, misidentify culprits, or optimize the wrong layer. When analysis becomes fine-grained, the reported benefits include lower abort rates, tighter WCET bounds, more accurate blame assignment, better overlap of communication and computation, lower runtime overheads, and improved scheduling or allocation decisions. The literature therefore treats granularity itself as a first-class determinant of contention behavior, rather than as a secondary implementation detail.