Introduction: The Quest for Faster Android Builds

Building Android from source is a demanding task, notorious for its intensive I/O operations and prolonged compilation times. Developers constantly seek optimizations to accelerate this process, from increasing RAM and CPU core counts to fine-tuning filesystem performance. ZFS on Linux (ZoL) has emerged as a compelling option, offering advanced features like data integrity, snapshots, and flexible caching. This article delves into setting up ZFS as a root filesystem on Linux and benchmarking its performance specifically for Android compilation workloads and general toolchain usage, comparing it against more traditional filesystems.

Why ZFS for Development Workloads?

ZFS brings several benefits to a development environment:

• Data Integrity: Copy-on-Write (CoW) and end-to-end checksumming prevent silent data corruption.
• Snapshots: Instantaneous, space-efficient snapshots allow quick rollbacks, invaluable for experimental development or system recovery.
• ARC (Adaptive Replacement Cache): ZFS uses available RAM as a powerful read cache, significantly reducing disk I/O for frequently accessed data, perfect for iterative builds.
• L2ARC (Level 2 ARC): An optional second-level read cache on fast SSDs/NVMe drives to extend the ARC’s capacity.
• Configurable Properties: Granular control over `recordsize`, `compression`, and other parameters allows fine-tuning for specific workloads.

However, ZFS also introduces complexities and potential performance pitfalls if not configured correctly, particularly for I/O-heavy tasks like large code compilations.

Setting Up ZFS On Linux Root for Benchmarking

Establishing ZFS as a root filesystem requires careful planning. For benchmarking purposes, we’ll assume a dedicated drive (SSD or NVMe) for the root pool.

Prerequisites and Initial Setup

You’ll need a Linux distribution that supports ZFS on root installation, such as Ubuntu or Debian, and a bootable live environment. The process typically involves partitioning your disk: a small EFI System Partition (ESP) for UEFI systems, and the remainder for ZFS.

# Assuming /dev/nvme0n1 is your target drive
sgdisk -Z /dev/nvme0n1 # Zap all current partitions
sgdisk -n 1:0:+512MiB -t 1:ef00 -c 1:EFI-System /dev/nvme0n1
sgdisk -n 2:0:0 -t 2:bf00 -c 2:ZFS-Root /dev/nvme0n1
mkfs.fat -F 32 /dev/nvme0n1p1

Creating the ZFS Pool and Datasets

The `ashift` parameter is critical for performance, especially on SSDs/NVMe, as it aligns the ZFS block size with the physical sector size (typically 4KB for modern drives). An `ashift` of 12 corresponds to 2^12 = 4096 bytes (4KB).

# Load ZFS kernel module (if not already loaded)
modprobe zfs

# Create the root pool with ashift=12
zpool create -f -o ashift=12 -o autotrim=on -R /mnt -m / -o feature@async_destroy=enabled 
  -o feature@bookmarks=enabled -o feature@embedded_data=enabled 
  -o feature@empty_bpobj=enabled -o feature@enabled_txg=enabled 
  -o feature@extensible_dataset=enabled -o feature@filesystem_limits=enabled 
  -o feature@hole_birth=enabled -o feature@livelist=enabled 
  -o feature@lz4_compress=enabled -o feature@project_quota=enabled 
  -o feature@resilver_defer=enabled -o feature@spacemap_histogram=enabled 
  -o feature@spacemap_v2=enabled -o feature@userobj_accounting=enabled 
  zroot /dev/nvme0n1p2

# Create root datasets
zfs create -o mountpoint=/ zroot/ROOT/default
zfs create -o mountpoint=/home zroot/home
zfs create -o mountpoint=/var/log -o compression=lz4 -o recordsize=128K zroot/var/log
zfs create -o mountpoint=/usr/local -o compression=lz4 -o recordsize=128K zroot/usr/local
# Other essential datasets as needed (/var/cache, /tmp, etc.)

# Set properties for the root dataset
zfs set compression=lz4 zroot/ROOT/default
zfs set atime=off zroot/ROOT/default
zfs set recordsize=128K zroot/ROOT/default # Optimal for mixed workloads like source code

After populating `/mnt/zroot/ROOT/default` with your system files (e.g., via `debootstrap` or a custom installer), ensure `/etc/zfs/zpool.cache` is correctly configured.

Integrating with the Bootloader (GRUB)

GRUB needs to be configured to understand and boot from ZFS. This typically involves installing GRUB to the EFI partition and updating its configuration:

# Install GRUB (example for UEFI)
grub-install --target=x86_64-efi --efi-directory=/boot/efi --bootloader-id=ubuntu_zfs --recheck --no-floppy

# Update GRUB configuration (from within the chroot)
update-grub

Ensure your GRUB configuration (`/etc/default/grub`) includes `GRUB_CMDLINE_LINUX=