betaFeedback

WorksComputer Science

SIMTurn: Lightweight Divergent Subgroup Scheduling for Intra-Warp Synchronization

Abstract

Stack-based reconvergence enables efficient SIMT execution with a shared warp program counter and compact control-flow state. However, its fixed serialization of divergent paths can deadlock programs that rely on intra-warp synchronization: a spinning subgroup may prevent a resource-holding sibling from executing. Independent Thread Scheduling (ITS) enables finer-grained progress through per-thread execution state, but introduces additional hardware cost. We present SIMTurn, a lightweight compiler-hardware mechanism that enables forward progress among divergent subgroups while retaining stack-based reconvergence. SIMTurn combines a compiler-inserted yield instruction at potentially blocking loops with a bounded pool of resumable subgroups. The scheduler allows a waiting subgroup to yield to a sibling that can make progress, without requiring independent program counters for every thread. We implement SIMTurn in the compiler, simulator, and RTL on the open-source Vortex GPGPU and evaluate it against baseline IPDOM and per-thread ITS schemes. Across the evaluated GPU thread configurations, SIMTurn introduces only 17-24% scheduler-area overhead relative to IPDOM, compared with 39-91% for ITS, and stays within 8% of IPDOM on workloads that never need cross-subgroup progress. On kernels with genuine cross-subgroup parallelism, SIMTurn tracks ITS closely and is up to 2.7x faster than a software-serialized IPDOM baseline.

CCS Concepts: • Computer systems organization → Parallel architectures; • Software and its engineering → Compilers.

Introduction

GPUs execute scalar threads under the single-instruction, multiple-thread (SIMT) model. Threads are grouped into warps that share one instruction stream, so control state is kept once per warp instead of once per thread. When threads in a warp take different branch directions, the warp diverges into subgroups. Stack-based reconvergence runs

one path at a time and merges the subgroups at the immediate post-dominator (IPDOM) of the branch [11, 19]. It needs only a shared program counter, an active-thread mask, and a compact stack per warp.

This fixed order becomes a problem when threads in the same warp synchronize. Consider the spin lock in Figure 2. One thread acquires the lock and leaves the acquisition loop, while the others keep spinning. The stack keeps the spinning subgroup active and holds the lock holder at the reconvergence point. The lock holder never releases the lock, and the spinning threads never leave the loop. The result is a SIMT-induced deadlock, even though the program would complete under a fair MIMD schedule [11, 19]. The challenge is to let such subgroups make progress while keeping the compact control state of stack-based SIMT.

Figure 2. Ordinary divergence and spin-lock deadlock under strict IPDOM scheduling.

Prior work addresses this problem at different costs. Static SIMT Deadlock Elimination (SSDE) restructures synchronization code in the compiler, and AWARE replaces strict stack traversal with split and reconvergence tables and fairer scheduling [11]. NVIDIA’s Independent Thread Scheduling (ITS) goes further and maintains execution state for every thread [28, 29]. ITS removes the ordering problem, but its control state grows with warp width.

Synchronization does not require this much independence. Threads waiting on the same path can keep sharing one instruction stream. They only need a different subgroup to run and end their wait. Stack-based reconvergence already represents each subgroup as a thread mask and a program counter. What it lacks is a way to schedule subgroups out of stack order. Moreover, the number of subgroups that are live at the same time is typically much smaller than the warp width, so this ability does not need per-thread state.

Building on this observation, we present SIMTurn, a compiler–hardware mechanism that makes divergent subgroups independently schedulable while keeping stack-based reconvergence intact. A subgroup is a thread mask and a resume program counter, so switching subgroups never copies register state. The compiler inserts a yield instruction into loops that may block. On a yield, the hardware rotates execution among one pending subgroup per warp and a bounded pool of parked subgroups. The pool capacity is sized to the workload, not to the number of threads. SIMTurn targets SIMT-induced scheduling deadlocks, not deadlocks from an application’s own lock ordering.

We implement SIMTurn2 in the LLVM-based compiler [22], the SimX simulator, and the RTL of the open-source Vortex GPGPU [10, 38] (Figure 1, additions in red). We compare it against the IPDOM baseline and a per-thread ITS implementation on the same platform. Across warp widths from 4 to 32 threads, SIMTurn adds 17–24% scheduler area relative to IPDOM, compared with 39–91% for ITS. On synchronization kernels with independent work across subgroups, it tracks ITS and runs up to 2.7× faster than software-serialized IPDOM. On control workloads that never need cross-subgroup progress, it stays within 8% of IPDOM’s runtime.

Figure 1. SIMTurn ISA and Microarchitecture modifications to a GPU core pipeline.

This paper makes the following contributions.

  • Subgroup scheduling on stack-based reconvergence. SIMTurn extends IPDOM with a yield instruction, one pending subgroup per warp, and a bounded pool of parked subgroups, without per-thread program counters.

  • An open-source implementation. We implement SIMTurn in LLVM, SimX, and the Vortex RTL. The compiler inserts yields automatically, so kernels need no source changes.

  • A cost and progress evaluation. We compare SIMTurn with IPDOM and ITS on synchronization and control workloads and on ASIC synthesis, and study its sensitivity to pool capacity and lock contention.

Background and Related Work

SIMT Divergence and Stack-Based Reconvergence

SIMT processors execute scalar threads together on SIMD lanes, sharing one instruction stream per warp and using an active-thread mask to select the participating lanes. A branch whose outcome differs across lanes splits the warp into divergent subgroups. A subgroup is a set of threads in one warp that follow the same control-flow path. The processor must preserve each subgroup’s resume PC and decide when the subgroups can resume together [11, 19]. Stack-based control flow handles this with a reconvergence stack. Each divergent entry records a program counter, a thread mask, and a reconvergence point, which under IPDOM is the divergent branch’s immediate post-dominator. The scheduler runs one path while keeping the others as suspended entries, and once the active path reaches its reconvergence boundary another path can run, with masks combined once all participants arrive. Strict stack traversal therefore imposes a depth-first order on divergent paths [11, 19].

This arrangement shares fetch and control across active lanes and keeps inactive paths in compact state, but it couples two distinct decisions, where threads should reconverge and which subgroup may execute next, so divergence management determines both SIMD utilization and the execution order seen by communicating threads [35].

Our chosen platform, Vortex, expresses this model with compiler-generated control-flow instructions [38]. Divergent regions and reconvergence are managed by vx_split and vx_join, while vx_pred and vx_pred_n update thread participation during diverged loops, and the core keeps one live program counter and active mask per warp. This stack-based configuration is the IPDOM baseline used in our evaluation.

SIMT-Induced Deadlock

