AI and HPC clusters run best when the data they need is as close as possible to the GPUs and CPUs doing the work. In most environments, that means the NVMe SSDs sitting inside each compute server. They’re the fastest, lowest-latency storage possible, and yet much of that performance is stranded, isolated in tiny silos inside individual nodes.
Hammerspace Tier 0 was created to activate that stranded performance by turning those local NVMe devices into a shared file system the entire cluster can use. Building on the improvements Hammerspace introduced into the Linux kernel in 2024 to further improve Tier 0 performance, the new Hammerspace v5.2 release contains a related enhancement called Tier 0 affinitization that adds locality-awareness to Tier 0 installations.
This new capability is automatic, transparent, and enabled by default. It builds on the NFS performance enhancements Hammerspace contributed to the Linux kernel in 2024, and, importantly, does not require any proprietary client software or kernel patches on compute servers.
What is Tier 0?
Compute servers that are clustered for AI and HPC workloads each typically contain a few NVMe SSDs. This storage is the fastest and lowest latency available, residing on the same PCIe bus with the CPUs and GPUs. But because this capacity is broken into many small silos across the servers, it is largely unused. This is a missed opportunity.
Hammerspace Tier 0 activates these formerly isolated islands of storage, bringing them together into a pNFS-mountable shared file system usable by the entire cluster. When combined with additional tiers of storage and Hammerspace data orchestration, Tier 0 becomes a standards-based high-performance foundation for data-intensive workflows.
How pNFS and Layouts Work in Tier 0
Under the hood, Tier 0 uses Parallel NFSv4.2 (pNFS) with Flex Files, which, like other high-performance file systems, separates metadata from the data path. To perform I/O, a pNFS client first contacts the metadata server (known as an Anvil in Hammerspace) which provides the client with a layout. The layout includes a list of storage targets the client may use to perform the I/O, and the credentials needed to do so. The client then goes directly to the storage to perform I/O – the Anvil metadata server is not in the data path.
Today, per the pNFS standard, the client will use the first storage target in the layout, only moving down the list if the first target is unreachable or if (for writes) the client needs to create additional mirrors of the data. Hammerspace automatically manipulates the order storage targets appear in layouts to spread the load and direct read and write activity as needed to fulfill configured policy objectives.
The Locality Problem Tier 0 Affinitization Solves
Tier 0 delivers the best possible performance when a compute node can use its own local Tier 0 volume for I/O, instead of crossing the network to read or write to another node’s NVMe. To make that happen, the Anvil needs to recognize when the pNFS client requesting a layout is also hosting a Tier 0 storage volume and then place that local volume first in the layout.
If the Anvil can’t distinguish which clients have local Tier 0 volumes, locality becomes a matter of chance. In that case, a given read or write will land on the client-local volume only 1/n of the time, where n is the number of Tier 0 nodes in the cluster. In a five-node cluster, that means the I/O is local only about 20% of the time, and the fraction gets worse as the cluster grows. That’s clearly not ideal.
Previously, the way to improve locality was to configure multiple directories in the file system and apply specific Hammerspace policy objectives to those directories to guide data placement. It worked, but it added configuration steps and ongoing management, especially as environments scaled.
What Changes with Tier 0 Affinitization in v5.2
Tier 0 affinitization removes that manual work. Starting in Hammerspace v5.2, the Anvil automatically detects when a client requesting I/O has a local Tier 0 storage volume. When it sees that, it places that local volume at the top of the list in the pNFS layout for that client.
The result: as much I/O as possible is kept local to the requesting node. This maximizes the performance of Tier 0 while keeping the behavior completely automatic and transparent. No extra configuration, no directory-by-directory tuning, and no changes required on the compute servers themselves.
Affinitization in a Multi-Tier World
Remember that Tier 0 is only one tier of storage in a multi-tier environment. There is usually a Tier 1 consisting of network-attached NVMe flash, and often a colder Tier 2 or Tier 3 on object storage or cloud storage as well.
Hammerspace policy objectives are used to control data placement and protection across these tiers. For example, policies can ensure that frequently accessed files are placed on faster tiers, while colder data is moved to more cost-effective storage, all while maintaining the necessary number of replicas for resilience.
In this multi-tier context, Tier 0 affinitization adds another layer of intelligence. When Tier 0 is configured and a file is accessed that currently resides on Tier 1, 2, or 3, the relevant policy objectives may cause an instance of that file to be placed on Tier 0. With affinitization, that instance doesn’t just land on any Tier 0 volume—it is placed on the local Tier 0 volume on the exact compute node that needs the data. That automatically gives the application the lowest-latency possible path to its data.
What This Means for AI and HPC Clusters
With Hammerspace v5.2, Tier 0 becomes easier to deploy and more effective in practice. The new affinitization capability:
- Keeps more I/O local to each compute node
- Reduces the need for manual configuration and directory-based tuning
- Preserves the standards-based NFS approach, avoiding proprietary client software
For operators of AI and HPC clusters, this means you can more fully exploit the performance potential of the NVMe devices you already own.
Learn More
- Visit the Tier 0 webpage
- For more about pNFS, visit the Hammerspace pNFS Resource Center
