This chapter covers NVMe (Non-Volatile Memory Express) and M.2 form factors, two critical technologies for modern high-performance storage. For the 220-1101 exam, understanding NVMe and M.2 is essential because they appear in multiple hardware objectives, especially when identifying and selecting storage devices for desktops and laptops. Expect around 5-8% of exam questions to touch on these topics, often asking you to compare speeds, form factors, or compatibility. This chapter will give you the precise technical knowledge to differentiate NVMe from SATA and M.2 from mSATA, including key values like PCIe lane counts and speeds.
Jump to a section
Imagine a city with two types of roads connecting the airport (CPU) to the downtown (storage). The old road is a winding, single-lane street with multiple traffic lights (SATA and AHCI). Every car (data request) must stop at each light, wait for a turn, and follow a strict order. This road was designed for horse-drawn carriages (hard disk drives). Now, a new superhighway (NVMe) is built directly from the airport to downtown, with 64,000 lanes (queues) and no traffic lights. Cars can enter any lane immediately, bypass all stops, and drive straight to their destination. The airport control tower (CPU) can dispatch thousands of cars simultaneously without waiting for each to return. This superhighway was designed for modern sports cars (SSDs) that can handle high speeds. The result: traffic moves 10-20 times faster, and the airport can handle many more flights (operations per second) because cars are never stuck waiting.
What is NVMe?
NVMe (Non-Volatile Memory Express) is a host controller interface and storage protocol designed specifically for SSDs connected via the PCI Express (PCIe) bus. It was developed to overcome the limitations of the older AHCI (Advanced Host Controller Interface) protocol, which was originally designed for spinning hard disk drives (HDDs). AHCI, even when used with SSDs, introduces significant overhead because it was built for mechanical drives with rotational latency and command queuing limitations. NVMe eliminates this legacy overhead by leveraging the parallelism of modern SSDs and the high bandwidth of PCIe.
Why NVMe Exists
Before NVMe, SSDs used the same interface as HDDs (SATA) and the same protocol (AHCI). SATA 3.0 has a maximum throughput of 6 Gb/s (about 550 MB/s after encoding overhead), which became a bottleneck for fast NAND flash. Even with multiple SSDs in RAID, the protocol limitations of AHCI prevented full utilization of the flash memory's speed. NVMe was designed from the ground up for flash storage, supporting much higher queue depths and more efficient command processing. The key innovation is that NVMe uses a highly parallel architecture with multiple queues, each capable of holding many commands, whereas AHCI uses a single queue with a maximum of 32 commands.
How NVMe Works Internally
NVMe communicates directly with the CPU via the PCIe bus, bypassing the traditional SATA controller. The protocol defines a set of command sets and completion queues. The host (CPU) creates submission queues (SQ) and completion queues (CQ) in system memory. Each queue can hold up to 64K entries (commands or completions). The NVMe controller on the SSD processes commands from the submission queues and posts completions to the completion queues. The host can have up to 64K submission queues and 64K completion queues, each with a depth of up to 64K entries. This massive parallelism allows thousands of outstanding I/O requests simultaneously, dramatically reducing latency and increasing IOPS (Input/Output Operations Per Second).
Key Components and Values
PCIe Lanes: NVMe devices typically use x2 or x4 PCIe lanes. PCIe 3.0 x4 provides about 3.94 GB/s (4 lanes x 985 MB/s per lane). PCIe 4.0 x4 doubles that to about 7.88 GB/s. PCIe 5.0 x4 reaches about 15.76 GB/s.
Queue Depth: Each NVMe queue can hold up to 64K commands. With 64K queues, the theoretical maximum outstanding I/Os is over 4 billion (64K x 64K). In practice, typical implementations use 16-128 queues with queue depths of 256-1024.
Command Size: NVMe commands are 64 bytes, compared to AHCI's 8-byte command plus data transfers. The streamlined command format reduces processing overhead.
Latency: NVMe reduces latency to as low as 2-3 microseconds for random reads, compared to 50-100 microseconds for SATA SSDs.
M.2 Form Factor
M.2 is a small form factor for expansion cards, including SSDs, Wi-Fi cards, and Bluetooth modules. It replaced mSATA and Mini PCIe. M.2 SSDs can use either SATA or NVMe protocol, but the physical connector is the same. The M.2 connector has multiple key notches to prevent insertion into incompatible slots. The two most common keys for storage are: - B-key: Supports SATA and PCIe x2 (up to two lanes). Common in older or budget systems. - M-key: Supports PCIe x4 (up to four lanes), used for high-performance NVMe SSDs. M-key slots are backward compatible with B-key devices if the slot supports PCIe x2.
M.2 Module Sizes
M.2 modules are identified by a four-digit code: WWLL (width and length in millimeters). Common sizes: - 2230: 22mm wide, 30mm long (often used for Wi-Fi cards) - 2242: 22mm x 42mm - 2260: 22mm x 60mm - 2280: 22mm x 80mm (most common for SSDs) - 22110: 22mm x 110mm (rare, used for enterprise SSDs)
NVMe vs. SATA M.2
It is critical to understand that an M.2 slot can support either SATA or NVMe, or both. The motherboard manual specifies which protocols are supported. An M.2 SATA SSD uses the same protocol as a 2.5-inch SATA SSD, so its speed is capped at ~550 MB/s. An M.2 NVMe SSD uses PCIe lanes, so its speed depends on the PCIe generation and lane count. A common exam trap: assuming all M.2 SSDs are NVMe. Some M.2 SSDs are SATA, and they are physically identical but slower.
Configuration and Verification
In modern operating systems, NVMe drives are automatically recognized. You can verify an NVMe drive in Windows using Device Manager (look under "Storage Controllers" for "NVMe Controller") or using PowerShell: Get-PhysicalDisk | Select-Object FriendlyName, BusType — BusType should be "NVMe". In Linux, use lspci | grep -i nvme or nvme list (requires nvme-cli package).
Interaction with Related Technologies
NVMe is often paired with Intel Optane Memory or similar caching technologies. For example, a system might use a small NVMe drive as a cache for a larger HDD. The 220-1101 exam may ask about Optane Memory, which requires an M.2 slot (often B-key or M-key) and specific motherboard support. Also, NVMe over Fabrics (NVMe-oF) extends NVMe over networks, but this is beyond the A+ scope.
Common Exam Values to Memorize
SATA 3.0 max throughput: 6 Gb/s (~550 MB/s)
PCIe 3.0 x4 throughput: ~3.94 GB/s
PCIe 4.0 x4 throughput: ~7.88 GB/s
M.2 key B: supports SATA and PCIe x2
M.2 key M: supports PCIe x4
M.2 module lengths: 2230, 2242, 2260, 2280, 22110
NVMe queue depth: up to 64K per queue, up to 64K queues
Trap Patterns
Trap 1: Confusing M.2 SATA with NVMe. Both use the same physical connector, but SATA M.2 is limited to SATA speeds. The exam might show a picture of an M.2 SSD and ask its speed; if it's SATA, the answer is ~550 MB/s, not several GB/s.
Trap 2: Assuming all M.2 slots support NVMe. Many older motherboards only support M.2 SATA. The exam may describe a system with an M.2 slot but the SSD doesn't work; the issue could be protocol incompatibility.
Trap 3: Forgetting that NVMe requires PCIe lanes. On some systems, using an M.2 NVMe SSD may disable some SATA ports or reduce PCIe lanes for the GPU. The exam might test this interaction.
Trap 4: Mixing up M.2 keys. B-key is for SATA or PCIe x2, M-key is for PCIe x4. A B-key SSD will not fit into an M-key-only slot unless the slot supports both keys (B+M keyed). The exam may show a card with two notches (B+M key) and ask which slots it fits.
Step-by-Step: How an NVMe Read Command is Processed
Host Creates Submission Queue Entry: The CPU driver builds a 64-byte command describing the read operation (LBA, length, memory address for data) and writes it to the submission queue tail doorbell.
Controller Picks Up Command: The NVMe controller sees the doorbell ring, reads the command from the submission queue, and processes it.
Controller Reads Data from NAND: The controller translates the LBA to physical NAND location, reads the data into its internal buffer, handling ECC and wear leveling transparently.
Controller Writes Data to Host Memory: Using DMA (Direct Memory Access), the controller transfers the data directly to the memory address specified in the command, bypassing the CPU.
Controller Posts Completion: After the data transfer, the controller writes a completion entry to the completion queue and optionally sends an interrupt to the CPU.
Host Processes Completion: The CPU's driver reads the completion entry, removes the command from the submission queue, and notifies the application that data is ready.
NVMe Power Management
NVMe supports multiple power states (PS0-PS4) to save energy. PS0 is full performance, while deeper states reduce power but increase latency to resume. The controller can transition between states automatically based on idle time. The exam may ask about Active Power State (APS) and Non-Operational Power State (NOPS).
Conclusion
NVMe and M.2 are essential for modern high-performance storage. The 220-1101 exam expects you to know the differences between NVMe and SATA, the physical characteristics of M.2 modules, and the speed implications. Memorize the key numbers: PCIe lane speeds, M.2 sizes, and protocol limitations. Understand that not all M.2 SSDs are NVMe, and not all M.2 slots support NVMe.
Host Creates Command Entry
The CPU driver allocates a 64-byte command in system memory for the desired I/O operation (read or write). The command includes the logical block address (LBA), transfer length, and a pointer to a data buffer in host memory. This command is written to the tail of a submission queue (SQ). The host then rings the doorbell register (a memory-mapped I/O write) to notify the NVMe controller that a new command is available. The doorbell address corresponds to the specific submission queue being used. This mechanism avoids polling and reduces CPU overhead.
Controller Fetches Command
The NVMe controller detects the doorbell ring and fetches the command from the submission queue via DMA (Direct Memory Access). The controller parses the command and schedules it for execution. Because NVMe supports multiple submission queues, the controller can fetch commands from many queues in parallel, enabling high concurrency. The controller maintains an internal scheduler that may reorder commands for efficiency, but it must ensure completion ordering per queue if required.
Controller Executes Command
For a read command, the controller translates the LBA to a physical NAND flash address using its internal Flash Translation Layer (FTL). It then reads the data from the NAND array into an internal SRAM buffer. The controller applies error correction (ECC) and may perform wear leveling or garbage collection transparently. For a write command, the controller writes data to the NAND after possibly erasing a block. This step involves the actual storage medium access.
Data Transfer via DMA
Once data is ready in the controller's buffer, it transfers the data directly to the host memory buffer specified in the command using PCIe DMA. The controller writes the data over the PCIe bus without CPU involvement. The transfer uses multiple PCIe lanes (x2 or x4) at high speed. The CPU is free to process other tasks during this transfer, which is a key advantage over PIO (Programmed I/O) where the CPU would have to copy data byte by byte.
Controller Posts Completion
After the data transfer is complete, the controller writes a completion entry to the completion queue (CQ) associated with the submission queue. The completion entry includes the command identifier and status (success or error). The controller then optionally rings an interrupt doorbell to notify the host. The host's driver processes the completion entry, removes the command from the submission queue, and signals the application that the I/O is done. The completion queue can also be polled to reduce latency in high-IOPS scenarios.
Enterprise Scenario 1: High-Frequency Trading Server
A financial firm deploys a server running low-latency trading algorithms. They use an NVMe SSD in an M.2 2280 form factor connected via PCIe 4.0 x4. The NVMe drive provides sub-10 microsecond latency and over 1 million random read IOPS, which is critical for processing market data feeds in real time. The system uses a Linux kernel with the NVMe driver optimized for polling mode to avoid interrupt latency. The drive is configured with a single queue pair (one submission queue, one completion queue) to minimize overhead. In this scenario, the NVMe's parallel queue architecture is less important than raw latency; therefore, they disable multiple queues to reduce context switching. A common misconfiguration would be using an M.2 SATA drive instead, which would add ~100 microseconds of latency and cause the trading algorithms to miss market opportunities.
Enterprise Scenario 2: Data Center Virtualization Host
A cloud provider uses a hypervisor with multiple VMs running on a single host. Each VM requires fast storage for database workloads. The host is equipped with two NVMe SSDs in M.2 22110 form factors (enterprise grade with higher endurance). The NVMe drives are configured with multiple I/O queues (one per CPU core) to maximize parallelism. The hypervisor's storage stack is NVMe-oF aware, allowing VMs to directly access NVMe namespaces with low overhead. The drives are formatted with 4K sector size for better alignment with database pages. Performance tuning includes setting the queue depth to 1024 and enabling Write Back caching. A common issue is thermal throttling: M.2 NVMe drives can overheat under sustained writes, causing performance drops. The solution is active cooling (heatsinks or fans) and monitoring drive temperature via SMART attributes.
Scenario 3: Consumer Laptop Upgrade
A user upgrades a laptop's storage from a 2.5-inch SATA SSD to an M.2 NVMe SSD. The laptop has one M.2 slot that supports both SATA and NVMe (B+M key). The user buys an M.2 NVMe drive (M-key) and installs it. The system boots but the drive is not recognized in the BIOS. The problem: the M.2 slot is wired for SATA only (common in older laptops). The user must check the motherboard manual to confirm NVMe support. Alternatively, the laptop might have a second M.2 slot that supports NVMe. This scenario illustrates the importance of verifying protocol support before purchasing. If the slot supports NVMe but the drive is SATA, it will work but at SATA speeds. The exam often tests this confusion.
What 220-1101 Tests on NVMe and M.2
This topic falls under Objective 3.4: "Given a scenario, select, install, and configure storage devices." The exam expects you to:
Identify M.2 form factors by size (2280, 2242, etc.) and key (B, M, B+M).
Compare speeds: SATA 3.0 (6 Gb/s, ~550 MB/s) vs. PCIe 3.0 x4 (~4 GB/s) vs. PCIe 4.0 x4 (~8 GB/s).
Understand that M.2 can be SATA or NVMe, and that NVMe uses PCIe lanes.
Recognize that NVMe requires specific motherboard support (M.2 slot wired to PCIe).
Common Wrong Answers and Why Candidates Choose Them
"All M.2 SSDs are NVMe." Candidates see M.2 and assume NVMe because NVMe is faster and newer. Reality: M.2 is a form factor, not a protocol. Many M.2 SSDs are SATA and limited to 550 MB/s. The exam may show a picture of an M.2 SSD and ask its speed; the answer depends on whether it's SATA or NVMe.
"M.2 NVMe drives use SATA lanes." Candidates confuse the physical connector with the protocol. NVMe uses PCIe lanes, not SATA. A common trap: the exam says an M.2 slot is connected to the chipset via SATA, so an NVMe drive won't work. The correct answer is that the slot only supports SATA M.2.
"NVMe drives have the same speed as SATA SSDs." Candidates who memorize SATA speeds but not PCIe speeds might pick 550 MB/s for an NVMe drive. The correct answer for a PCIe 3.0 x4 NVMe drive is about 4 GB/s.
"M.2 2280 means 22mm x 80mm, and it's the only size." While 2280 is common, other sizes exist (2230, 2242, 2260, 22110). The exam may ask which size fits a specific slot.
Specific Numbers and Terms That Appear Verbatim
SATA 3.0: 6 Gb/s, 550 MB/s (after 8b/10b encoding)
PCIe 3.0 x4: 3.94 GB/s (often rounded to 4 GB/s)
PCIe 4.0 x4: 7.88 GB/s (rounded to 8 GB/s)
M.2 key B: SATA and PCIe x2; key M: PCIe x4
M.2 sizes: 2230, 2242, 2260, 2280, 22110
NVMe command size: 64 bytes
NVMe queue depth: up to 64K per queue, up to 64K queues
Edge Cases and Exceptions the Exam Loves to Test
M.2 slot with B+M key: A slot that accepts both B and M keyed cards. The card can have two notches (B+M keyed) to fit either slot.
NVMe in a SATA-only M.2 slot: The drive will not be detected because the slot lacks PCIe connectivity.
Using an M.2 NVMe drive may disable some SATA ports (e.g., on Intel chipsets, certain SATA ports share bandwidth with M.2). The exam might ask: "After installing an M.2 NVMe SSD, two SATA ports stop working. What is the most likely cause?" Answer: The M.2 slot shares PCIe lanes with those SATA ports.
PCIe generation mismatch: An NVMe drive designed for PCIe 4.0 will work in a PCIe 3.0 slot but at PCIe 3.0 speeds.
How to Eliminate Wrong Answers
If the question mentions speed and the form factor is M.2, check whether it specifies SATA or NVMe. If not specified, assume it's SATA unless context suggests otherwise (e.g., "high-performance" or "gaming").
If the question asks about compatibility, look for key type (B vs. M) and protocol (SATA vs. NVMe). A B-key card will not fit an M-key-only slot.
For speed comparisons, convert to MB/s: SATA 3.0 = 550 MB/s; PCIe 3.0 x4 = ~4000 MB/s; PCIe 4.0 x4 = ~8000 MB/s.
If the question involves an M.2 SSD not being recognized, consider protocol mismatch (SATA vs. NVMe) or key mismatch (B vs. M).
M.2 is a form factor, not a protocol. M.2 SSDs can be SATA or NVMe.
NVMe uses PCIe lanes; typical speeds: PCIe 3.0 x4 ~4 GB/s, PCIe 4.0 x4 ~8 GB/s.
SATA 3.0 max throughput is 6 Gb/s (~550 MB/s).
M.2 key B supports SATA and PCIe x2; key M supports PCIe x4.
Common M.2 sizes: 2230, 2242, 2260, 2280, 22110 (width x length in mm).
NVMe supports up to 64K queues, each with 64K commands, enabling massive parallelism.
Not all M.2 slots support NVMe; verify motherboard specs before purchasing.
Using an M.2 NVMe drive may disable some SATA ports due to shared PCIe lanes.
NVMe command is 64 bytes; AHCI command is 8 bytes.
NVMe reduces latency to as low as 2-3 microseconds for random reads.
These come up on the exam all the time. Here's how to tell them apart.
NVMe (PCIe)
Uses PCIe bus directly (x2 or x4 lanes)
Protocol designed for flash: low latency, high parallelism
Up to 64K queues, each with 64K commands
Speeds: PCIe 3.0 x4 ~4 GB/s, PCIe 4.0 x4 ~8 GB/s
Command size: 64 bytes
SATA (AHCI)
Uses SATA bus (6 Gb/s, ~550 MB/s after encoding)
Protocol designed for HDDs: single queue, 32 commands max
Single queue with 32 command slots (NCQ)
Max ~550 MB/s (SATA 3.0)
Command size: 8 bytes (plus data transfers)
Mistake
M.2 is a type of storage protocol.
Correct
M.2 is a form factor (physical connector and size), not a protocol. M.2 SSDs can use either SATA or NVMe protocol. The protocol determines speed, not the form factor.
Mistake
All M.2 SSDs are faster than 2.5-inch SSDs.
Correct
Speed depends on the protocol. An M.2 SATA SSD has the same ~550 MB/s speed as a 2.5-inch SATA SSD. Only M.2 NVMe SSDs are significantly faster, using PCIe lanes.
Mistake
NVMe drives use SATA cables.
Correct
NVMe drives connect directly to the PCIe bus, either through an M.2 slot or an add-in card. They do not use SATA cables or controllers. SATA is a separate interface.
Mistake
An M.2 slot always supports both SATA and NVMe.
Correct
Many M.2 slots are wired for only SATA or only NVMe. Some support both (via B+M key and appropriate chipset connections). Always check the motherboard manual.
Mistake
NVMe drives have unlimited queue depth.
Correct
The theoretical maximum is 64K queues × 64K commands per queue, but practical implementations are limited by hardware resources. Typical consumer drives support 16-128 queues with queue depths of 256-1024.
Reveal each answer, then mark whether you got it right. Score 60%+ to unlock the next chapter.
M.2 SATA uses the SATA protocol and is limited to ~550 MB/s, while M.2 NVMe uses PCIe lanes and can reach multiple GB/s (e.g., PCIe 3.0 x4 ~4 GB/s). Physically, both use the same M.2 connector, but the key may differ: M.2 SATA often uses B-key, while NVMe uses M-key. Some slots support both. The exam expects you to know that not all M.2 SSDs are fast; check the protocol.
No. If the M.2 slot is wired for SATA only, it lacks PCIe lanes, so an NVMe drive will not be detected. You must check the motherboard manual to see if the slot supports NVMe (PCIe). Some slots support both, but many older ones are SATA-only. The exam may present this as a troubleshooting scenario.
M.2 2280 refers to a module size: 22mm wide and 80mm long. The first two digits are width in mm, the next two are length in mm. Common sizes: 2230, 2242, 2260, 2280, 22110. The exam may ask you to identify the size from a label or picture.
PCIe 3.0 provides about 985 MB/s per lane. With x4 lanes, the theoretical maximum is ~3.94 GB/s. Real-world speeds are slightly lower due to overhead, but expect around 3.5 GB/s sequential reads. The exam often rounds to 4 GB/s.
B-key has a notch on the left side (pins 12-19) and supports SATA and PCIe x2. M-key has a notch on the right side (pins 59-66) and supports PCIe x4. A B+M keyed card has both notches and fits both types of slots, but is limited to the lower capability (e.g., PCIe x2). The exam may test which key fits which slot.
NVMe drives can generate significant heat under sustained loads, especially PCIe 4.0 drives. High temperatures can cause thermal throttling, reducing performance. Many motherboards include heatsinks for M.2 slots. The exam may mention that M.2 NVMe drives benefit from passive or active cooling.
Yes, you can use an M.2 to PCIe adapter card to install an M.2 NVMe drive in a standard PCIe slot (x4 or x16). The adapter provides the necessary PCIe lanes and power. However, the drive will still use the NVMe protocol. This is a common way to add NVMe storage to older systems without M.2 slots.
You've just covered NVMe and M.2 Form Factors — now see how well it sticks with free 220-1101 practice questions. Full explanations included, no account needed.
Done with this chapter?