A synchronization algorithm may require a waiting thread to leave other threads opportunities to execute. Strict divergent-path serialization can violate this requirement within a warp, because a suspended path cannot run until the active path reaches its reconvergence point. Habermier and Knapp analyze this unfairness in stack-based SIMT execution [19], and ElTantawy and Aamodt characterize the resulting synchronization failures as SIMT-induced deadlock [11]. Figure 2 contrasts ordinary divergence with a spin lock. In Figure 2(a), serialization is harmless: each divergent subgroup finishes on its own and the lanes merge. In Figure 2(b), lane 0 acquires the lock and exits the acquisition loop, while lanes 1 and 2 keep spinning. If the spinning path stays active, IPDOM execution holds lane 0 at the loop’s reconvergence boundary. Lane 0 cannot release the lock until lanes 1 and 2 exit the loop, and they cannot exit until it does, so a synchronization dependency and a scheduling dependency form a cycle. The program could complete if the lock holder ran, yet the SIMT execution order prevents it. NVIDIA documents this class of intra-warp lock and mutex limitation for pre-Volta execution [28, 29].

The crucial distinction is between retaining a resume PC and making it schedulable. The processor retains enough information to resume the lock holder, but strict reconvergence ordering prevents it from doing so while its sibling spins. Scheduling the lock holder before the spinning subgroup reconverges can break this cycle without assigning a separate program counter to every waiting lane.

SIMT-induced deadlock is distinct from a cycle in the application’s lock acquisition order. It is also distinct from a dependency on a workgroup that has not been scheduled onto the device, which GPU workgroup progress models address [37]. The mechanism studied here addresses scheduling dependencies among divergent subgroups. Its progress argument depends on reaching suitable yield points, retaining the required parked subgroups, and allowing the participating resident work and memory operations to advance. These conditions separate the execution mechanism from the correctness of the synchronization protocol itself.

Approaches to Forward Progress

Table 1 compares the principal mechanisms by their execution state and how they expose opportunities for progress. The table summarizes mechanisms rather than assigning unconditional deadlock-freedom guarantees, which depend on the supported programs and scheduling model. Figure 3 schematically compares per-warp control state with warp width WW and KK parked slots. SSDE retains IPDOM’s hardware state, and AWARE replaces the stack with split and reconvergence tables. SIMTurn adds one pending slot and KK parked slots to the stack, while ITS maintains a PC per thread.

Figure 3. Per-warp control state across various SIMT control-flow divergence mechanisms.

MechanismControl-flow stateExecution policyScope and requirements
IPDOM [19]Shared warp PC and reconvergence stackStrict stack traversal serializes divergent pathsCompact control; inactive siblings can be prevented from satisfying a wait
SSDE [11]Existing stack-based stateCompiler restructures synchronization to expose path progressDepends on static detection and CFG transformation
AWARE [11]Split and reconvergence tables; scheduling FIFOFairer split scheduling with delayed reconvergenceDecouples scheduling from stack order; table capacity and virtualization matter
DWS [27]Sub-warp execution contextsSubdivides warps to tolerate branch and memory divergenceTargets execution efficiency rather than synchronization progress directly
Hanoi [35]Split/reconvergence stacks and convergence stateModels explicit convergence operations and sibling-path yieldingExamines control-flow behavior inferred from modern NVIDIA execution
ITS [9, 28]Per-thread execution state and convergence stateThreads can advance independently and re-group for shared executionSupports finer-grained scheduling; requires thread-level control state
SIMTurnExisting stack plus pending and parked subgroupsCompiler-directed yielding rotates execution among subgroupsRequires yield coverage and sufficient parked capacity

Table 1. Control-flow mechanisms relevant to intra-warp progress.

Compiler restructuring and split scheduling. SSDE identifies potentially unsafe synchronization and transforms the control-flow graph to let otherwise suspended paths make progress [11]. It preserves the stack hardware, placing the responsibility for exposing progress in the compiler. AWARE instead separates split tracking from reconvergence through a Split Table, a Reconvergence Table, and a scheduling FIFO. Its scheduling and delayed-reconvergence mechanisms relax depth-first execution. The work also explores memory virtualization of these tables. AWARE is the closest architectural precedent for SIMTurn. Both schedule divergent splits, but SIMTurn integrates explicit yielding and bounded parked subgroups with the existing stack-based mechanism. The comparison is thus about the machinery and software interface needed to expose progress, not the discovery that subgroup scheduling helps synchronization.

Independent thread scheduling. Beginning with Volta, NVIDIA maintains execution state at per-thread granularity, including program counters and call stacks, and dynamically groups compatible threads for shared SIMT execution [28, 29]. This permits threads to yield independently and supports synchronization patterns that can deadlock under strict shared-PC execution. The convergence-barrier model described by Diamod et al. includes thread states, resume PCs, participation masks, and explicit convergence operations [9]. These descriptions motivate the per-thread design point evaluated in this paper. Our ITS baseline is an implementation of this design point on the same GPU platform.

Busy-wait overheads. Busy-wait synchronization that does complete can still waste resources. ElTantawy and Aamodt detect spin loops at run time (DDOS) and back off spinning warps (BOWS) to reduce the issue slots and memory traffic they consume [12]. Other work reduces synchronization cost through synchronization-aware warp scheduling [25] and by moving fine-grained locks into scratchpad memory [40]. These approaches target contention between warps, whereas SIMTurn addresses scheduling dependencies among subgroups inside one warp. Run-time spin detection could also help SIMTurn find yield points.

Divergence efficiency and control-flow flexibility. Dynamic Warp Formation regroups threads from different warps at common PCs to improve SIMD utilization [15], and Thread Block Compaction applies a similar regrouping at reconvergence points within a thread block [14], while Dynamic Warp Subdivision addresses branch and memory divergence through independently executing sub-warps [27]. SIMD Reconvergence at Thread Frontiers generalizes reconvergence-point detection beyond the immediate post-dominator to handle unstructured control flow [8], and Dual-Path execution extends each stack entry to hold two live paths that can be scheduled interchangeably [32]. GPU Subwarp Interleaving explores fine-grained interleaving at a subwarp granularity similar to SIMTurn, though its authors report that the added cost did not justify the benefit in a commercial design [7]. Hanoi studies control-flow management using inferred modern NVIDIA ISA behavior, including explicit convergence and yielding operations [35].

Related work improves divergence behavior through compaction prediction [31], divergence analysis and CFG restructuring [1, 6, 30], control-flow melding [34], and multi-path execution [13]. Other studies explore the divergence management design space [24], characterize unstructured control flow [41], or address memory-system and application-level effects through divergence-aware caching and herding [33, 39]. These techniques target the efficiency of divergent execution, whereas SIMTurn targets forward progress between divergent subgroups.

_Positioning SIMTurn._ SIMTurn sits between compiler-only restructuring and per-thread scheduling. Unlike SSDE, it leaves synchronization code unchanged and only marks where a waiting path may yield. Unlike AWARE, it keeps the reconvergence stack for ordinary divergence and uses its added state only when a subgroup yields. Unlike ITS, this state scales with the number of parked subgroups, not with the number of threads. In return, it requires yield coverage and sufficient parked capacity.

Motivation and Design Principles

