Flexible Data Placement: Methods & Mechanisms

• Flexible Data Placement (FDP) is a concept that separates logical data units from physical locations using cost models and workload-aware strategies.
• It leverages techniques like graph clustering, configuration-based replica placement, and coded caching to optimize latency, bandwidth, and endurance.
• Empirical studies show FDP can significantly reduce fronthauling costs, improve SSD performance, and boost training throughput in large-scale systems.

Searching arXiv for recent and foundational papers related to Flexible Data Placement. arxiv_search(query="Flexible Data Placement", max_results=10, sort_by="relevance") arxiv_search(query="Flexible Data Placement", max_results=10, sort_by="relevance") Searching arXiv for the specific foundational C-RAN paper and broader FDP usage. to=arxiv_search {"query":"(Liu et al., 2015) OR Graph-based Framework for Flexible Baseband Function Splitting and Placement in C-RAN", "max_results": 5, "sort_by": "relevance"} to=arxiv_search code: {"query":"Flexible Data Placement arXiv", "max_results":10, "sort_by":"relevance"} Flexible Data Placement (FDP) denotes a family of placement mechanisms in which the system decides where logical data units, replicas, processing operators, functions, views, or tensor shards reside across machines, storage devices, network tiers, or accelerators, with the objective of optimizing communication cost, storage or computation cost, latency, endurance, or subpacketization. In the literature, the term appears both as a broad systems concept and as a storage-interface-specific term in the NVMe Flexible Data Placement proposal. Across these uses, FDP is characterized by a separation between logical objects and physical locations, explicit cost models for movement or co-location, and placement decisions that are sensitive to workload structure rather than fixed by a rigid layout (Angel et al., 2010, Liu et al., 2015, Allison et al., 21 Feb 2025, Wang et al., 25 Feb 2026).

1. Historical development and scope

Early work framed FDP as a hardware-level exploitation of device geometry. For MEMS storage, the central observation was that the device offers both “flexibility: freely selecting a set of probe tips for accessing data” and “parallelism: simultaneously reading and writing data with the set of probe tips selected,” which made data placement a first-class optimization problem rather than a passive consequence of linear block addressing (0807.4580). The proposed Region–Sector model abstracted the physical four-dimensional layout into a logical two-dimensional space in which one axis captured parallel probe-tip selection and the other captured sequential transfer.

The theory-oriented strand appeared explicitly in replica placement problems on arbitrary networks. “Optimal Data Placement on Networks With Constant Number of Clients” formalized data placement and page placement as capacity-constrained decisions over replica sets, with the objective of minimizing access and installation cost and, in page placement, respecting per-node serving limits (Angel et al., 2010). This work is notable because it treated non-metric distance matrices and showed exact polynomial-time solvability when the number of clients is fixed, with an additive capacity relaxation of at most $\epsilon \ell_{\max}$ for non-uniform object lengths (Angel et al., 2010).

A second strand emphasized co-placement of data and compute in distributed environments. “Pilot-Data” introduced Data-Units and Pilot-Data as abstractions that separate logical data from physical storage and make data-compute co-placement schedulable across heterogeneous cyberinfrastructure (Luckow et al., 2013). “Distributed Data Placement via Graph Partitioning” then showed that communication-cost minimization for relational workloads can be reduced exactly to weighted graph partitioning, using a bipartite graph of queries and tables rather than a hypergraph that only captures span or distributed-transaction count (Golab et al., 2013). Related workload-driven work used hypergraphs and the objective of minimizing average query span through data placement and replica selection, rather than minimizing explicit bytes transferred (Kumar et al., 2013).

Later work broadened FDP beyond replica placement. In C-RAN, “Graph-based Framework for Flexible Baseband Function Splitting and Placement in C-RAN” modeled baseband function placement as weighted graph clustering, where nodes are functions, edges are information flows, and the placement balances computation cost, fronthauling cost, and delay (Liu et al., 2015). In cloud data centers, joint placement of virtual machines and data blocks was formulated as a network-aware optimization problem over compute and storage nodes, again with communication structure as the key input (Ferdaus et al., 2017). More recent systems extended the same logic to storage interfaces, flexible address spaces, coded caching, and large-scale training, including NVMe FDP SSDs, byte-granular logical insertion and collapse in FlexSpace, placement-delivery arrays with flexible cache sizes, and RaggedShard-based tensor placement in FSDP (Chen et al., 2020, Wu et al., 2021, Allison et al., 21 Feb 2025, Wang et al., 25 Feb 2026).

