What is LiquidCache?

Distributed caching with efficient compute pushdown.

Who are we?

• Research project lead by Xiangpeng Hao from UW-Madison ADSL
• Paper co-authors: Andrew Lamb, Yibo Wu, Andrea Arpaci-Dusseau, and Remzi Arpaci-Dusseau
• The project began with support from InfluxData, with subsequent support from SpiralDB and Bauplan
• Public-benefit project in appreciation of taxpayers, gifts, and open-source communities

LiquidCache at a Glance

As a cache service

• All object stores (S3, GCS, Azure Blob, ...)
• All all compute platforms compute (K8s, Lambda, ...)
• All data services (anomaly detection, knowledge base, dashboards, ...)
• Built on industry standards (Parquet, Arrow Flight, DataFusion)

LiquidCache at a Glance

As a pushdown engine

• Filter and aggregation pushdown
• Compressed execution
• Network-efficient transfer
• Efficient storage access

Why LiquidCache?

We like S3

1. Simple durability: 11 nines — you never worry about data loss
2. Simple scalability: virtually unlimited space and throughput

Why LiquidCache?

...but S3 is slow and expensive

1. 100 ms first-byte latency + transfer latency; multiplies with round-trips
2. Complex pricing model: storage, request, and egress costs
3. Storage price unchanged for 10 years despite 20x cheaper hardware*

Why LiquidCache?

LiquidCache: foundation of diskless architectures

1. Caches are everywhere: compute-local, shared-nothing, and cache services
2. DLC trilemma: among Durability, low Latency, and low Cost, pick two

How LiquidCache Works

LiquidCache - Pushdown

User side change: add a DataFusion physical optimizer rule

LiquidCache - Liquid Data

Parquet is industry standard

• Supported by all major engines
• Battle-tested and evolving
• Open governance under ASF

More performance needed

• Better encodings exist
• Parquet evolves cautiously — it cannot break your data

Vortex

Nimble

FastLanes

LiquidCache - Liquid Data

1. Best encodings from decades of research*
2. Cache-only format: freely evolves without breaking user code
3. Transparent, progressive, selective transcoding from Parquet
4. Designed for efficient pushdown to save compute and network

How much overhead?

How to use LiquidCache?

#[tokio::main]
pub async fn main() -> Result<()> {
    let ctx = SessionContext::new()?;

    ctx.register_table(table_name, ...)
        .await?;
    ctx.sql(&sql).await?.show().await?;
    Ok(())
}

#[tokio::main]
pub async fn main() -> Result<()> {
	  let cache_server = "http://localhost:8080";
    let ctx = LiquidCacheBuilder::new(cache_server)
        .with_object_store(...)
        .with_cache_mode(CacheMode::Liquid)
        .build(SessionConfig::from_env()?)?;

    ctx.register_table(table_name, ...)
        .await?;
    ctx.sql(&sql).await?.show().await?;
    Ok(())
}

Conclusions: What is LiquidCache?

1

Pushdown

- Execute filters and aggregations at cache

- Send filtered data to compute

+

2

Liquid data

- Cache-only format for efficient pushdown

- First-class support for Parquet