Simultaneous multithreading

Also known as: SMT · Hyper-Threading

On this page 7

Simultaneous multithreading (SMT) is a processor technique in which a single physical core keeps several independent hardware threads in flight and issues instructions from more than one of them in the same clock cycle. In hardware design for processors, SMT exists to fill execution slots that a single thread leaves idle while it waits for memory, mispredicted branches or data dependencies.

Intel markets its implementation as Hyper-Threading, while AMD, IBM and several Arm server designs simply call it SMT. To the operating system, each hardware thread appears as a logical processor, so a core with two-way SMT shows up as two CPUs even though most of its resources are shared.

How simultaneous multithreading shares a core

A modern out-of-order superscalar core can dispatch four to eight or more micro-operations per cycle, yet a typical thread uses only part of that width because of cache misses, branch mispredictions and dependency chains. SMT exposes a second instruction stream to the same scheduler, so the core can pick ready operations from either thread and convert wasted slots into useful work.

To make this possible, the core duplicates the architectural state of each thread, including the program counter, register mapping and some control registers, while sharing the expensive structures such as execution units, caches and the branch predictor. Some queues are statically partitioned between threads, others are competitively shared.

The table below shows which core resources are typically replicated, partitioned or shared in a two-way SMT design.

ResourceHandlingEffect
Architectural registers and program counterReplicated per threadEach thread keeps its own state
Reorder buffer and load/store queuesPartitioned or sharedLimits how far each thread runs ahead
Execution unitsFully sharedMain source of throughput gain
L1 and L2 cachesFully sharedThreads can evict each other’s data
Branch predictor and TLBShared, often thread-taggedPossible interference between threads
Resource handling in a typical two-way SMT core

Because only a small amount of logic is duplicated, SMT costs roughly 5 percent or less of core area in commonly cited estimates, which makes it one of the cheapest ways to raise throughput per square millimeter of silicon.

SMT compared with other forms of multithreading

SMT is one of several ways to run multiple threads on shared hardware, and it differs from the others in how finely instructions are interleaved. The following comparison places it alongside related approaches and multiple physical cores.

ApproachHow threads alternateMain trade-off
Coarse-grained multithreadingSwitches on long stalls such as cache missesSimple, but leaves short stalls unfilled
Fine-grained multithreadingSwitches every cycle in round-robin orderHides latency but slows each thread
Simultaneous multithreadingIssues from several threads in one cycleBest slot use, but more resource contention
Multiple physical coresEach thread has dedicated hardwareFull performance per thread at higher cost
Multithreading approaches compared

The key distinction for buyers is between a CPU core and a CPU thread. A logical thread created by SMT is not equivalent to an extra core: it shares the core’s execution width, so two threads on one core almost never run twice as fast as one thread alone.

Performance effects and typical SMT widths

SMT improves aggregate throughput, not single-thread speed. Throughput gains commonly fall in the range of about 10 to 30 percent for mixed server and multitasking workloads, while workloads that already saturate the core can see no gain or even a small loss due to cache and queue contention.

Workload typeTypical SMT effectReason
Web servers and databasesClear throughput gainFrequent memory stalls leave idle slots
Software compilationModerate gainMixed integer work with branch misses
Dense floating-point HPC codeLittle gain or slight lossVector units already saturated
Latency-sensitive gamesNeutral to slightly negativeShared caches can raise frame-time variance
How workload type influences SMT benefit

Most desktop and server x86-64 processors use two-way SMT. IBM POWER processors have offered four-way and eight-way SMT modes, targeting highly parallel commercial workloads. In hybrid CPU architecture designs, manufacturers often enable SMT only on the performance cores, and some recent client designs have dropped it from performance cores entirely to save power and area.

Configuring and scheduling SMT systems

SMT is usually controlled in the firmware setup, and Linux additionally allows it to be switched at runtime through the kernel’s SMT control interface. A topology-aware scheduler in the operating system tries to place busy threads on separate physical cores before doubling up on sibling threads, which preserves per-thread performance when the system is lightly loaded.

Administrators make SMT decisions based on workload, security posture and software licensing, as the following decision table summarizes.

SituationRecommended settingReason
General desktop multitaskingKeep SMT enabledBetter responsiveness under mixed load
Multitenant cloud hosts with untrusted guestsDisable SMT or use core schedulingReduces cross-thread side-channel risk
Software licensed per logical processorEvaluate cost before enablingThread count may raise license fees
Tightly tuned HPC jobsBenchmark both settingsBenefit depends on code characteristics
When to enable or disable SMT

Linux core scheduling offers a middle path: it allows only tasks that trust each other to share sibling threads, keeping most of the throughput benefit while reducing exposure to attacks that cross thread boundaries.

Security risks and common misconceptions

Because sibling threads share caches, buffers and execution ports, SMT creates microarchitectural side channels. Vulnerability classes such as L1 Terminal Fault and Microarchitectural Data Sampling showed that data could leak between sibling threads, and some operating system vendors recommended disabling SMT on sensitive systems until mitigations matured.

  • Misconception: logical threads equal cores. A 16-thread processor with 8 cores has the execution resources of 8 cores.
  • Misconception: SMT always helps. Contention can reduce performance for cache-heavy or vector-bound code.
  • Misconception: disabling SMT halves performance. The real loss is usually limited to the throughput gain SMT was providing.
  • Warning: monitoring can mislead. A logical processor shown at 100 percent busy does not mean the physical core is saturated.

Understanding these limits helps engineers treat SMT as a throughput optimization with costs, not as free extra cores, and decide case by case whether it serves a given system.

The short version

Simultaneous multithreading lets one processor core work on two tasks at once by filling the moments when one task is waiting. The core does not get bigger or faster; it simply wastes less of its time.

Picture a cook preparing two dishes on one stove. While one sauce simmers, the cook chops vegetables for the second dish. The kitchen produces more food per hour, but each dish is not cooked any faster. The key takeaway: SMT adds throughput, not extra cores.

Where it makes a difference

A company runs its customer database on a server with two 32-core processors, giving 64 physical cores and 128 logical processors with SMT enabled. Database queries frequently wait on memory and storage, which leaves many execution slots idle on each core.

The operations team benchmarks the server with SMT on and off using a replay of a normal business day. With SMT enabled, the server handles about 20 percent more transactions per second at the same response-time target, so the planned purchase of an additional server is postponed.

The same company also operates a multitenant virtualization cluster for external customers. There, the security team enables core scheduling so that virtual machines from different customers never share sibling threads, accepting a small throughput loss in exchange for stronger isolation between tenants.