2. Core abstractions and objectives

Despite domain differences, FDP formulations repeatedly rely on a small set of abstractions. The first is a logical placement unit. Depending on the system, this unit may be a data object or page (Angel et al., 2010), a workload-derived Data-Unit (Luckow et al., 2013), a table, view, or intermediate result (Golab et al., 2013), a baseband operator (Liu et al., 2015), a virtual machine or data block (Ferdaus et al., 2017), a packetized file segment in coded caching (Wu et al., 2021), a block or row of a tensor in FSDP (Wang et al., 25 Feb 2026), or a class of flash-cache writes mapped to a Reclaim Unit Handle in NVMe FDP (Allison et al., 21 Feb 2025).

The second abstraction is a physical placement target. In different papers this target is a client cache or machine (Angel et al., 2010), a Pilot-Data sandbox on a storage backend (Luckow et al., 2013), a server partition in a shared-nothing cluster (Golab et al., 2013), a cell site or central office (Liu et al., 2015), a computing node or storage node in a data center (Ferdaus et al., 2017), an address-space extent backed by segments (Chen et al., 2020), a user cache column in a placement-delivery array (Wu et al., 2021), a reclaim unit or reclaim group inside an SSD (Allison et al., 21 Feb 2025), or a GPU-local shard of a distributed tensor (Wang et al., 25 Feb 2026).

The third abstraction is a workload-sensitive cost model. In replica-placement papers, the cost is access plus installation cost, with clients fetching from the nearest replica in an arbitrary distance matrix (Angel et al., 2010). In graph-partitioning formulations, the cost is explicit communication cost incurred when a query and a table or view dependency are assigned to different servers (Golab et al., 2013). In workload-span formulations, the objective is the minimum number of partitions that a query must touch, computed as a set-cover problem over replicas (Kumar et al., 2013). In C-RAN, node weights encode computational complexity, edge weights encode bandwidth, and the objective jointly minimizes computational and fronthauling costs under delay constraints (Liu et al., 2015). In NVMe FDP, the relevant quantity is device write amplification and its induced endurance, power, and carbon effects (Allison et al., 21 Feb 2025). In coded caching, placement is judged by memory ratio $M/N$, rate $R$, and subpacketization level $F$, all encoded by the structure of a placement-delivery array (Wu et al., 2021). In veScale-FSDP, flexible placement is evaluated by alignment constraints, per-device buffer size $S$, communication efficiency, and memory usage (Wang et al., 25 Feb 2026).

Setting	Placement unit	Primary objective
Non-metric data placement	Object replicas	Access + installation cost
Workload graph clustering	Tables, views, functions	Communication or fronthaul cost
Query-span minimization	Replicated data items	Average query span
NVMe FDP caching	Write classes via RUHs	Lower device write amplification
FSDP training	Ragged tensor blocks	Low padding, communication, memory

A plausible implication is that FDP is best understood as a unifying optimization pattern rather than a single algorithmic template. What remains invariant is not the object being placed, but the late binding between a logical unit and a physical location.

3. Mathematical formulations and algorithmic patterns

One canonical FDP formulation is graph-based clustering. In the C-RAN model, the transceiver is represented as a directed graph $G=(V,E)$ in which nodes are atomic baseband functions, edges are information flows, node complexity is $\gamma:V\to\mathbb{R}$, and link bandwidth is $\omega:E\to\mathbb{R}$. A placement is a clustering function $\xi:V\to\mathbb{Z}$. The optimization is bi-objective:

$$\begin{array}{ll} \min\limits_{\xi} & \sum\limits_i c_c(i;\xi), \quad \sum\limits_{i}\sum\limits_{j} c_f(i,j;\xi) \ \text{s.t.} & d(p;\xi)=\sum_{v\in p} d(v,p;\xi)<D(p),\quad \forall p \end{array}$$

and is solved by a customized genetic algorithm with natural encoding, seed nodes, roulette-wheel selection, dispersive crossover, and graph-based mutation (Liu et al., 2015). This formulation is directly recognizable as FDP over a weighted directed graph with path-level latency constraints.

A second canonical formulation is configuration-based replica placement. In the non-metric data-placement model, each object chooses exactly one configuration $M/N$0 of clients that store replicas. The ILP uses binary variables $M/N$1 and minimizes

$M/N$2