Challenges of Deadlock-Free SIMT Execution

Stack-based reconvergence keeps control state compact, but its fixed path order can leave a lock holder unschedulable while its siblings spin. Our HT and LCList kernels (Table 2) run into exactly this problem. Our Vortex ITS baseline shows what it costs to lift that order with per-thread scheduling. It adds per-thread PCs and intra-warp scheduling state on top of the existing mechanism, which is far more than a change in scheduling policy alone.

KernelDescriptionSweep parameters
TL-CG/FGProtected-counter increment; CG: one lock, FG: independent locks; adjacent lanes share targets256 work-items; FG: 2/8/32 locks
AM-CG/FGProtected-maximum update, same CG/FG split256 work-items; 25/50/100% participation
HTPreallocated chained hash-table insertion [20]128/512 nodes, 1/8/64 buckets
LCListHand-over-hand sorted-list search & per-key update [17, 18]128 ops, 8/32/128 keys, 0/50/100% updates
ATMTwo-account transfer, locks acquired in account order2/8/32 accounts
CP-DSEndpoint-locked distance-constraint projection on a perturbed grid [3]512 constraints ×2, 4²/8²/16² grid
BH-STOctree offset propagation; child polls parent’s publication [2, 5]128/256/512 nodes
AtomicRedMax-contention reduction: every lane atomic_adds into one global countern=1024n=1024
HistogramPer-bin atomic_add; contention only within a binn=1024n=1024
Rank SortCounting/rank sort; all-pairs comparison, no atomics or locksn=256n=256
PathfinderRodinia dynamic-programming wavefront, halo-cached in local memory [4]16×6416 \times64 grid, y=2y=2, block 16

Table 2. Evaluated benchmarks.

Figure 4 compares the three designs on the HT bucket-lock spin loop. The code and control-flow panels show the compiler instrumentation, where the highlighted vx_yield in panel (b) is the only instruction that SIMTurn adds. The timelines show that IPDOM stalls once the winner is masked off, while a yield lets the lock holder run.

Figure 4. Baseline IPDOM, SIMTurn, and ITS execution of the HT bucket-lock spin loop.

A fully independent program counter for every thread is sufficient for forward progress, but it is not necessary. IPDOM already separates a warp into divergent subgroups, each with an active mask and a suspended control-flow location. Its only limitation is that these subgroups are consumed in a fixed depth-first order. A subgroup that could release a lock or another shared resource is therefore already represented by the divergence mechanism, yet it stays unschedulable while another subgroup waits on it.

A second challenge follows. Subgroup scheduling must not recreate the cost that SIMTurn seeks to avoid. Arbitrary divergence can in theory create as many distinct subgroups as there are threads in a warp, and provisioning for that worst case would again approach ITS-like state.

Design Principles of SIMTurn

Four principles guide how SIMTurn divides forward progress between the compiler, ISA, and microarchitecture.

Schedule divergence, not individual threads. The unit that needs independent progress is usually a divergent subgroup, not a single lane. Threads on the same path already share a PC and run efficiently in SIMT fashion. SIMTurn therefore attaches schedulability to subgroups. Per-lane algorithmic state stays in the existing architectural registers. The only control-flow state needed to resume a subgroup is its thread mask and resume PC, so switching between subgroups never copies register state.

Preserve the IPDOM fast path. Forward-progress support should not penalize the common case where ordinary divergence terminates normally. SIMTurn builds on Vortex’s existing split/join model and does not replace it. vx_split and vx_join continue to identify divergence and reconvergence regions. Subgroup scheduling activates only when execution needs to transfer between paths, so converged execution and non-blocking divergence keep the baseline’s simple warp-level behavior.

Bound expensive resident state. SIMTurn keeps divergence state in dense, inexpensive storage instead of large arrays of timing-critical per-thread state. Parked subgroups live in a bounded pool whose capacity is a configurable architectural parameter and whose bulk storage is BRAM-backed on FPGA implementations. The compiler helps by structuring blocking regions so that a blocking operation needs only a few simultaneously live subgroups. Resident hardware cost therefore scales with the configured pool capacity and not with thread-granular state for every lane.

Use software to expose progress, not scheduling resources. The compiler is better positioned to identify where execution may wait, while hardware is better positioned to choose which ready subgroup runs next. LLVM identifies potentially blocking loops and inserts a lightweight vx_yield at appropriate loop backedges. The hardware interprets this instruction by transferring execution to another runnable subgroup. Unlike an ITS-style convergence optimizer, the compiler does not allocate named hardware barriers or manage their lifetimes across nested control flow. This keeps the compiler transformation simple and leaves scheduling policy in the microarchitecture.

Together, these principles retain SIMT execution wherever threads naturally move together and introduce independence only between the divergent subgroups that require it. The added control-flow state stays proportional to the number of resident subgroups, not the number of threads. The next section describes how these principles are realized in the Vortex microarchitecture and the LLVM divergence pipeline.

SIMTurn Design and Implementation

SIMTurn combines a compiler-generated scheduling point with hardware that retains and selects divergent subgroups. We first explain this execution model, then describe the scheduler and the compiler transformation. We also separate the conditions for correct subgroup progress from the pipeline mechanisms used to implement the design.

Execution Model and ISA Interface

A subgroup consists of a thread mask and a resume PC. The mask determines which lanes participate when the subgroup resumes, while per-thread operands and algorithmic state remain in the existing registers. SIMTurn does not replicate the IPDOM stack for each subgroup. The existing stack continues to maintain the warp’s ordinary reconvergence state, including its return/reconvergence PC, next PC, and active mask. SIMTurn adds two forms of resumable state per warp, a pending subgroup and a pool of parked subgroups. Each parked subgroup is stored as only a mask and a resume PC. Pending work is captured by a divergent loop predicate and can either be restored through ordinary loop completion or selected for independent execution. Parked work has been descheduled and retained for later selection.

Figure 5 shows how a subgroup moves between these states. It is running while its mask and PC are in use, pending or parked while it is retained, and done once its lanes exit. Figure 6 follows these states through the HT lock acquisition.

Figure 5. Lifecycle of a subgroup within a warp.

Figure 6. Subgroup-state transitions during HT lock acquisition.

In panel (a), all three lanes are active and no additional subgroup is needed. In panel (b), lane 0 acquires the lock, and vx_pred_n leaves lanes 1–2 active while it captures lane 0 in the pending register. In panel (c), the yield selects the pending winner, saves the spinning subgroup in the pool, and changes the executing mask to lane 0. The winner can now enter the critical section and release the lock. Later subgroup selections let the parked lanes resume at their waiting PC and retry the acquisition. The loop and exit labels in the figure mark control-flow phases, not individual instructions.

The ISA addition is vx_yield, a warp-control instruction with no register operands. It exposes a point at which the current subgroup can be descheduled in favor of another retained subgroup. The instruction is handled as a warp-stalling control operation, so instruction execution waits until the scheduler has resolved the transition. Its purpose is scheduling, and any memory ordering that a synchronization protocol requires stays part of that protocol.

