FlashTree: Advanced Tree Structures in Computing

• FlashTree is a dual-concept term referring to a flash-optimized B-tree variant (FM Tree) for durable storage and an OctTree solver for astrophysical simulations.
• The FM Tree innovatively defers erasures and employs unsorted node fills to extend flash device lifetime while maintaining logarithmic-time operations.
• The FlashTree OctTree solver leverages adaptive mesh refinement and parallelization to efficiently compute self-gravity and optical depth in large-scale simulations.

FlashTree is a term referring to two distinct advanced tree structures pivotal in computational research: (1) the FM Tree, a flash-optimized search tree for durable storage, and (2) the FlashTree OctTree solver, a parallel adaptive mesh refinement tree for self-gravity and optical depth calculations within the FLASH astrophysical code. Both address foundational performance limitations of existing tree data structures in their respective domains—flash-based storage systems and large-scale astrophysics simulations—through innovations in data organization, update algorithms, and physical hardware considerations (III et al., 2012, Wünsch et al., 2017).

1. FlashTree (FM Tree) for Flash Storage

The FM Tree, introduced by Clay & Wortman, is a B-tree variant tailored for multi-level flash memory, exploiting the non-destructive increment property and addressing the high cost and limited lifetime of block erasures. Its core design goals are to drastically reduce erasure rates, maintain amortized logarithmic-time operations, and incur only modest additional CPU and space overhead (III et al., 2012).

Key differences from classical B-trees include:

• Lazy, deferred erasure: Blocks are erased only on global rebuild, not on every logical modification.
• Unsorted node fills: Entries are inserted into any free slot, abandoning in-node sorted order to avoid costly in-place rewrites.
• Barren marking: Deletions and node emptiness are signaled by a single-bit increment (barren bit), not physical removal, deferring rebalancing to a future garbage collection.

2. Data Organization and Update Mechanisms

FM Tree (Flash Memory)

Each FM Tree node stores up to $2B$ key/value slots and $2B+1$ child pointers. Entries are invalidated using a 1-bit barren cell. The architecture maintains a global pool of erased blocks, from which fresh nodes are allocated upon splits or rebuilds, ensuring no erasure cost at split time. Node entries are not kept sorted, enabling $O(B)$ scans instead of $O(\log B)$ searches per node; as $B$ is a small constant, this is acceptable (III et al., 2012).

Operational summary:

• Search: Linear scan over non-barren entries; recurses to children.
• Insert: If a slot is available, write (increment-cell) without erasure; if overfull, split into fresh blocks, with no erasures.
• Delete: Mark entry’s barren bit; no immediate data structure rebalancing.
• Garbage Collection: Triggered periodically or as the erase-pool depletes; all live entries copied to new blocks reconstructing a balanced FM Tree, with one erasure per old block.

FlashTree OctTree (FLASH Code)

The “FlashTree” in FLASH—distinct from the FM Tree—consists of an AMR “amr-tree” covering the simulation domain, with local “block-trees” extending down to individual grid cells. Each node aggregates total mass and center-of-mass, supporting recursive multipole calculation for gravity. For parallelization, only the subset of the tree required for a local calculation is communicated between MPI ranks, significantly reducing communication and memory overhead (Wünsch et al., 2017).

3. Asymptotic and Empirical Performance

FM Tree Erasure Cost

The FM Tree achieves

$$T_{\mathrm{search}}(n) = O(\log n),\quad T_{\mathrm{insert}}(n) = O(\log n),\quad T_{\mathrm{delete}}(n) = O(\log n)$$

with the critical improvement: $$E_{\mathrm{FM}}(M) = \frac{N_{\mathrm{blocks}}}{M}\ll 1$$ meaning that, by scheduling global rebuilds appropriately, block erasures per update are reduced by 27–70× compared to standard B-trees (which have $\Theta(1)$ erasures per update worst-case). This reduction directly extends device lifetime, given typical flash limits of $10^4$–$10^5$ erasures per block (III et al., 2012).