subject to per-client capacity constraints and one-configuration-per-object constraints (Angel et al., 2010). For uniform object lengths, dynamic programming over remaining capacity vectors yields an optimal polynomial-time algorithm when the number of clients is fixed. For page placement, the state is extended with load vectors and history patterns to enforce limits on how many distinct clients any cache may serve (Angel et al., 2010).

A third pattern is exact reduction to graph partitioning. For relational workloads, the communication cost of query $M/N$3 under placement $M/N$4 is

$M/N$5

and total workload cost is the sum over queries (Golab et al., 2013). By constructing a bipartite graph with zero-weight query nodes, weighted table nodes, and edge weights $M/N$6, the paper shows that minimizing workload communication cost is exactly equivalent to minimizing cut cost under partition-capacity constraints (Golab et al., 2013). This exactness is significant because prior hypergraph approaches targeted different objectives, such as query span or distributed-transaction count, rather than communication cost.

A fourth pattern is combinatorial coded placement. In coded caching, a $M/N$7 placement-delivery array yields cache fraction $M/N$8 and rate $M/N$9 (Wu et al., 2021). The paper constructs new PDAs from Proper Orthogonal Arrays, obtaining

$R$0

while preserving structured delivery and enabling a transformation that reduces subpacketization (Wu et al., 2021). Two coded-placement schemes then use useless-star elimination and MDS coding to further reduce subpacketization and memory while preserving decodability (Wu et al., 2021). Here FDP is combinatorial rather than graph-theoretic, but the core decision is still which coded pieces are placed in which caches.

4. Systems mechanisms and interfaces

At the systems level, FDP often begins with an interface that decouples logical identity from physical residence. Pilot-Data provides such an interface through Data-Units, which are logical groups of files with immutable membership, and Pilot-Data instances, which are physical storage containers on filesystems, SRM endpoints, iRODS collections, or object stores (Luckow et al., 2013). Compute-Units then refer to Data-Units logically, and the scheduler decides whether to move compute to data, move data to compute, or replicate the data to multiple Pilot-Data instances. Affinity is represented through a logical topology tree and location labels, so co-placement can be expressed even across heterogeneous infrastructures (Luckow et al., 2013).

FlexSpace addresses a different layer: logical address-space placement inside a storage engine. Its FlexTree stores extents using partial offsets in leaves and shift values on internal pointers, so the effective logical offset of an entry is

$R$1

As a result, insertions and removals of arbitrary-sized ranges can be implemented in $R$2 time instead of updating all subsequent offsets, and applications can maintain sorted data in a linear address space with minimal extra indirection (Chen et al., 2020). This suggests a form of FDP in which logical order is preserved while physical placement remains log-structured and GC-managed underneath.

In NVMe FDP, the abstraction is host-directed but device-managed placement. The host associates writes with Reclaim Unit Handles, while garbage collection and NAND management remain inside the SSD. The key objects are Reclaim Units, Reclaim Groups, and RUHs, and RUH types may be initially isolated or persistently isolated (Allison et al., 21 Feb 2025). The interface is therefore more constrained than Open-Channel SSDs or ZNS, but it preserves backward compatibility and random writes while still allowing targeted separation of data classes with different lifetimes (Allison et al., 21 Feb 2025).

In large-scale model training, veScale-FSDP realizes FDP as flexible tensor sharding. RaggedShard generalizes element-wise and row-wise even sharding by allowing arbitrary atomic blocks and arbitrary uneven distributions across devices. A planner then packs these blocks into balanced communication buffers while ensuring that device boundaries coincide with block boundaries and collective-preferred alignment (Wang et al., 25 Feb 2026). The runtime Distributed Buffer binds this logical plan to contiguous global buffers and enables zero-copy all-gather and reduce-scatter operations (Wang et al., 25 Feb 2026). Here FDP is not about durable storage but about high-performance placement of structured model state.

5. Representative trade-offs and empirical effects

The empirical literature consistently presents FDP as a trade-off surface rather than a monotone improvement. In the C-RAN graph-clustering model, proper splitting and placement can “significantly reduce fronthauling cost at the expense of increased computational cost,” while cooperative processing structures and stringent delay requirements increase the likelihood of centralized placement (Liu et al., 2015). The same structural trade-off appears in cloud data centers, where joint VM and data-block placement reduced average network cost by up to 67%, reduced core-switch usage by up to 84%, and increased the average number of application deployments by up to 18% relative to baseline schemes (Ferdaus et al., 2017).