Subgroup Scheduler

Each numbered event in Figure 5 corresponds to one handler of the scheduler. We describe them in the same order.

State organization. The pending register holds a valid bit, a thread mask, and a resume PC. The parked pool holds mask/PC pairs with a head pointer and an occupancy counter. Two bookkeeping masks track completed lanes and lanes represented in the pool. They prevent a later restoration from reactivating completed work or duplicating lanes owned by another schedulable subgroup. Let KK denote the number of parked slots per warp. The active and pending subgroups are accounted for separately.

Capturing pending work (event 1, park). A divergent vx_pred or vx_pred_n already computes masks for lanes remaining in the loop and lanes leaving it. When both sets are nonempty, the warp-control unit raises pred_park_valid with the exiting mask. The scheduler records these lanes as pending while the remaining lanes continue. Lanes that leave through the same resume PC can accumulate in the pending mask across iterations. This compatibility requirement is essential, because mask accumulation must not combine lanes that need different resume PCs. The recorded PC is taken from the warp’s post-increment PC state.

Selecting another subgroup (event 2, yield). The scheduler responds to yield_valid by saving the current subgroup in the pool and then selecting another subgroup to run. Pending work has priority and can be installed directly, as in Figure 5(c). Otherwise, execution rotates to the oldest parked subgroup. The FIFO orders parked subgroups, and pending priority is a separate part of the policy. After a switch, lanes that were previously prevented from executing can run and satisfy a sibling’s wait.

Restoration (event 3, restore). When no lanes remain on the loop’s continuing path, the warp-control unit raises pred_restore_valid. The scheduler merges a pending mask back into the running subgroup only when the pending resume PC matches the restoration point. This check prevents restoration from applying an older mask snapshot to unrelated subgroup work. When no compatible pending subgroup exists, the running subgroup remains the restoration basis, and the preheader mask in rs2 is not used.

Completion (event 4, exit). A kernel-exiting mask-clear operation records the completed lanes while subgroup work remains and selects pending work or the pool head. The warp retires only when no retained work survives. Temporary mask narrowing in the runtime must keep its existing behavior, because temporarily inactive lanes are not equivalent to permanently completed lanes.

Algorithm 1 summarizes the four event handlers and their selection policy. It abstracts the physical queue operations and the mask bookkeeping, and it is not a complete specification of arbitrary nested control flow. The RTL additionally updates the done and in_pool masks when subgroups are inserted, removed, completed, and restored.

Compiler Transformation

The compiler exposes waiting points through the existing branch-divergence pass. That pass already inserts vx_pred or vx_pred_n at each conditional loop exit to identify the lanes that leave a loop, and the hardware uses the same event to capture a pending subgroup. SIMTurn adds a yield after the predicate in loops that may block, as highlighted in Figure 4. For each divergent loop, innermost first, the pass does the following.

  1. Decide whether the loop may block, using the MAY-BLOCK classifier described below.

  2. Insert vx_tmask in the loop preheader to snapshot the entry mask.

  3. For each conditional exiting branch, compute its predicate with vx_mov and insert it immediately before the branch.

  4. If the branch leaves the loop through its first successor, insert vx_pred_n before the branch and, when the loop may block, a vx_yield right after it. Otherwise, insert vx_pred and no yield.

  5. Replace the branch condition with the new predicate.

Algorithm 1: Warp Scheduler Subgroup Management

Input: Per-warp: pending ⟨live,mask,PC⟩\langle live, mask, PC\rangle; pool (head, count); done, in-pool masks; live mask; warp PC

Procedure InstallNext():

  • if pending.live then live ←\leftarrow pending.mask ∧¬\land\negdone; PC ←\leftarrow pending.PC; pending.live ←\leftarrow false

  • else

    • if pool.count >0> 0 then (mask, PC′) ←\leftarrow pop pool head; live ←\leftarrow mask ∧¬\land\negdone; PC ←\leftarrow PC′

    • else return false // nothing runnable

  • return true

Procedure OnPredPark(else_mask) (event 1): pending.mask ←\leftarrow pending.mask ∨\lorelse_mask; pending.PC ←\leftarrow warp.PC; pending.live ←\leftarrow true

Procedure OnYield() (event 2): push (live, warp.PC) to pool tail InstallNext() // no-op if nothing runnable

Procedure OnPredRestore() (event 3):

  • if pending.live and pending.PC == warp.PC then live ←\leftarrow live ∨\lor pending.mask; pending.live ←\leftarrow false

Procedure OnTmcExit(exiting_mask) (event 4):

  • if pending.live or pool.count >0> 0 then done ←\leftarrow done ∨\lorexiting_mask

  • if not InstallNext() then retire warp

Identifying candidate loops. The current MayBlock classifier recognizes native atomicrmw and cmpxchg instructions, inline assembly containing amo or lr., and direct calls with atomic in the callee name. These cases cover the atomic forms targeted by the implementation. The classifier identifies candidate waiting loops and does not prove that an operation will block. It does not comprehensively detect load-only polling, indirect calls, or synchronization hidden behind unrecognized interfaces.

Placement and ordering. The transformation runs after control-flow structurization, which provides the divergent-loop representation with its preheaders and conditional exits. Yield coverage additionally depends on the placement of the relevant exiting branch. The steps above insert vx_yield for the exit-on-succ_0 form lowered with vx_pred_n. The alternative branch form retains predicate insertion without a yield. The transformation therefore covers this specific insertion case and does not give a coverage guarantee that is independent of branch orientation.

The yield follows the predicate so that the winner has been captured before the remaining lanes request a switch. It is emitted as side-effecting, memory-clobbering inline assembly to constrain compiler motion. This compiler constraint is distinct from hardware memory-ordering semantics. Loops not selected for yield insertion retain their existing control-flow instrumentation, and a compiler flag disables yield insertion for ablation.

This keeps the interface narrow. Software identifies where a waiting path should offer a scheduling opportunity, while hardware retains and selects the subgroups. The compiler does not name, allocate, or reclaim scheduling state.

Correctness Requirements and Progress Scope

Subgroup switching must preserve execution before it can improve progress. Three requirements govern the state transitions. First, every unfinished lane must retain a valid resume PC, in the executing subgroup, the pending register, the parked pool, or the ordinary divergence state. Second, scheduling ownership must remain consistent. Restoring a mask must not duplicate a lane already assigned to another schedulable subgroup or reactivate a completed lane. Third, retaining the IPDOM stack requires respecting its reconvergence obligations across subgroup switches. The simple predicate-based loop in Figure 6 illustrates capture and selection. It does not by itself establish correctness for all possible nested vx_split/vx_join interleavings.

