NVMe Namespace Design and Multi-Drive Architectures on FPGA

NVMe Namespace Design and Multi-Drive Architectures on FPGA

Industry update — NVM Express released the full set of eleven NVMe specifications on 4 August 2026, headlined by Base Specification Revision 2.4, ratified 31 July 2026 — the document that defines what a namespace is, when its identifier is valid, and when it may be attached to more than one controller at a time (NVM Express, 4 August 2026).

In short: a namespace is the addressing unit an NVMe controller exposes, identified by the NSID every command carries. Splitting one SSD into several namespaces buys logical separation, not bandwidth. Going faster needs more drives — a PCIe topology problem, and host logic your FPGA has to carry.

If you already know how submission and completion queues work — if not, start with NVMe explained: queues, namespaces and the host controller — the next decision is not how commands get issued but where they land. Get that layer right and one design scales from a single M.2 module to a striped bank of drives.

The short answer

An NVMe namespace is a set of resources directly accessible to the host — formatted non-volatile storage presented as its own target device — identified by a namespace identifier (NSID) carried in every command. Namespaces are logical isolation inside one NVM subsystem: several on one SSD give separate LBA spaces, separate LBA formats and separate protection scope, but share the same flash, controller and PCIe link, so they add no bandwidth. A namespace is private (attached to one controller at a time) or shared (two or more concurrently). To go faster you add drives — fanned out from one root port through a PCIe switch, or on independent root ports — and stripe.

What a namespace is, precisely

Revision 2.4 is terse, and the terseness is the point. A namespace is “a set of resources that may be directly accessed by a host (e.g., formatted non-volatile storage)”; an NSID is “an identifier used by a controller to provide access to a namespace”. NVM Express’ explainer adds the operational view: a collection of logical block addresses presented as a separate target device — hence /dev/nvme0n1 for controller 0, namespace 1.

Two consequences matter on FPGA. A namespace is not physical isolation: it isolates logical blocks, not flash, and the drive still wear-levels and shares spare area across namespaces — the construct for media separation is an NVM Set. And each namespace carries its own LBA format, reported in Identify Namespace alongside size (NSZE), capacity (NCAP) and utilisation (NUSE), so host logic assuming one sector size per drive will mis-address a differently formatted namespace.

The NSID states that break hosts

Most first-time host bugs live in this field: the specification defines four overlapping states plus a broadcast value.

  • Valid vs invalid. Any NSID is valid except 0h or a value greater than the Number of Namespaces (NN) field in Identify Controller. NN is the maximum valid NSID, not a count; the number supported is the separate MNAN field.
  • Broadcast. FFFFFFFFh specifies all namespaces, but its scope depends on the command and only some commands accept it.
  • Allocated vs unallocated. Subsystem-wide: an allocated NSID refers to a namespace that exists, an unallocated one to none.
  • Active vs inactive. Per controller: an allocated namespace attached to this controller is active for it. An inactive NSID makes the controller abort the command.

That last one bites in the lab: a namespace can exist, be healthy, and still reject every command — because it was never attached to the controller you are talking to.

Private, shared, and NMIC

Revision 2.4 defines a private namespace as one only able to be attached to one controller at a time, and a shared namespace as one that may be attached to two or more controllers concurrently. Both point at the NMIC field — Namespace Multi-path I/O and Namespace Sharing Capabilities — set at creation and reported in Identify Namespace.

Sharing has a price the specification names: reservations. When several controllers reach the same logical blocks something must arbitrate writes, and a conforming drive must hold enough resources for every controller with access to register a reservation key, with Persist Through Power Loss state. If an FPGA and a CPU share one SSD, that is where the design work is; with one host, keep namespaces private. The data-centre end goes further — NVM Express’ June 2026 explainer describes exported subsystems, controllers and namespaces, and the August 2026 release adds PCIe Exported NVM Subsystem Migration — but those are hypervisor features an embedded recorder rarely needs.

Shared namespaces, or simply more drives? A short technical conversation usually settles it faster than a spec read.

See the NVMe and storage IP catalogue

Managing NVMe namespaces from fabric

There are two jobs here, and an FPGA host usually needs only the first.

Enumeration — always required

Once the controller is enabled: for each enabled I/O Command Set, issue Identify with the I/O Command Set specific Active Namespace ID list (CNS 07h) and the matching Command Set Identifier, then for each returned NSID issue Identify Namespace (CNS 00h) for size, capacity and LBA format. In fabric that is a modest admin-queue state machine — and it is what tells you the sector size your data path depends on.

