WIO: Upload-Enabled Computational Storage on CXL SSDs

This paper presents WIO, a system for CXL SSDs that enables reversible computational storage by dynamically migrating WebAssembly-based processing actors between the host and device via a zero-copy protocol to overcome thermal and power constraints, thereby significantly improving throughput and reducing latency without requiring application modifications.

The Gist

Imagine your computer is a busy restaurant kitchen.

The Problem: The Traffic Jam
In modern computers, the "chef" (the processor) is incredibly fast, but the "pantry" (the storage drive) is slow. Every time the chef needs an ingredient, they have to run back and forth to the pantry. This running back and forth is the biggest bottleneck. It wastes time and energy.

To fix this, engineers tried two things:

1. The Super-Fast Pantry (Persistent Memory): They put a tiny, super-fast pantry right next to the chef. It worked, but it was expensive and hard to program, so most kitchens didn't use it.
2. The Smart Pantry (Computational Storage): They gave the pantry a brain. Now, instead of the chef running to the pantry, the pantry could chop the vegetables or mix the sauce itself. This sounded great, but it had a fatal flaw: Overheating. If the pantry tried to do too much cooking, it would get too hot, shut down, and the whole kitchen would stop. Also, the "brains" in different pantries spoke different languages, so you couldn't move a recipe from one pantry to another.

The Solution: WIO (The "Upload-Enabled" Kitchen)
The paper introduces WIO, a new way to run a kitchen that solves the overheating problem by making the cooking reversible.

Think of WIO as a kitchen with a magic teleportation belt and a smart manager.

1. The Magic Teleportation Belt (CXL)

In old kitchens, if the pantry got too hot, you had to stop cooking, pack up the chef's notes, and move the whole kitchen to a different room. That took forever.

WIO uses a new technology called CXL. Imagine this as a magic belt that connects the chef and the pantry so tightly that they share the exact same notebook.

• No Copying: If the chef writes a note in the notebook, the pantry sees it instantly. If the pantry writes a note, the chef sees it instantly.
• The Result: When they need to switch who is doing the cooking, they don't have to move the ingredients or the recipe book. They just need to move the chef's current position (which is tiny).

2. The "Upload" Concept (Reversible Cooking)

Usually, "offloading" means sending work away from the chef to the pantry. WIO introduces "Upload."

• The Scenario: The pantry (the storage drive) starts cooking a huge batch of soup. It gets hot. The smart manager sees the temperature rising.
• The Move: Instead of letting the pantry burn out, the manager instantly says, "Stop! Send the cooking back to the chef!"
• The Magic: Because of the magic belt (CXL), the pantry doesn't have to pack up the soup. It just hands the "current step" to the chef. The chef takes over immediately, while the pantry cools down. Later, if the chef gets busy, the manager can send the cooking back to the pantry.

This is like a relay race where the runners can swap the baton mid-stride without stopping the race.

3. The Universal Language (WebAssembly)

In the past, if you wanted to use a Samsung pantry, you had to write recipes in "Samsung-ese." If you switched to a ScaleFlux pantry, you had to rewrite everything in "ScaleFlux-ese."

WIO uses WebAssembly, which is like a universal language (like Esperanto).

• You write the recipe once in this universal language.
• The manager can run that same recipe on the chef's brain (the computer's CPU) or the pantry's brain (the storage drive) without changing a single word.
• This means the kitchen works with any hardware, and you don't have to rewrite your software.

4. The Smart Manager (The Scheduler)

WIO has a manager that watches the kitchen 24/7.

• If the pantry gets too hot: It "uploads" the work to the chef.
• If the chef gets too busy: It "offloads" the work to the pantry.
• If both are busy: It slows down the orders gracefully instead of crashing.

The Real-World Result

The researchers tested this on real hardware. Here is what happened:

• Old Kitchens: When the pantry got hot, it slowed down by 50-60%. The kitchen basically stopped working.
• WIO Kitchen: When the pantry got hot, the work smoothly moved to the chef. The kitchen kept running at full speed.
• Speed: They saw up to 2x faster performance and 3.75x faster writing speeds compared to traditional methods.

Summary

WIO is like giving your computer a storage drive that is smart enough to know when it's getting too hot to work. Instead of crashing, it instantly asks the main processor to help out, and then takes over again when it cools down. It does this without you having to change any of your apps, making your computer faster, cooler, and more efficient.

Technical Summary

1. Problem Statement

Modern computing systems face a widening gap between processor speeds and storage latency, making data movement a dominant performance and energy bottleneck. While two previous lines of innovation attempted to address this, they have failed to displace conventional NVMe SSDs at scale:

• Persistent Memory (PMem): Shortened the latency hierarchy but suffered from complex programming models (e.g., dual-mode requirements) and platform lock-in, leading to market rejection (e.g., Intel Optane).
• Computational Storage Devices (CSDs): Pushed processing toward the data but relied on vendor-specific APIs (fragmenting the ecosystem), lacked cache coherency (requiring explicit synchronization), and suffered from thermal and power cliffs. Under sustained loads, device-side processors (FPGAs/ASICs) overheat and throttle, causing drastic throughput drops (50–60%) or shutdowns.