Representative table of empirical results:

Metric	Standard B-tree	FM Tree	Ratio (B/FM)
Total reads	30,000	54,000	0.56×
Total writes	1,200	360	3.3× fewer
Total erasures	1,080	15–40	27–72× fewer
Throughput (ops/s)	12,000	36,000	3×
Avg latency (μs)	80	45	0.56×

FlashTree OctTree Accuracy and Scalability

For gravity and optical depth, the FLASH OctTree solver demonstrates high accuracy (typically $<1\%$ error versus direct sum or multigrid methods) and scales efficiently up to $\approx$1500 cores. Boundary conditions (isolated, fully periodic, mixed) are flexibly supported via Ewald summation and its generalizations. ABU (Adaptive Block Update) further accelerates repeated computations by selectively skipping updates for blocks with small potential changes. Optical depth estimation uses a TreeCol-style node-ray intersection mapped via local HEALPix directions (Wünsch et al., 2017).

4. Hardware-Aware Optimization and Wear-Leveling

For the FM Tree, wear-leveling is achieved using deferred erasure pools: freshly erased blocks are cycled in a round-robin strategy across physical flash, distributing write and erase usage uniformly. All logical updates occur as bit increments—no destructive overwrite—delaying any block erasure until global rebuild. Combined, these optimizations ensure two orders of magnitude reduction in erase count per update and, consequently, major lifetime extension for flash hardware (III et al., 2012).

5. Algorithmic Innovations and Multipole Criteria

FM Tree

Unsynchronized updates (due to lazy deletion and unsorted slots) enable zero-erase insertions, and global rebalancing ensures overall efficiency and correctness. The decoupling of logical and physical removal of entries is central to flash durability.

FlashTree OctTree

Multiple multipole acceptance criteria (MACs) are supported:

• Geometric (Barnes–Hut): $h/d < \theta_{\rm lim}$
• APE (Approximate Partial Error): Accept if monopole error $\Delta a<G\,M\,h^2/d^4$ falls below threshold
• MPE (Maximum Partial Error): Uses detailed multipole expansion for upper-bounding force error

APE and MPE MACs optimize accuracy/cost tradeoffs: e.g. for a turbulent sphere (AMR $1024^3$, 96 cores), APE at $\epsilon=10^{-2}$ achieves $e_a=4.5\%$ at $t_{\rm grv}=7.0$s/step; Geometric BH MAC ($\theta=0.5$) achieves $e_a=2.1\%$ at $t_{\rm grv}=19.9$s/step (Wünsch et al., 2017).

6. Comparative Benefits and Empirical Results

Both FlashTree paradigms demonstrate significant advantages for their respective domains:

• FM Tree: Extends flash lifetime by 27–70×, lowers write and erase rates, and delivers 2–3× overall throughput improvement, at the cost of slightly increased read operations due to unsorted node scans (III et al., 2012).
• FlashTree OctTree: Outperforms or matches multigrid for gravity, with lower memory overhead and robust scaling. Optical depth calculations achieve $<10\%$ typical discrepancy vs. RADMC-3D while being much faster (e.g. 24s/step vs. 53min for comparable radiation field calculations); scaling is near-ideal up to 1536 cores (Wünsch et al., 2017).

7. Applications and Conclusions

The FM Tree is suited for workloads dominated by inserts and deletes on multi-level flash devices (e.g. databases, file systems) requiring maximum flash endurance and efficiency. Its design supports near-zero per-update erasure cost while maintaining classical B-tree operation times (III et al., 2012). The FLASH FlashTree OctTree solver is integral for astrophysical simulations, supporting advanced gravity calculation and radiation transport estimators at scale, with accurate boundary handling and effective parallel efficiency (Wünsch et al., 2017).

Collectively, “FlashTree” architectures exemplify data structures adapted for hardware-aware computing and highly parallel scientific workflows, providing critical infrastructure for persistent key-value stores and high-performance astrophysical codes.