Creation and attachment — optional, often unsupported

The Namespace Management command handles create, delete and restore-configuration; the Namespace Attachment command attaches or detaches a namespace, persistently across all reset events. Support is optional, advertised by the Namespace Management Supported (NMS) bit in Identify Controller’s OACS field — many client SSDs never set it — and the pair is coupled: where Management is supported, Attachment shall be too. Detaching turns that NSID inactive, producing exactly the abort above. For most recorders you never create a namespace in fabric: provision once from a PC with nvme-cli, then enumerate and use what you find.

Six NVMe topologies, and what each costs

With the namespace model clear, “multi-drive” becomes six architectures rather than one idea.

NVMe namespace and multi-drive topologies on FPGA: what each buys and what it costs
Topology What it buys Typical use case Implication for the FPGA host
One drive, one namespace Simplicity Single-stream recorder, boot or config storage One NSID, one context, one LBA format. The baseline.
One drive, several private namespaces Logical separation; per-namespace LBA format and protection scope Raw capture area plus a file-system or event-log area Enumerate all active NSIDs; carry the right NSID per command; never assume one sector size.
One drive, namespace shared by two controllers Two hosts reaching the same data FPGA capture with CPU-side read-back Needs NMIC support on the drive plus a reservation scheme.
Several drives, one root port, PCIe switch fan-out Capacity and aggregate IOPS from one FPGA PCIe block Compact multi-M.2 recorder or carrier card Enumeration walks the switch; one context per drive; rate capped by the upstream link.
Several drives, independent root ports Full per-drive bandwidth, no shared bottleneck Highest sustained-rate striped recorders N PCIe hard blocks, N contexts, N sets of buffers. Costs fabric and pins.
Drives behind a network fabric Remote or pooled storage; distance from capture to media Distributed acquisition, JBOD at the far end of a link Needs a MAC and a storage-over-network layer instead of a local root port.

The common error is conflating rows two and four: four namespaces on one SSD give four target devices and zero extra bandwidth; four drives behind a switch give real aggregate throughput.

What multi-drive actually buys

Recorders go multi-drive for rate, and the mechanism is striping — RAID0: consecutive blocks written round-robin across N drives. Three things decide whether the theoretical N× survives contact with hardware. Stripe alignment: the stripe unit must be a whole number of logical blocks in the namespace’s LBA format, or every write straddles a boundary and the drive does read-modify-write behind your back. Queue depth per drive: a host that serialises across drives gets one drive’s throughput however many it has. The slowest member wins: the set writes at the rate of whichever drive is mid-garbage-collection.

And the trade nobody should skip: RAID0 has no redundancy — one drive lost is the whole capture lost. For trials or flight-test data that is often an acceptable exchange for rate, but it should be a decision, not an accident. RAID0 across disks appears in the published feature list of our exFAT and FAT32 File-System IP and in the SATA III recorder IP, one interface down.

What changes inside the FPGA host

Moving beyond one namespace on one drive changes four things:

  1. The command builder is parameterised. NSID becomes a per-transfer field alongside starting LBA and block count.
  2. Enumeration becomes real logic. An admin-queue sequence stores sector size and capacity per namespace.
  3. Completion routing gains a dimension. N drives means N controllers, each with its own completion queues and doorbells, steered back to the right context.
  4. Buffering multiplies. Each drive needs elastic buffer to ride out its own garbage-collection pauses without backpressuring the capture front end — where multi-drive designs run out of BRAM before bandwidth.

Against that, the published feature list of our NVMe Host IP cores cites 8 namespaces and up to 16 independent I/O queues usable by multiple users, sector sizes of 512 bytes or 4096 bytes, and an I/O queue buffer configurable from 32 KB to 1024 KB. Control registers sit on AXI-Lite for AMD families, Avalon on Agilex 7 R-Tile and APB on the PolarFire recorders, with payload on AXI4 — the Zynq UltraScale+ integration guide walks that wiring end to end. Cores ship as VHDL or Verilog source with C drivers, which is what makes a per-drive context replicable rather than a black box. How many drives a core sustains concurrently, and at what rate, is a per-core datasheet question. For the network row, our NOE SAN IP feature list covers ATA-over-Ethernet v1.0 for NVMe SSDs with JBOD over 10 GbE to 400 GbE.

