What Is SASS in GPU Execution and How Does It Relate to PTX?
SASS (Shader Assembly) is the low-level machine instruction set that NVIDIA GPUs actually execute. PTX (Parallel Thread Execution) is the higher-level, virtual instruction set that compilers target first; a backend assembler then lowers PTX into SASS for a specific GPU architecture. If you are profiling kernel performance, reading SASS tells you what the hardware really does, while PTX tells you what the compiler intended before architecture-specific scheduling and register allocation.
SASS vs. PTX at a glance
| Dimension | PTX | SASS |
|---|---|---|
| Abstraction level | Virtual ISA, largely architecture-independent | Native ISA, architecture-specific |
| Who consumes it | Compiler backend, JIT layers | GPU execution units |
| Portability | Forward-compatible across GPU generations | Tied to a target architecture |
| Typical use | Intermediate representation, inspection | Performance analysis, instruction-level tuning |
PTX is designed so the same code can run on future GPUs, with the driver or a JIT step translating it. SASS is what the silicon decodes and issues, so its instruction mix, scheduling, and register usage reflect the concrete target.
How PTX becomes SASS
The path is a lowering pipeline, not a single translation:
- Source to PTX — CUDA C++ or another front end is compiled to PTX, a virtual assembly with explicit thread, block, and memory semantics.
- PTX to SASS — a backend assembler performs instruction selection, register allocation, scheduling, and architecture-specific lowering, emitting SASS for the chosen GPU.
- Execution — the GPU fetches and issues SASS instructions; this is the level where latency hiding, occupancy, and instruction throughput are determined.
Because step 2 is architecture-aware, the same PTX can produce different SASS on different GPUs. That is why two machines running identical source can show different performance.
Why SASS matters for performance analysis
PTX shows intent; SASS shows reality. When a kernel underperforms, the useful questions are usually answered at the SASS level:
- Instruction mix — how many arithmetic, memory, and control instructions are actually issued.
- Register pressure — how register allocation limits occupancy.
- Scheduling and stalls — how instructions are ordered to hide memory latency.
- Compiler lowering effects — where high-level constructs turn into more or fewer machine instructions than expected.
Tools and research efforts such as Gestell focus on compiled GPU execution analysis, studying PTX, SASS, compiler lowering, and GPU execution behavior to understand and advance GPU performance. That framing is a useful reminder: SASS is not just an output artifact, it is the object you analyze when you want to explain measured performance.
Practical takeaway
Use PTX when you want to understand the compiler's intermediate intent and portability story. Use SASS when you need to explain or improve what the hardware actually executes. For performance work, the two are complementary: PTX narrows down where a transformation happened, and SASS confirms what it cost.