The progress rationale is that a waiting subgroup offers an execution opportunity to a subgroup that can satisfy its dependency. This guarantee holds only when all five of the following conditions are met.

  1. Yield coverage. Every potentially blocking loop on the path carries a vx_yield.

  2. Sufficient capacity. The subgroups waiting at any time never exceed the pool capacity KK.

  3. Fair selection. The scheduler eventually selects every pending or parked subgroup.

  4. Resident dependent work. The subgroup that can satisfy a wait is already resident on the device.

  5. Acyclic application dependencies. The program’s own synchronization has no circular lock order.

An execution opportunity does not guarantee that a particular lane wins every contended acquisition.

The resident pool makes capacity part of these conditions. When demand exceeds KK, the bounded implementation cannot claim the same progress behavior without an additional capacity-handling mechanism, so we measure capacity sensitivity explicitly. Likewise, the atomic-loop classifier bounds the compiler coverage. Arbitrary nested divergence with independently interleaved stack state is outside the scope of the evaluated implementation.

Microarchitecture Implementation

Pipeline integration. Figure 1 locates the additions in the GPU pipeline. The implementation extends warp control and subgroup scheduling while retaining the existing IPDOM-stack structure. The new yield instruction uses the Vortex custom warp-control encoding (funct7=5, funct3=0). The predicate masks are reused to generate the park and restore events, and the decoded instruction generates the yield event. These signals pass through the existing registered warp-control interface, which avoids a separate subgroup writeback or commit path.

Pool storage. The parked pool is the bulk of the additional state and maps to dual-port BRAM on an FPGA. With NwN_w warps, WW lanes per warp, PC width PP, and KK parked slots per warp, its payload storage is

Spool=NwK(W+P) bits,S_{\mathrm{pool}} = N_w K(W + P)\ \text{bits},

excluding pending registers, pointers, counters, and bookkeeping masks. This accounting separates the configurable number of parked slots from the width-dependent size of each mask. The pool is addressed by {wid,slot}\{wid, slot\}. At most one subgroup-control event retires per cycle, which allows a shared one-write/one-read organization.

Pipelined activation. A combinational push/pop/select sequence can place pool-memory access on the next-PC path. The implementation therefore pipelines pool activation. A read request selects a parked entry, and its mask/PC pair is installed one cycle later. A pending subgroup can instead be installed directly, which avoids the pool-read latency. This difference between direct pending selection and pipelined pool selection follows from the two subgroup classes shown in Figure 6. Figure 7 compares the two paths.

Figure 7. Pending and parked activation after vx_yield.

During a pipelined activation, the warp remains active but stalled. The CTA dispatcher must not interpret this interval as a free warp slot. Only true completion, with no pending or parked work and no activation in flight, permits retirement and reuse. Preserving ownership across this interval prevents a newly dispatched task from overwriting a subgroup that has been selected but not yet installed.

Evaluation

Experimental setup. We evaluate our implemented SIMTurn design using Vortex RTL simulation [38], based on Verilator [36]. The RV32IMAFDC GPU has one core, eight resident warps, and W∈{4,8,16,32}W \in\{4, 8, 16, 32\} threads per warp. SIMD width scales with WW, while issue width remains one. Each configuration has 16 KiB, four-way instruction and data caches, with no L2 cache enabled. OpenCL kernels are compiled at -O3 using LLVM-Vortex 20.1.8 and launched through PoCL [21, 23].

We compare three configurations. For the IPDOM baseline, we convert the naturally blocking code to a software-serialized version (IPDOM_SW). On SIMTurn, we run the same natural code with compiler-inserted yields. On ITS, we run it unmodified, because per-thread scheduling needs no yield to make progress. IPDOM_SW executes complete synchronization operations in local-work-item order, so only one lane reaches a blocking acquisition at a time. The lock protocol and inputs are otherwise identical.

Measurements and correctness. We report simulated device cycles, dynamic warp instructions, and average SIMD utilization. Device measurements include kernel dispatch and device-side runtime instructions, but exclude host compilation and transfers. Time and instruction counts are normalized to IPDOM_SW for synchronization and control workloads. Host checks validate final data and released locks, while order-dependent distance updates are checked by CPU replay of the recorded serialization.

Evaluated benchmarks. We evaluate 9 synchronization and 4 control workloads, summarized in Table 2. Our OpenCL synchronization kernels follow the patterns evaluated by AWARE [11], with explicitly parameterized contention [26]. The controls are Vortex’s existing atomic-reduction and histogram microbenchmarks, a rank/counting sort, and the Rodinia pathfinder kernel [4, 16]. They exercise atomics, loops, and divergence without requiring cross-subgroup progress, so they isolate any overhead that SIMTurn adds when forward progress was never at stake.

Synchronization Microbenchmarks

Figure 8 reports geometric means over each kernel’s parameter sweep, averaged across all four warp widths. SIMTurn tracks ITS closely on most synchronization benchmarks. The bounded pool recovers essentially the same outcome as full per-thread scheduling, without paying for it.

(a) Normalized device cycles.

Normalized dynamic warp instructions

(b) Normalized dynamic warp instructions.

Average SIMD utilization

(c) Average SIMD utilization.

Figure 8. Synchronization microbenchmark performance.

The kernels fall into two groups. Where genuine independent parallelism exists across locks or lanes (TL-FG, AM-FG, HT, LCList, and BH-ST), SIMTurn and ITS both beat IPDOM_SW. The largest gain is on BH-ST, where SIMTurn is 2.7× faster and SIMD utilization rises from 0.46 to 0.79. On CP-DS, SIMTurn executes fewer warp instructions but only matches IPDOM_SW’s cycles. The second group, TL-CG, AM-CG, and ATM, has a single point of contention that every lane must pass through. Here SIMTurn and ITS are both slower than the plain retry loop (SIMTurn 2.2× on TL-CG). With no independent subgroup to schedule to, yields and switches are pure overhead on top of a serialization that IPDOM_SW already achieves for free.

Figure 8b and Figure 8c show the same split. In the first group, SIMTurn and ITS execute far fewer warp instructions than IPDOM_SW, down to 0.11× and 0.09× on BH-ST. In the second group, SIMTurn executes more, up to 3.3× on TL-CG, while ITS executes no more than IPDOM_SW (0.69–0.99×). SIMTurn’s SIMD utilization rises sharply on LCList (from 0.16 to 0.26) and BH-ST, stays level on the other kernels of the first group, and falls in the second group, from 0.26 to 0.19 on TL-CG. ITS reaches the highest utilization on seven of the nine kernels, including 0.52 on TL-CG.

Control Workloads

Figure 9 confirms that the IPDOM fast path is mostly untouched on all four kernels. Averaged across all four warp widths, SIMTurn stays within 8% of IPDOM_SW. These kernels never need cross-subgroup progress, so the split/pred machinery never fires as anything more than ordinary divergence. ITS deviates further in both directions. It runs Rank Sort in 0.72× the cycles of IPDOM_SW, with 0.77× the warp instructions, and Pathfinder in 1.15×.

Control workloads performance

Figure 9. Control workloads performance normalized to IPDOM_SW device cycles.