Core Insight: Static offloading of computation to storage is brittle. The system needs a mechanism where computation can migrate dynamically between the host and the device based on runtime conditions (thermal, power, load). However, previous attempts at "upload" (moving computation back to the host) were impractical due to the high cost of transferring execution state over non-coherent PCIe DMA.

2. Methodology and System Design

The authors propose WIO, a system that realizes "upload-enabled computational storage" on CXL SSDs. The design leverages the CXL.mem protocol to create a coherent shared memory region, enabling reversible compute placement.

Key Architectural Components:

• Migratable Storage Actors:
  • I/O-path logic (compression, encryption, checksumming, parsing) is decomposed into fine-grained storage actors.
  • Actors are compiled to WebAssembly (WASM), providing a portable, sandboxed runtime that works on both host (x86) and device (ARM) cores.
  • State Management:
    • Shared State: Long-lived data (counters, metadata, LRU lists) resides in a 32 GB Coherent PMR (Persistent Memory Region) mapped via CXL.mem. This state is visible to both host and device without copying.
    • Control State: Execution context (instruction pointer, stack, local variables) is small (~8 KB) and is the only state migrated during switching.
• Drain-and-Switch Migration Protocol:
  • When thermal or power constraints arise, the scheduler triggers a migration.
  • Step 1: New requests are routed to the destination.
  • Step 2: The source drains in-flight requests.
  • Step 3: Control state is checkpointed to the coherent PMR.
  • Step 4: The destination reconstructs the actor and resumes.
  • Result: Migration is zero-copy (no data movement) and completes in <50 µs, making it transparent to applications.
• Agility-Aware Scheduler:
  • Samples host (CPU frequency, power) and device (temperature, utilization) metrics every 10 ms.
  • Decision Logic:
    • If Device Temp > 75°C and Host has headroom $\rightarrow$ Upload actors to Host.
    • If Host CPU > High and Device is cool $\rightarrow$ Offload actors to Device.
    • If both are near limits $\rightarrow$ Throttle request rate (avoid thrashing).
  • Enforces a minimum residency interval (100 ms) to prevent oscillation.
• Hardware Implementation:
  • Built on an FPGA-based CXL SSD prototype (Intel Agilex + Samsung SSD).
  • Uses MONITOR/MWAIT instructions for power-efficient polling of completion queues, reducing host CPU utilization from 100% to 35% at low queue depths.

3. Key Contributions

1. Empirical Insight: Demonstrated that static offload is a liability under sustained load due to thermal asymmetry and fragmentation. Showed that CXL coherence makes zero-copy state sharing feasible.
2. New Abstraction: Introduced "Upload-Enabled Computational Storage," where I/O logic is expressed as migratable actors that move between host and device without changing the application interface (POSIX/io_uring).
3. System Realization: Implemented WIO on a CXL SSD prototype, proving that thermal cliffs can be transformed into elastic trade-offs.
4. Performance Gains: Achieved up to 2× throughput improvement and 3.75× write latency reduction compared to thermally throttled CSDs, without application modification.

4. Evaluation Results

The system was evaluated against a ScaleFlux ASIC CSD, a Samsung SmartSSD (FPGA), and the WIO CXL SSD prototype.

• Thermal Resilience (The "Cliff" vs. "Trade-off"):
  • Samsung/ScaleFlux: Under sustained writes, temperatures triggered throttling, causing 50–60% throughput drops.
  • WIO: As device temperature approached 75°C, actors were uploaded to the host. Throughput remained stable with only minor oscillations (CV ~36%), effectively eliminating the hard performance cliff.
• Latency and Throughput:
  • Fine-grained I/O: For 8-byte writes, WIO achieved 5.4 µs latency (vs. 38 µs for SmartSSD and 80.6 µs for ScaleFlux) due to byte-addressable CXL.mem access.
  • Queue Scaling: WIO scaled linearly up to QD=32, reaching 460K read IOPS and 413K write IOPS, outperforming competitors that saturated earlier.
• Runtime Overhead:
  • WASM Performance: For control-flow-heavy and data-movement tasks (typical of storage actors), WASM overhead was negligible or even faster than native (0.74× for memcopy). For dense numeric kernels (e.g., matrix multiplication), overhead was higher (4.22×), confirming the design choice to target I/O-path logic rather than heavy compute.
  • Migration Cost: The drain-and-switch protocol incurred <50 µs latency, making it invisible to the application.
• Application Case Studies:
  • RocksDB: Reduced write latency from 45 µs (NVMe) to 12 µs (3.75× improvement) by placing WAL directly in PMR.
  • STREAM/LLM: Demonstrated effective tiered memory behavior and stable inference performance by offloading metadata handling to the device and shifting compute back to the host when thermal limits were reached.

5. Significance

WIO represents a paradigm shift in storage system design:

• Reversibility: It challenges the dogma of "offload-only" by proving that "upload" is a viable, low-cost operation when supported by coherent memory (CXL).
• Elasticity: It transforms thermal constraints from hard failure points into manageable, elastic trade-offs, allowing systems to sustain high performance under variable loads.
• Transparency: It achieves these gains without requiring application code changes, solving the ecosystem fragmentation that plagued previous CSD efforts.
• Future Proofing: As CXL hardware proliferates, WIO provides a blueprint for "agility-aware" storage that dynamically balances compute placement across the host-device boundary, maximizing the utility of both embedded device compute and host CPU resources.