Hardware / NVIDIA Ampere · GA102
GeForce RTX 3090
The 24 GiB Ampere card, where GPT-2 on AlphaOS trained to 30,000 updates.
SM86 · compute capability 8.6
What has run here
Qualified
GPT-2 on AlphaOS trained here to 30,000 updates (October 2026), the model the knots research runs on, and AlphaOS's resumable nodes were qualified here. The card's earlier qualification and performance runs belong to systems archived on 2026-11-08.
Driver facts
Typed profile
Read at build time from Platform.RunPod.Nvidia.SM86 at 5f12a3db. Systems bind to these values by name; none branches on a card name.
| Fact | Value | Alpha definition |
|---|---|---|
| Product identity | NVIDIA GeForce RTX 3090 | runPodRTX3090ProductIdentity |
| Target identity | runpod-nvidia-geforce-rtx3090-sm86 | runPodRTX3090TargetIdentity |
| Compute capability | 8.6 | runPodRTX3090TargetProfile |
| Total video memory | 25,769,803,776 B (24 GiB) | runPodRTX3090TotalVideoMemory |
Instruction set · 48 typed instructions
Every GPU instruction Alpha can emit for this device
The typed instruction set is SM86InstructionBody in Accelerator.SM86.Instruction; each name links to the line that defines it, each opcode to the line that encodes it. The SASS column is the mnemonic NVIDIA's tools would print for the same encoding. Instructions this device has that Alpha has not yet typed are not listed: Alpha only claims what its compiler can emit and its runtime has executed.
| Alpha name | SASS | Opcode | Meaning | Operands |
|---|---|---|---|---|
SM86MoveConstant | MOV (constant bank) | — | destination = c[bank][offset], a 32-bit word from a constant bank. |
|
SM86SpecialToRegister | S2R | — | destination = a special register (thread or cooperative-thread-array index). |
|
SM86MoveImmediate | MOV (immediate) | — | destination = a 32-bit immediate. |
|
SM86IntegerMultiplyAddConstant | IMAD (constant bank) | — | destination = left * c[bank][offset] + addend, 32-bit integer. |
|
SM86IntegerMultiplyAddImmediate | IMAD (immediate) | — | destination = left * immediate + addend, 32-bit integer. |
|
SM86IntegerMultiplyAddWideConstant | IMAD.WIDE.U32 | — | destination pair = left * right + c[bank][offset], a 64-bit product plus a 64-bit constant. |
|
SM86IntegerAddThreeImmediate | IADD3 (immediate) | — | destination = left + immediate, the three-input adder with one input zero. |
|
SM86IntegerAddThreeRegister | IADD3 (register) | — | destination = left + right, the three-input adder with one input zero. |
|
SM86ShiftRightImmediate | SHF.R.U32.HI | — | destination = source logically shifted right by an immediate amount. |
|
SM86LogicThreeInputTruthTable | LOP3.LUT | — | destination = truthTable(left, right, zero), any bitwise function of the inputs given as an 8-bit lookup table. |
|
SM86IntegerToFloat | I2FP.F32.S32 | — | destination = the signed 32-bit integer source converted to binary32. |
|
SM86FloatAdd | FADD | — | destination = left + right, binary32, round to nearest even. |
|
SM86FloatMultiply | FMUL | — | destination = left * right, binary32, round to nearest even. |
|
SM86Float64Binary | — | — | Binary64 arithmetic has paired operands and separate rounding at every instruction. It is variable-latency: callers must retire both destination words and protect both words of every source with scoreboard dependencies. |
|
SM86FloatConvert | — | — | F2F with nearest-even rounding and subnormals preserved. Its pair shape, late sources and late result are explicit; conversion never implies FTZ. |
|
SM86FloatFusedMultiplyAdd | FFMA | — | destination = left * right + addend, binary32 with a single rounding. |
|
SM86MultiFunctionUnitApproximation | MUFU | — | destination = an approximate transcendental of the source (cosine, sine, exp2, log2, reciprocal, reciprocal square root, square root, tanh) from the multi-function unit. |
|
SM86FloatMinimumOrMaximum | FMNMX | — | destination = the minimum or the maximum of left and right, binary32. |
|
SM86FloatNegate | FADD (negated source, zero addend) | — | destination = -source, binary32. |
|
SM86FloatPairToPackedHalfPair | F2FP.PACK_AB | — | destination = two binary32 sources converted and packed into one register of two binary16 halves. |
|
SM86FloatPairToPackedBFloat16Pair | F2FP.BF16.PACK_AB | — | destination = two binary32 sources rounded to bfloat16 (to nearest, ties to even) and packed into one register. |
|
SM86FloatPairToPackedFloat8Pair | HADD2.F32 | — | destination = the selected binary16 half of the source widened to binary32. SASS F2FP.SATFINITE.{E4M3,E5M2}.F32.PACK_AB_MERGE_C (sm_89 and later): destination = the half of `merge` that `mergeHalf` selects in bits 16..31, the high source rounded to the 8-bit format in bits 8..15 and the low source in bits 0..7 (each to nearest, ties to even, saturating to the format's largest finite magnitude; a NaN stays NaN). |
|
SM86FloatArithmetic | FADD / FMUL / FFMA with their modifiers (SM86FloatModifiers) | — | the words of ptxas 12.9 for sm_90a (Proof.FloatArithmeticContract), libdevice's forms -- __nv_expf's FFMA.FTZ.RM, __nv_tanhf's FFMA.FTZ, FADD.FTZ.SAT. destination = left + right, left * right, or left * right + addend (the addend unread unless FFMA), binary32 with one rounding. |
|
SM86HalfToFloat | — | — | — |
|
SM86BFloat16ToFloat | PRMT Rd, Ra, 0x1044 (H0) or 0x3244 (H1), RZ | — | destination = the selected bfloat16 half of the source widened to binary32 (its bits moved to the high half, the low half zero: exact). |
|
SM86TensorCoreHalfMatrixMultiplyAccumulate16x8x16Float32 | HMMA.16816.F32 | — | destination = fragmentA (16x16, binary16) * fragmentB (16x8, binary16) + accumulator (16x8, binary32) on the tensor cores, one warp-wide 16x8x16 tile. |
|
SM86TensorCoreBFloat16MatrixMultiplyAccumulate16x8x16Float32 | HMMA.16816.F32.BF16 | — | the same tile product with bfloat16 fragments. |
|
SM86TensorCoreHalfMatrixMultiplyAccumulate16x8x16Half | HMMA.16816.F16 | — | the binary16 tile product with a binary16 accumulator and destination (a register pair each, not a quad). GeForce Ampere is documented at twice the binary32-accumulate rate for it; the accumulator's rounding inside the tensor core is not modelled (the machine models fault). Encoding: ptxas 11.8's for sm_86 (experiments/sm86-opcodes, probe gpt2_alphaos_products). |
|
SM86TensorCoreInteger8MatrixMultiplyAccumulate16x8x32Integer32 | IMMA.16832.S8.S8 | — | a 16 x 32 signed 8-bit fragment times a 32 x 8 one plus a 16 x 8 binary32-wide signed integer accumulator (quads, as HMMA.16816.F32's). Not modelled. Encoding: ptxas 11.8's for sm_86. |
|
SM86LoadGlobal | LDG.E | — | destination = the 32-bit word at address + offset in global memory. |
|
SM86LoadGlobalWide | LDG.E.128 | — | destination quad = the 128 bits at address + offset in global memory. |
|
SM86WarpShuffle | SHFL | — | destination = the source register of another lane of the warp, selected by index, up, down or butterfly mode. |
|
SM86LoadShared | LDS | — | destination = the 32-bit word at 4 address + offset in shared memory (encoded LDS [Ra.X4 + offset]: the register is a WORD index, the offset bytes -- nvdisasm prints the .X4; a byte address in the register reads 4x too far, as the Hopper attention key pass did, 2026-10-18). |
|
SM86LoadSharedMatrix | LDSM | — | destination = one, two or four 8x8 binary16 matrices loaded from shared memory into tensor-core fragment layout, optionally transposed. |
|
SM86StoreShared | STS | — | the 32-bit value stored at 4 address + offset in shared memory (STS [Ra.X4 + offset]: the register a word index, the offset bytes). |
|
SM86LoadGlobalToShared | LDGSTS.E.BYPASS.128 (cp.async.cg, 16 bytes) | — | the 128 bits at global source + sourceOffset (a register pair; the offset a signed 12-bit immediate) copied to shared memory at address + offset, asynchronously: the copy joins the thread's open group (SM86CommitAsyncGroup closes it), and nothing may read those shared bytes until SM86WaitAsyncGroups has retired the group (and, for other threads, a BAR.SYNC after). Its registers are read after issue: a read barrier guards them. |
|
SM86CommitAsyncGroup | LDGDEPBAR (cp.async.commit_group) | — | the thread's open group of asynchronous copies closed; the groups in flight count on scoreboard SB0, which the control's write barrier names. |
|
SM86WaitAsyncGroups | DEPBAR.LE SB0, count (cp.async.wait_group count) | — | wait until at most `count` (0..63) groups of asynchronous copies are in flight. |
|
SM86BarrierSynchronize | BAR.SYNC | — | every thread of the cooperative thread array waits until all have arrived. |
|
SM86BarrierSynchronizeCount | BAR.SYNC b, n | — | the first `threads` threads to arrive at named barrier `barrier` (0..15) wait until that many have (a multiple of the warp size, at most 1024; the others of the CTA run on). Warps that synchronise among themselves this way leave the CTA's other warps free -- a warp streaming independent work beside them (Realization.Nvidia.SM86's side warps). |
|
SM86StoreGlobal | STG.E | — | the 32-bit value stored at address + offset in global memory. |
|
SM86StoreGlobalWide | STG.E.128 | — | the 128-bit value quad stored at address + offset in global memory. |
|
SM86StoreGlobal64 | STG.E.64 | — | the 64-bit value pair stored at address + offset in global memory. |
|
SM86ReduceGlobalAddFloat32 | RED.E.ADD.F32 | — | the binary32 value atomically added to the word at address + offset in global memory, no result returned. |
|
SM86PredicateGreaterThanImmediate | ISETP.GT (immediate) | — | destination predicate = source > immediate, compared as unsigned 32-bit words in this encoding: the RTX 3070 has 0x80000000 > 0 (Checked.IntegerCompareProbe, Proof.CheckedIntegerCompareSilicon). |
|
SM86Branch | BRA | — | continue at the instruction offset bytes away, relative to the next instruction. |
|
SM86Exit | EXIT | — | this thread finishes the program. |
|
SM86System | — | — | One of the system forms above, with its control word. |
|
Operand vocabularies
The named values an instruction's operands range over: special registers, execution guards, shuffle modes, half selectors, shared-matrix shapes, multi-function operations, extremum modes, and the scoreboard barriers and yield modes carried by every instruction's SM86Control word (Stall, Yield, WriteBarrier, ReadBarrier, WaitMask, ReuseMask).
SM86SpecialRegister
| Alpha name | SASS | Meaning |
|---|---|---|
SM86CooperativeThreadArrayIdX | SR_CTAID.X | the cooperative thread array (block) index on x. |
SM86CooperativeThreadArrayIdY | SR_CTAID.Y | the cooperative thread array (block) index on y. |
SM86CooperativeThreadArrayIdZ | SR_CTAID.Z | the cooperative thread array (block) index on z. |
SM86ThreadIdX | SR_TID.X | the thread index on x within its cooperative thread array. |
SM86ClockLow | SR_CLOCKLO | the low word of the SM's cycle counter. |
SM86GlobalTimerLow | SR_GLOBALTIMERLO | the low word of the device's global timer, in nanoseconds -- the clock the semaphore releases stamp. |
SM86GlobalTimerHigh | SR_GLOBALTIMERHI | its high word. |
SM86InstructionGuard
| Alpha name | SASS | Meaning |
|---|---|---|
SM86InstructionAlways | — | no guard: the instruction always executes. |
SM86InstructionWhen | @P | the instruction executes only in threads where the predicate is true. |
SM86InstructionWhenNot | @!P | the instruction executes only in threads where the predicate is false. |
SM86ShuffleMode
| Alpha name | SASS | Meaning |
|---|---|---|
SM86ShuffleIndex | SHFL.IDX | read the lane named by the lane operand. |
SM86ShuffleUp | SHFL.UP | read the lane that is lane places below this one. |
SM86ShuffleDown | SHFL.DOWN | read the lane that is lane places above this one. |
SM86ShuffleButterfly | SHFL.BFLY | read the lane whose index is this lane's index xor the lane operand. |
SM86HalfSelector
| Alpha name | SASS | Meaning |
|---|---|---|
SM86LowHalf | — | the low binary16 half (H0) of a 32-bit register. |
SM86HighHalf | — | the high binary16 half (H1) of a 32-bit register. |
SM86HalfFormat
| Alpha name | SASS | Meaning |
|---|---|---|
SM86Binary16 | — | — |
SM86BFloat16 | — | — |
SM86Float8Format
| Alpha name | SASS | Meaning |
|---|---|---|
SM86Float8E4M3 | — | — |
SM86Float8E5M2 | — | — |
SM86FloatOperation
| Alpha name | SASS | Meaning |
|---|---|---|
SM86FloatOperationAdd | — | — |
SM86FloatOperationMultiply | — | — |
SM86FloatOperationFusedMultiplyAdd | — | — |
SM86Rounding
| Alpha name | SASS | Meaning |
|---|---|---|
SM86RoundNearestEven | — | — |
SM86RoundDown | — | — |
SM86RoundUp | — | — |
SM86RoundTowardZero | — | — |
SM86FloatModifiers
| Alpha name | SASS | Meaning |
|---|---|---|
SM86FloatModifiersValue | — | — |
SM86MemoryScope
| Alpha name | SASS | Meaning |
|---|---|---|
SM86ScopeBlock | — | — |
SM86ScopeDevice | — | — |
SM86ScopeSystem | — | — |
SM86AtomicOperation
| Alpha name | SASS | Meaning |
|---|---|---|
SM86AtomicAdd | — | — |
SM86AtomicMinimum | — | — |
SM86AtomicMaximum | — | — |
SM86AtomicIncrement | — | — |
SM86AtomicDecrement | — | — |
SM86AtomicAnd | — | — |
SM86AtomicOr | — | — |
SM86AtomicXor | — | — |
SM86AtomicExchange | — | — |
SM86FenceMode
| Alpha name | SASS | Meaning |
|---|---|---|
SM86FenceSequential | — | — |
SM86FenceAcquireRelease | — | — |
SM86IntegerComparison
| Alpha name | SASS | Meaning |
|---|---|---|
SM86CompareLess | — | — |
SM86CompareEqual | — | — |
SM86CompareLessOrEqual | — | — |
SM86CompareGreater | — | — |
SM86CompareNotEqual | — | — |
SM86CompareGreaterOrEqual | — | — |
SM86IntegerSignedness
| Alpha name | SASS | Meaning |
|---|---|---|
SM86Unsigned | — | — |
SM86Signed | — | — |
SM86PredicateSense
| Alpha name | SASS | Meaning |
|---|---|---|
SM86PredicateAsIs | — | — |
SM86PredicateInverted | — | — |
SM86SystemOperation
| Alpha name | SASS | Meaning |
|---|---|---|
SM86AtomicGlobal | — | ATOMG.E.<op>.STRONG.<scope> PT, Rd, [Ra.64 + offset], Rb: the 32-bit word at the address combined with Rb, atomically; Rd receives the old word. |
SM86AtomicCompareSwapGlobal | — | ATOMG.E.CAS.STRONG.<scope> PT, Rd, [Ra.64 + offset], Rcompare, Rvalue: the word becomes Rvalue when it equals Rcompare; Rd receives the old word. |
SM86ReduceGlobal | — | RED.E.<op>.STRONG.<scope> [Ra.64 + offset], Rb: the same without the old word (no exchange: RED has no EXCH) |
SM86MemoryBarrier | — | MEMBAR.<mode>.<scope>: this thread's earlier accesses ordered before its later ones |
SM86ErrorBarrier | — | ERRBAR: wait until outstanding memory errors are reported |
SM86InvalidateDataCache | — | CCTL.IVALL: every line of this SM's L1 data cache invalidated (what ptxas emits after the fence of an acquire) |
SM86LoadGlobalStrong | — | LDG.E.STRONG.<scope> Rd, [Ra.64 + offset]: a coherent 32-bit load |
SM86StoreGlobalStrong | — | STG.E.STRONG.<scope> [Ra.64 + offset], Rb: a coherent 32-bit store |
SM86Sleep | — | NANOSLEEP immediate: suspend the warp about that many nanoseconds |
SM86CompareRegisters | — | ISETP.<comparison>.<U32|S32>.AND Pd, PT, Ra, Rb, PT |
SM86SelectRegisters | — | SEL Rd, Rt, Rf, P: Rt where the predicate (as sensed) holds, else Rf |
SM86IntegerMinimumOrMaximum | — | IMNMX.<U32|S32> Rd, Ra, Rb: the integer minimum or maximum |
SM86MoveRegister | — | IMAD.MOV.U32 Rd, RZ, RZ, Rs: a register copy on the fixed-latency pipe |
SM86IntegerMultiplyAddRegister | — | IMAD.U32 Rd, Ra, Rb, Rc: the low 32 bits of Ra x Rb + Rc |
SM86ReadSystemRegister | — | S2R Rd, SR_<code>: any special register by its code (lane id 0x00, TID.X 0x21, CTAID.X 0x25, virtual SM id 0x43, ...) |
SM86BranchIndirect | — | BRX Ra, offset: continue at the next instruction's address + Ra:Ra+1 + offset. The register is a PAIR, a 64-bit displacement (ptxas loads the pair before every BRX, CALL.REL and RET.REL it writes: "MOV R10, ..; MOV R11, 0x0; RET.REL.NODEC R10"); ptxas sets offset to minus the next instruction's position, so the pair is a target relative to the start. |
SM86CallIndirect | — | CALL.REL.NOINC Ra, offset: the same transfer through the pair, as a call (no call stack; the caller leaves its return target in registers by convention) |
SM86ReturnIndirect | — | RET.REL.NODEC Ra, offset: the same transfer, as a return |
SM86PopulationCount | — | POPC Rd, Rs: the number of set bits |
SM86VoteBallot | — | VOTE.ANY Rd, PT, P: the warp's ballot of the predicate (as sensed) in Rd |
SM86BarrierArrive | — | BAR.ARV barrier, threads: arrive at a named barrier without waiting |
SM86ConvergenceStart | — | BSSY Bb, target: convergence barrier b (0 .. 15) takes the lanes that execute it, the reconvergence point `displacement` bytes past the next instruction (its BSYNC). Independent thread scheduling never merges lanes that went different ways on its own; a BSYNC on the barrier does. |
SM86ConvergenceWait | — | BSYNC Bb: wait until every lane barrier b took (and has not exited) is here; they leave together, one group |
SM86LabelDistance | — | MOV Rd, to - from: the byte distance from one label to another (Accelerator.SM86.Assembly's SM86AsmLabelOffset, the offset an indirect transfer adds to its base). Its word is MOV immediate's; the two labels' displacements from the next instruction (bytes, two's complement) are kept apart so a lowering that moves instructions (Accelerator.SM121. Lowering) can measure the distance again where it placed them. |
SM86MultiFunction
| Alpha name | SASS | Meaning |
|---|---|---|
SM86Cosine | MUFU.COS | cosine of the source, radians. |
SM86Sine | MUFU.SIN | sine of the source, radians. |
SM86ExponentialBase2 | MUFU.EX2 | two raised to the source. |
SM86LogarithmBase2 | MUFU.LG2 | the base-2 logarithm of the source. |
SM86Reciprocal | MUFU.RCP | one divided by the source. |
SM86ReciprocalSquareRoot | MUFU.RSQ | one divided by the square root of the source. |
SM86SquareRoot | MUFU.SQRT | the square root of the source. |
SM86HyperbolicTangent | MUFU.TANH | the hyperbolic tangent of the source. |
SM86FloatExtremum
| Alpha name | SASS | Meaning |
|---|---|---|
SM86FloatMinimum | FMNMX with PT | the smaller of the two operands. |
SM86FloatMaximum | FMNMX with !PT | the larger of the two operands. |
SM86Barrier
| Alpha name | SASS | Meaning |
|---|---|---|
SM86Barrier0 | — | — |
SM86Barrier1 | — | — |
SM86Barrier2 | — | — |
SM86Barrier3 | — | — |
SM86Barrier4 | — | — |
SM86Barrier5 | — | — |
SM86Barrier6 | — | — |
SM86BarrierNone | — | — |
SM86WaitBarrier
| Alpha name | SASS | Meaning |
|---|---|---|
SM86WaitBarrier0 | — | — |
SM86WaitBarrier1 | — | — |
SM86WaitBarrier2 | — | — |
SM86WaitBarrier3 | — | — |
SM86WaitBarrier4 | — | — |
SM86WaitBarrier5 | — | — |
SM86YieldMode
| Alpha name | SASS | Meaning |
|---|---|---|
SM86Continue | — | — |
SM86Yield | — | — |
Profile coverage
What has been measured, and what has not
A fully profiled device has three tiers. A tier that is not measured yet lists the fields it will fill, so the gap is explicit.
- 1
Driver facts
LiveWhat the resource manager reports and the typed profile binds: product identity, compute capability, video memory, the QMD architecture, compute class and SPA version the command stream is built for.
- product identity
- compute capability
- total video memory
- QMD architecture
- compute class
- SPA version
- UVM / RM / QMD / pushbuffer / GPFIFO admission bits
- 2
Micro-benchmarks
Not measured yetMeasured instruction and memory behaviour, so the compiler can reason about cost from numbers read on this card rather than assumptions.
- issue rate and latency per typed instruction (FFMA, IMAD, MUFU, LDG, STG, LDSM, HMMA…)
- shared-memory bandwidth and bank behaviour
- global-memory bandwidth by access pattern and width
- tensor-core throughput at 16×8×16
- barrier and warp-shuffle cost
- submission, doorbell and semaphore round-trip cost
- sustained clocks under the training workload
- 3
Model-shaped calibration
Not measured yetThe cost of the exact kernels and launch schedules Alpha emits for each system on this device, so realization choices can be made from measurements.
- per-kernel time for every launch in each system's schedule
- occupancy and register / shared-memory pressure per kernel
- end-to-end step time and its split between host protocol, launches and waits
- memory footprint against the profile's video memory
Sources