---
title: 'Flexible Data Placement: Methods & Mechanisms'
url: https://www.emergentmind.com/topics/flexible-data-placement-fdp
type: topic
---

# Flexible Data Placement: Methods & Mechanisms

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":"1501.04703 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 [1004.4420] [1501.04703] [2503.11665] [2602.22437].

## 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 [1004.4420]. 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 [1004.4420].

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 [1301.6228]. “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 [1312.0285]. 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 [1302.4168].

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 [1501.04703]. 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 [1706.06035]. 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 [2011.01024] [2106.00480] [2503.11665] [2602.22437].

## 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 [1004.4420], a workload-derived Data-Unit [1301.6228], a table, view, or intermediate result [1312.0285], a baseband operator [1501.04703], a virtual machine or data block [1706.06035], a packetized file segment in coded caching [2106.00480], a block or row of a tensor in FSDP [2602.22437], or a class of flash-cache writes mapped to a Reclaim Unit Handle in NVMe FDP [2503.11665].

The second abstraction is a physical placement target. In different papers this target is a client cache or machine [1004.4420], a Pilot-Data sandbox on a storage backend [1301.6228], a server partition in a shared-nothing cluster [1312.0285], a cell site or central office [1501.04703], a computing node or storage node in a data center [1706.06035], an address-space extent backed by segments [2011.01024], a user cache column in a placement-delivery array [2106.00480], a reclaim unit or reclaim group inside an SSD [2503.11665], or a GPU-local shard of a distributed tensor [2602.22437].

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 [1004.4420]. 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 [1312.0285]. 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 [1302.4168]. In C-RAN, node weights encode computational complexity, edge weights encode bandwidth, and the objective jointly minimizes computational and fronthauling costs under delay constraints [1501.04703]. In NVMe FDP, the relevant quantity is device write amplification and its induced endurance, power, and carbon effects [2503.11665]. 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 [2106.00480]. In veScale-FSDP, flexible placement is evaluated by alignment constraints, per-device buffer size $S$, communication efficiency, and memory usage [2602.22437].

| 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 [1501.04703]. 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 $c\subseteq M$ of clients that store replicas. The ILP uses binary variables $x_{oc}$ and minimizes
$$
\sum_{o\in O}\sum_{c\in\mathcal{C}} \text{cost}_{oc}\,x_{oc}
$$
subject to per-client capacity constraints and one-configuration-per-object constraints [1004.4420]. 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 [1004.4420].

A third pattern is exact reduction to graph partitioning. For relational workloads, the communication cost of query $Q_i$ under placement $f$ is
$$
\operatorname{cost}(f,Q_i)=\min_k \sum_{T_j\in Q_i,\; f(T_j)\neq S_k} C_i^j,
$$
and total workload cost is the sum over queries [1312.0285]. By constructing a bipartite graph with zero-weight query nodes, weighted table nodes, and edge weights $C_i^j$, the paper shows that minimizing workload communication cost is exactly equivalent to minimizing cut cost under partition-capacity constraints [1312.0285]. 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 $(K,F,Z,S)$ placement-delivery array yields cache fraction $M/N=Z/F$ and rate $R=S/F$ [2106.00480]. The paper constructs new PDAs from Proper Orthogonal Arrays, obtaining
$$
\frac{M}{N}=1-\left(\frac{q-z}{q}\right)^t,
$$
while preserving structured delivery and enabling a transformation that reduces subpacketization [2106.00480]. Two coded-placement schemes then use useless-star elimination and MDS coding to further reduce subpacketization and memory while preserving decodability [2106.00480]. 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 [1301.6228]. 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 [1301.6228].

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
$$
E=\left(\sum_{i=0}^{N-1} S_i\right)+P.
$$
As a result, insertions and removals of arbitrary-sized ranges can be implemented in $O(\log N)$ time instead of updating all subsequent offsets, and applications can maintain sorted data in a linear address space with minimal extra indirection [2011.01024]. 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 [2503.11665]. 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 [2503.11665].

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 [2602.22437]. The runtime Distributed Buffer binds this logical plan to contiguous global buffers and enables zero-copy all-gather and reduce-scatter operations [2602.22437]. 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 [1501.04703]. 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 [1706.06035].

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 [1302.4168]. 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 [2503.11665]. The paper stresses that these gains arise not from host-managed garbage collection, but from host-guided data isolation with device-managed GC [2503.11665].

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 [2602.22437]. 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 [2602.22437]. 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 [2503.11665]. 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 [1501.04703] [1301.6228] [2011.01024] [2602.22437] [2106.00480].

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 $\epsilon \ell_{\max}$ to preserve tractability [1004.4420]. Graph-partitioning formulations are workload-driven and static; they assume known queries, known dependencies, and estimated communication costs [1312.0285]. Hypergraph span-minimization likewise presumes a historical query trace that can be modeled as a hypergraph of co-access patterns [1302.4168]. 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 [1301.6228]. FlexSpace centralizes complexity in FlexTree, copy-on-write metadata, logical logging, and garbage collection [2011.01024]. NVMe FDP depends on device-specific RUH counts and reclaim-unit granularity [2503.11665]. 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 [2602.22437]. 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 [1501.04703]. 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 [1004.4420] [1706.06035]. In training systems, more explicit topology-aware planning, heterogeneity handling, and automated block-policy design remain open [2602.22437]. 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.

Source: https://www.emergentmind.com/topics/flexible-data-placement-fdp