Case Studies

We now look inside the scheduler itself, at fixed W=32W=32, to ask two questions that are central to SIMTurn’s design. How many schedulable subgroups does a divergent kernel actually need at once? How does lock contention change what the scheduler is doing? We instrument the RTL to additionally emit, per warp-cycle, the number of live subgroups (the running subgroup plus its warp’s pending entry and pool occupancy) and the number of runnable subgroups not currently executing (pending + pool). This instrumentation is not otherwise part of the evaluated design.

Case A: How many subgroups does SIMTurn actually use? We measure the three synchronization kernels with the widest range of lock-dependency structure. These are HT (8 buckets, 256 work-items), ATM (8 accounts, 256 work-items, 4 rounds), and LCList (32 keys, 128 work-items, 50% updates). We run them at SIMTurn’s default capacity (K=W=32K=W=32) and across K∈{1,2,4,8,16}K \in\{1, 2, 4, 8, 16\}.

Live-subgroup distribution

(a) Live-subgroup distribution.

Pool-capacity sensitivity

(b) Pool-capacity sensitivity.

Figure 10. Subgroup demand and parked-pool capacity.

::::

Figure Figure 10a shows the fraction of warp-cycles at each live-subgroup count at K=32K=32. Demand is highly workload-dependent. With adjacent lanes sharing buckets, HT has one subgroup in 93.6% of warp-cycles (mean 1.06, peak 2), while ATM and LCList spend 42.8% and 6.5%, respectively, at five or more. LCList’s hand-over-hand chain holds two locks per hop, pushing the mean to 3.09 (peak 6). ATM’s lock-ordered two-account transfers create the deepest simultaneous dependency chains of the three (mean 3.75, peak 10), which is still less than a third of WW. This supports SIMTurn’s central idea that subgroups need to be tracked only on the workload’s divergent paths, not across the full warp width.

Figure Figure 10b plots execution cycles against pool capacity KK, normalized per workload to K=16K=16. A × marks a 180 s wall-clock timeout, and dashed lines mark the measured peaks from Figure 10a. Capacity K≪WK \ll W is enough for HT and LCList. HT is insensitive down to K=1K=1, and LCList is within 1% of unconstrained by K=4K=4. ATM is different. It never makes forward progress for K≤8K \le8, while K=16K=16 is cycle-identical to the unconstrained run. This is exactly where the independently measured peak of 10 in Figure 10a predicts the cutoff. A pool below a workload’s true peak concurrency does not just slow SIMTurn down. It can stall it. Pool size is therefore a real, workload-dependent parameter, though even ATM’s requirement stays a small fraction of WW.

Case B: Contention scaling. We sweep HT’s bucket count from 1 (all 256 work-items on one lock) to 64 and hold every other parameter fixed.

Figure 11a shows that, for HT, contention barely moves the average number of live subgroups that SIMTurn carries (1.04–1.11 across the whole sweep). Bucket sharing among adjacent lanes bounds simultaneous waiters to a small number, roughly independent of contention even at its maximum. The peak stays at 2 across the sweep, apart from a single peak of 3 at 4 buckets. What contention drives instead is how often the scheduler acts. Figure 11b shows the vx_yield count falling monotonically from 4878 at 1 bucket to 49 at 64, and subgroup switches falling from 992 to 32. These are 100× and 31× reductions. The floor of 32 switches comes from workgroup dispatch and exit, not from contention. SIMTurn’s cost is therefore dominated by scheduling frequency under contention, not by carrying more concurrent state.

Figure 11c shows this cost scaling smoothly and monotonically, from 573K cycles at 1 bucket down to 75K at 64. The curve flattens beyond 16 buckets, where subgroup switches have already reached their floor. This is a 7.6× range from contention alone, on the unmodified natural kernel, with every point correct.

Both case studies point to the same conclusion. Forward progress in this class of kernel needs a handful of concurrently schedulable subgroups, almost always far fewer than WW. Provisioning SIMTurn’s pool to that number, which is measurable and depends on the workload, is sufficient to recover full performance. The state that SIMTurn adds scales with how much a kernel actually diverges, not with per-thread state as in ITS.

HT bucket-count sweep

Figure 11. HT bucket-count sweep (lower bucket count = more contention), fixed W=32W=32.

Average and peak live subgroups

Figure 11a. Average and peak live subgroups.

vx_yield and subgroup-switch counts

Figure 11b. vx_yield and subgroup-switch counts.

Figure 11c. SIMTurn device cycles.

Figure 12a. Performance vs. area.

Figure 12b. Static power.

Hardware Cost

We synthesize the warp scheduler for IPDOM, SIMTurn, and a full per-thread ITS baseline through Yosys with Open-STA for timing and power, mapped to the open ASAP7 (7 nm, LVT) PDK at an 800 MHz target clock. We sweep W∈{4,8,16,32}W \in\{4, 8, 16, 32\} at Nw=8N_w=8 and report post-synthesis maximum frequency, total area (cell + SRAM), and static power for each configuration. ITS keeps a full PC and mask per lane, while IPDOM and SIMTurn use the reconvergence stack and the bounded pool, respectively.

Figure 12 shows that IPDOM is the cheapest configuration at every WW. SIMTurn adds a modest, roughly flat premium of 1.17–1.24× IPDOM’s area and 1.05–1.25× its power. It meets the 800 MHz target at every width, with a maximum frequency within 7% of IPDOM’s. ITS costs far more and grows the fastest, reaching 1.91× IPDOM’s area at W=32W=32. Its power climbs 4.7× from W=4W=4 to W=32W=32, against 2.2× for SIMTurn and 2.6× for IPDOM. Its maximum frequency falls from 1054 MHz to 775 MHz and misses the target at W=32W=32.

Figure 12. SIMTurn ASIC synthesis comparison against IPDOM baseline and ITS.

That extra cost buys nothing past small WW. Figure 12(a) plots the geometric-mean synchronization speedup against area. At W=4W=4 and W=8W=8, ITS is 1.28× and 1.23× faster than IPDOM_SW, and SIMTurn follows within 6% at 1.22× and 1.16×. By W=16W=16, both fall behind IPDOM_SW, dragged down by the single-point-of-contention kernels. Overall, SIMTurn stays close to IPDOM in area, power, and timing while delivering ITS-level forward progress, without paying ITS’s escalating per-thread cost.

Limitations and Extensions

The evaluated design leaves three extensions open. First, a workload whose live subgroup count exceeds the pool capacity KK stalls, as ATOM does for K≤8K \le8. Spilling the oldest parked subgroup to memory, or a scheduling watchdog that falls back to a safe mode, would remove this limit. Second, a wait that avoids the forms recognized by MB, such as polling a plain load or calling through a function pointer, gets no vx_yield. Broader compiler analysis or run-time spin detection in the style of DDOS [12] could cover these cases. Third, the scheduler uses one fixed policy, pending work first and then the oldest parked subgroup, and other selection policies are possible.