Workload-driven replica placement shows an analogous balance between parallelism and resource consumption. In distributed analytics, minimizing average query span through co-location and replica selection can substantially reduce the number of machines touched by a query and thereby lower total resource and energy consumption, but the paper also notes that increasing execution parallelism by spreading data more widely may reduce latency in some cases while increasing total resource usage (Kumar et al., 2013). This makes clear that FDP objectives differ across workloads: latency, span, bytes moved, and energy need not be aligned.

In storage, NVMe FDP is motivated by hot–cold lifetime separation. For CacheLib on FDP-capable SSDs, targeted placement of SOC and LOC traffic reduced device write amplification to approximately 1.03 over more than two days in the key-value cache workload, kept DLWA near 1.03 from 50% to 100% SSD utilization, improved p99 read latency by 1.75× and p99 write latency by 10× at 100% utilization, and lowered embodied SSD carbon by about 4× in the reported model (Allison et al., 21 Feb 2025). The paper stresses that these gains arise not from host-managed garbage collection, but from host-guided data isolation with device-managed GC (Allison et al., 21 Feb 2025).

In training systems, veScale-FSDP reports 5–66% higher throughput and 16–30% lower memory usage than existing FSDP systems, while supporting block-wise quantization and non-element-wise optimizers and scaling efficiently to tens of thousands of GPUs (Wang et al., 25 Feb 2026). The planner’s padding overhead is below 3% for 1× and 16× row granularities across all reported FSDP sizes, though 128× row granularity can produce step-like spikes up to 18% in GPT-OSS-120B (Wang et al., 25 Feb 2026). The result is an FDP regime in which flexibility and performance are jointly optimized rather than traded off by construction.

6. Misconceptions, limitations, and open directions

A common misconception is that FDP is equivalent to full host-managed storage. The NVMe literature explicitly rejects that equivalence: FDP gives the host influence over where data lands on flash, but “GC remains internal,” unlike Open-Channel SSDs and ZNS, where the host takes over much more of media management (Allison et al., 21 Feb 2025). Another misconception is that FDP is only about replication. The literature here includes replica placement, but also function splitting, compute–data co-placement, flexible logical address spaces, blockwise tensor sharding, and coded placement in caches (Liu et al., 2015, Luckow et al., 2013, Chen et al., 2020, Wang et al., 25 Feb 2026, Wu et al., 2021).

A second limitation is that many exact results rely on strong structural assumptions. The non-metric data-placement and page-placement algorithms are polynomial only when the number of clients is fixed, and non-uniform object lengths require an additive capacity blow-up of at most $R$3 to preserve tractability (Angel et al., 2010). Graph-partitioning formulations are workload-driven and static; they assume known queries, known dependencies, and estimated communication costs (Golab et al., 2013). Hypergraph span-minimization likewise presumes a historical query trace that can be modeled as a hypergraph of co-access patterns (Kumar et al., 2013). This suggests that many FDP schemes are best viewed as offline or periodically re-optimized mechanisms rather than purely online policies.

A third limitation is implementation complexity. Pilot-Data requires adaptors, affinity metadata, and coordination services across heterogeneous infrastructures (Luckow et al., 2013). FlexSpace centralizes complexity in FlexTree, copy-on-write metadata, logical logging, and garbage collection (Chen et al., 2020). NVMe FDP depends on device-specific RUH counts and reclaim-unit granularity (Allison et al., 21 Feb 2025). veScale-FSDP introduces RaggedShard metadata, structure-aware planning, and DBuffer mappings, and its exact planning problem is NP-hard even though the reported planner runs in less than 0.3 seconds (Wang et al., 25 Feb 2026). FDP thus often shifts complexity from applications into control planes, runtime systems, or device interfaces rather than eliminating it altogether.

The open directions identified across the literature are consistent. Several papers point to dynamic graphs, time-varying weights, heterogeneous nodes, and multi-tenant scenarios as natural extensions of static placement models (Liu et al., 2015). Others highlight dynamic or online FDP, approximation for large non-metric systems, richer replication and caching-aware placement, and the integration of migration costs and demand forecasting into cloud schedulers (Angel et al., 2010, Ferdaus et al., 2017). In training systems, more explicit topology-aware planning, heterogeneity handling, and automated block-policy design remain open (Wang et al., 25 Feb 2026). Taken together, these directions suggest that future FDP research will likely focus less on whether placement matters and more on how to make placement adaptive, cost-aware, and compositional across storage, network, and execution layers.