Where this stops applying

  • You need physical, not logical, isolation. If two streams must not contend for media, the construct is an NVM Set or a separate drive.
  • Your drive does not support namespace management. Check the NMS bit in OACS before designing a create-and-attach flow into fabric.
  • You want exact throughput or resource numbers. We publish no sustained GB/s figure for Gen4 or Gen5 cores and will not invent one — size it on your own bench.
  • A single link would do. If one drive carries your rate, multi-drive adds failure modes for nothing; our NVMe host IP guide covers where that line sits.

In summary

Namespaces and multi-drive answer different questions. A namespace is the addressing and isolation unit inside one subsystem — an NSID that must be valid, allocated and active on the controller you are addressing. Multiple drives are the answer to rate. A host that treats NSID as a runtime field, enumerates properly and replicates its context per drive scales across all six topologies without a redesign.

Frequently asked questions

How many namespaces can one NVMe SSD expose?

It is a per-drive property. Identify Controller reports the Number of Namespaces (NN) field — the maximum valid NSID for the subsystem — and the Maximum Number of Allowed Namespaces (MNAN) field, the maximum the subsystem actually supports. Many client-class SSDs ship with exactly one namespace and no way to create more, so read both at enumeration rather than assuming.

What is the difference between a private and a shared namespace?

A private namespace can only be attached to one controller at a time; a shared namespace may be attached to two or more controllers in the NVM subsystem concurrently. The distinction is carried by the NMIC field, set at creation and reported in Identify Namespace. Sharing brings reservations into the design, since two controllers reaching the same blocks need arbitration.

Do I need namespace management logic in my FPGA host?

Usually not. Creating, deleting and attaching namespaces is optional in NVMe, and support is advertised by the NMS bit in the Identify Controller OACS field — a drive that does not set it cannot do it at all. The pragmatic pattern is to provision the drive once from a PC with nvme-cli, then have the FPGA enumerate and use what it finds.

Is an NVMe namespace the same thing as a disk partition?

No. A partition is a host-side convention written into a table inside one block device; a namespace is created by the controller and presented as a separate target device with its own LBA space, LBA format and Identify data. Two namespaces on one SSD can use different logical block sizes — but they remain logical isolation, sharing flash, controller and spare area.

Will splitting my SSD into several namespaces increase write throughput?

No. Every namespace on a drive is served by the same controller over the same PCIe link and backed by the same flash, so sustained rate is unchanged — you have divided one address space, not multiplied the media. Namespaces buy logical separation and distinct LBA formats. If the goal is rate, add drives and stripe across them.

Can a single FPGA host IP core drive several NVMe SSDs at once?

Treat that as a datasheet question for the specific core and family. Architecturally there are two routes: a PCIe switch fanning one root port out to several endpoints, where the upstream link caps aggregate bandwidth; or several independent PCIe hard blocks, each with its own host context, which costs fabric and pins but removes the shared bottleneck. Both are architectures enabled by host IP on the fabric side.

LDS
Logic Design Solutions
FPGA design house and soft-IP core vendor — NVMe, SATA, ARINC 429, 10G Ethernet MAC and exFAT IP for AMD, Altera and Microchip FPGAs since 1994.

How we write these guides: each is drafted by the engineers who build and support our cores. Protocol behaviour is quoted from the NVM Express specifications; drive counts, throughput, latency and LUT/BRAM utilisation are deferred to the core’s datasheet and your own bench — never to a made-up figure.

Designing a multi-drive NVMe recorder, or laying out namespaces on one? Tell us your FPGA family, drive count and sustained rate — we will point you to the right core.

Explore the IP catalogue

  1. NVM Express — NVM Express Base Specification: the set released 4 August 2026, Base Revision 2.4 ratified 31 July 2026.
  2. NVM Express — Base Specification, Revision 2.4 (PDF): namespace and NSID definitions, private vs shared, NSID states, NN and MNAN, Management and Attachment commands.
  3. NVM Express — NVMe Namespaces: logical vs physical isolation, NSZE/NCAP/NUSE, attachment model.
  4. NVM Express — press release, 4 August 2026: NVMe 2.4, including PCIe Exported NVM Subsystem Migration.
  5. NVM Express — Standardizing SSD Virtualization (9 June 2026): exported subsystems, controllers and namespaces.
  6. PCI-SIG — PCI Express specifications: the root port, switch and endpoint model behind every topology above.
  7. Logic Design Solutions — IP catalogue: published feature lists for the NVMe Host, exFAT/FAT32 and NOE SAN IP.