Conclusion

We revisit a long-standing tension in SIMT execution where stack-based reconvergence keeps divergence management cheap but its strict, depth-first scheduling order can deadlock programs that rely on intra-warp synchronization. Independent Thread Scheduling resolves this by giving every thread its own program counter, but at a hardware cost that scales with warp width rather than with how much a program actually diverges. We show that a middle ground is possible. SIMTurn restores forward progress at the subgroup granularity where divergence actually occurs, pairing a single new compiler-inserted instruction, vx_yield, with a small, bounded, BRAM-backed pool of parked subgroups in the warp scheduler, and leaving Vortex’s existing IPDOM-based reconvergence stack untouched. Across a range of synchronization microbenchmarks, SIMTurn reaches ITS-level forward progress on the evaluated kernels, under the conditions we state, while adding only a modest, near-flat hardware premium at every evaluated warp width, in contrast to ITS’s cost, which grows steeply with warp width.

References

References

  1. [1]Jayvant Anantpur and Govindarajan R. 2014. Taming Control Divergence in GPUs through Control Flow Linearization. In Compiler Construction, Albert Cohen (Ed.). Springer Berlin Heidelberg, Berlin, Heidelberg, 133–153. doi:10.1007/978-3-642-54807-9_8
  2. [2]Josh Barnes and Piet Hut. 1986. A Hierarchical O(N log N) Force-Calculation Algorithm. Nature 324 (1986), 446–449. doi:10.1038/324446a0
  3. [3]Andrew Brownsword. 2009. Cloth in OpenCL. Game Developers Conference, Khronos Group. https://www.khronos.org/assets/uploads/developers/library/2009-gdc/OpenCL%20EA%20Cloth%20Demo%20GDC%20%20Mar09.pdf
  4. [4]Shuai Che, Michael Boyer, Jiayuan Meng, David Tarjan, Jeremy W. Sheaffer, Sang-Ha Lee, and Kevin Skadron. 2009. Rodiinia: A benchmark suite for heterogeneous computing. In 2009 IEEE International Symposium on Workload Characterization (IISWC). 44–54. doi:10.1109/ISWC.2009.5306797DOI
  5. [5]Jared Coplin and Martin Burtscher. 2015. Effects of Source-Code Optimizations on GPU Performance and Energy Consumption. In Proceedings of the 8th Workshop on General Purpose Processing Using GPUs. Association for Computing Machinery, New York, NY, USA, 48–58. doi:10.1145/2716282.2716292DOI
  6. [6]Bruno Coutinho, Diogo Sampaio, Fernando Magno Quintao Pereira, and Wagner Meira Jr. 2011. Divergence Analysis and Optimizations. In 2011 International Conference on Parallel Architectures and Compilation Techniques. 320–329. doi:10.1109/PACT.2011.63
  7. [7]Sana Damani, Mark Stephenson, Ram Rangan, Daniel Johnson, Rishkul Kulkarni, and Stephen W. Keckler. 2022. GPU Subwarp Interleaving. In 2022 IEEE International Symposium on High-Performance Computer Architecture (HPCA). 1184–1197.DOI
  8. [8]Gregory Diamos, Benjamin Ashbaugh, Subramaniam Maiyuran, Andrew Kerr, Haicheng Wu, and Sudhakar Yalamanchili. 2011. SIMD Re-convergence at Thread Frontiers. In 2011 44th Annual IEEE/ACM International Symposium on Microarchitecture (MICRO). Association for Computing Machinery, New York, NY, USA, 477–488.DOI
  9. [9]Gregory Frederick Diamos, Richard Craig Johnson, Vinod Grover, Olivier Giroux, Jack H. Choquette, Michael Alan Fetterman, Ajay S. Tirumala, Peter Nelson, and Ronny Meir Krashinsky. 2016. Execution of Divergent Threads Using a Convergence Barrier. U.S. Patent Application US20160019066A1.
  10. [10]Fares Elbasha, Blaise Tine, Priyadarshini Roshan, Ethan Lyons, Euna Kim, Da Eun Shim, Lingjun Zhu, Sung Kyu Lim, and Hye-soon Kim. 2020. Vortex: OpenCL Compatible RISC-V GPGPU. arXiv:2002.12151 [cs.DC] https://arxiv.org/abs/2002.12151
  11. [11]Ahmed ElTantawy and Tor M. Aamodt. 2016. MIMD Synchronization on SIMD Architectures. In Proceedings of the 49th Annual IEEE/ACM International Symposium on Microarchitecture (MICRO). 1–14. doi:10.1109/MICRO.2016.7783714DOI
  12. [12]Ahmed ElTantawy and Tor M. Aamodt. 2018. Warp Scheduling for Fine-Grained Synchronization. In 2018 IEEE International Symposium on High Performance Computer Architecture (HPCA). 375–388. doi:10.1109/HPCA.2018.00040DOI
  13. [13]Ahmed ElTantawy, Jessica Wenjie Ma, Mike O’Connor, and Tor M. Aamodt. 2014. A scalable multi-path microarchitecture for efficient GPU control flow. In 2014 IEEE 20th International Symposium on High Performance Computer Architecture (HPCA). 248–259. doi:10.1109/HPCA.2014.6835936DOI
  14. [14]Wilson W. L. Fang and Tor M. Aamodt. 2011. Thread block compaction for efficient SIMT control flow. In 2011 IEEE 17th Annual International Symposium on High Performance Computer Architecture (HPCA). 25–36.
  15. [15]Wilson W. L. Fung, Ivan Sham, George Yuan, and Tor M. Aamodt. 2007. Dynamic Warp Formation and Scheduling for Efficient GPU Control Flow. In Proceedings of the 40th Annual IEEE/ACM International Symposium on Microarchitecture (MICRO). 407–420. doi:10.1109/MICRO.
  16. [16]Vortex GPGPU. Vortex GPGPU. Retrieved November 12, 2026 from https://github.com/vortexgpgpu/vortex
  17. [17]Vincent Gramoli. 2015. More Than You Ever Wanted to Know about Synchronization: Synchronization, Measuring the Impact of the Synchronization on Concurrent Algorithms. In Proceedings of the 20th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming. Association for Computing Machinery, New York, NY, USA, 1–10. https://gramoli.github.io/pubs/gramoli-synchrobench.pdf
  18. [18]Vincent Gramoli and contributors. 2026. Synchrobench. https://github.com/gramoli/synchrobench. Accessed September 7, 2026.
  19. [19]Axel Habermaier and Alexander Knapp. 2012. On the Correctness of the SIMT Execution Model of GPUs. In Programming Languages and Systems: 21st European Symposium on Programming (ESOP). Springer Berlin Heidelberg, Berlin, Heidelberg, 316–335. doi:10.1007/978-3-642-28869-2_16DOI
  20. [20]Maurice Herlihy, Nir Shavit, Victor Luchangco, and Michael Spear. 2020. The Art of Multiprocessor Programming (2 ed.). Morgan Kaufmann. doi:10.1016/C2011-0-06993-4DOI
  21. [21]Pekka Jääskeläinen, Carlos Sánchez Lama, Erik Schnetter, Kalle Raiskila, Jarmo Takala, and Heikki Berg. 2015. pocl: A Performance-Portable OpenCL Implementation. Int. J. Parallel Program. 43, 5 (Oct. 2015), 752–785. doi:10.1007/s10766-014-0320-yDOI
  22. [22]Shinnung Jeong, Jisheng Zhao, Chihyo Ahn, Huanzhi Pu, Hyesoon Kim, and Blaise Tine. 2025. Inside VOLT: Designing an Open-Source GPU Compiler. arXiv:2511.13751 https://arxiv.org/abs/2511.13751
  23. [23]C. Lattner and V. Adve. 2004. LLVM: a compilation framework for lifelong Program analysis & transformation. In International Symposium on Code Generation and Optimization, 2004. CGO 2004. 75–86. doi:10.1109/CGO.2004.1281665DOI
  24. [24]Yunsup Lee, Vinod Grover, Ronny Krashinsky, Mark Stephenson, Stephen W. Keckler, and Krste Asanovic. 2014. Exploring the Design Space of SPMD Divergence Management on Data-Parallel Architectures. In 2014 47th Annual IEEE/ACM International Symposium on Microarchitecture. 101–113. doi:10.1109/MICRO.2014.48DOI
  25. [25]Jiwei Liu, Jun Yang, and Rami G. Melhem. 2015. SAWS: Synchronization Aware GPGPU Warp Scheduling for Multiple Independent Warp Schedulers. In Proceedings of the 48th International Symposium on Microarchitecture (MICRO). Association for Computing Machinery, New York, NY, USA, 383–394. doi:10.1145/2830772.2830822DOI
  26. [26]Peter Maucher, Nick Djerfi, Lennard Kittner, Lukas Werling, and Frank Bellosa. 2025. Are Your GPU Atomics Secretly Contending?. In Proceedings of the 13th Workshop on Programming Languages and Operating Systems (PLOS ’25). Association for Computing Machinery, New York, NY, USA, 84–92. doi:10.1145/3764860.3768338DOI
  27. [27]Jiayuan Meng, David Tarjan, and Kevin Skadron. 2010. Dynamic Warp Subdivision for Integrated Branch and Memory Divergence Tolerance. In Proceedings of the 37th Annual International Symposium on Computer Architecture (ISCA). Association for Computing Machinery, New York, NY, USA, 235–246.
  28. [28]NVIDIA Corporation. 2017. NVIDIA Tesla V100 GPU Architecture: The World’s Most Advanced Data Center GPU. Technical Report. NVIDIA Corporation.
  29. [29]NVIDIA Corporation. CUDA Programming Guide: Independent Thread Scheduling. Retrieved November 12, 2026 from https://docs.nvidia.com/cuda/cuda-programming-guide/
  30. [30]Nico Reissmann, Thomas L. Falch, Benjamin A. Bjørnseth, Helge Bahmann, Jan Christian Meyer, and Magnus Jahre. 2016. Efficient control flow restructuring for GPUs. In 2016 International Conference on High Performance Computing & Simulation (HPCS). 48–57. doi:10.1109/HPCSim.2016.7568315DOI
  31. [31]Minsoo Rhu and Mattan Erez. 2012. CAPRI: Prediction of compaction-adequacy for handling control-divergence in GPGPU architectures. In 2012 39th Annual International Symposium on Computer Architecture (ISCA). 61–71. doi:10.1109/ISCA.2012.6237006 Minsoo Rhu and Mattan Erez. 2013. The dual-path execution model for efficient GPU control flow. In 2013 IEEE 19th International Symposium on High Performance Computer Architecture (HPCA). 591–602. doi:10.1109/HPCA.2013.6522352DOI
  32. [33]John Sartori and Rakesh Kumar. 2012. Branch and data herding: Reducing control and memory divergence for error-tolerant GPU applications. In 2012 21st International Conference on Parallel Architectures and Compilation Techniques (PACT). Association for Computing Machinery, New York, NY, USA, 427–428.
  33. [34]Charitha Saumya, Kirshanthan Sundararajah, and Milind Kulkarni. 2022. DARM: Control-Flow Melding for SIMT Thread Divergence Reduction. In 2022 IEEE/ACM International Symposium on Code Generation and Optimization (CGO). 1–13. doi:10.1109/CGO53902.2022.9741285DOI
  34. [35]Mojtaba Abaie Shoushtary, Jordi Tubella Murgadas, and Antonio Gonzalez. 2024. Control Flow Management in Modern GPUs. arXiv:2407.02944 [cs.AR]. https://arxiv.org/abs/2407.02944
  35. [36]Wilson Snyder. Verilator. Retrieved November 12, 2026 from https://www.veripool.org/ftp/verilator_doc.pdf
  36. [37]Tyler Sorensen, Lucas F. Salvador, Harman Raval, Hugues Evrard, John Wickerson, Margaret Martonosi, and Alastair F. Donaldson. 2021. Specifying and Testing GPU Workgroup Progress Models. Proceedings of the ACM on Programming Languages 5, OOPSLA, Article 131 (2021), 30 pages. doi:10.1145/3485508DOI
  37. [38]Blaise Tine, Krishna Praveen Yalamarthy, Fares Elsabbagh, and Hyesoon Kim. 2021. Vortex: Extending the RISC-V ISA for GPGPU and 3D-Graphics. In MICRO-54: 54th Annual IEEE/ACM International Symposium on Microarchitecture (Virtual Event, Greece) (MICRO ’21). Association for Computing Machinery, New York, NY, USA, 754–766. doi:10.1145/3466752.3480128DOI
  38. [39]Bin Wang, Weikuan Yu, Xian-He Sun, and Xinning Wang. 2015. Da-Cache: Memory Divergence-Aware GPU Cache Management. In Proceedings of the 29th ACM on International Conference on Supercomputing (Newport Beach, California, USA) (ICS ’15). Association for Computing Machinery, New York, NY, USA, 89–98. doi:10.1145/2751205.2751239DOI
  39. [40]Kai Wang, Don Fussell, and Calvin Lin. 2019. Fast Fine-Grained Global Synchronization on GPUs. In Proceedings of the 2019 International Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS). Association for Computing Machinery, New York, NY, USA, 793–806. doi:10.1145/3297858.3304055
  40. [41]Haicheng Wu, Gregory Diamos, Jin Wang, Si Li, and Sudhakar Yalamanchi. 2012. Characterization and transformation of unstructured control flow in bulk synchronous GPU applications. Int. J. High Perform. Comput. Appl. 26, 2 (May 2012), 170–185. doi:10.1177/1094342011434814DOI

Paper details

vlnc:W_27wsbech
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 0

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Not recorded for this paper

View statement
Looking for related papers…
Contents