Sharded write in Zarr performance based on write size

gistfile1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "f41b2f44",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-06-11T15:26:56.469937Z",
     "iopub.status.busy": "2026-06-11T15:26:56.469470Z",
     "iopub.status.idle": "2026-06-11T15:26:56.476055Z",
     "shell.execute_reply": "2026-06-11T15:26:56.475171Z"
    }
   },
   "outputs": [],
   "source": [
    "# /// script\n",
    "# requires-python = \">=3.11\"\n",
    "# dependencies = [\n",
    "#     \"icechunk>=2.0.6\",\n",
    "#     \"zarr>=3.1\",\n",
    "#     \"numpy\",\n",
    "#     \"matplotlib\",\n",
    "# ]\n",
    "# ///"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c453c97",
   "metadata": {},
   "source": [
    "# The cost of writing a sharded array in small pieces\n",
    "\n",
    "A shard is a single stored object that packs many inner chunks together. No Zarr\n",
    "store supports partial writes, so writing less than a whole shard turns into a\n",
    "read-modify-write of the entire object:\n",
    "\n",
    "```\n",
    "shard a/c/0:  | c0 | c1 | c2 | c3 |   one object holding 4 inner chunks\n",
    "\n",
    "Writing only c2 -- there is no partial write, so the whole object moves:\n",
    "\n",
    "    GET a/c/0  ->  | c0 | c1 | c2 | c3 |   read the whole shard\n",
    "                   (replace c2 in memory)\n",
    "    SET a/c/0  ->  | c0 | c1 |[c2]| c3 |   write the whole shard back\n",
    "```\n",
    "\n",
    "Filling a shard one inner chunk at a time repeats that GET + SET for every chunk.\n",
    "The rule that falls out for a write pipeline: align writes to shard boundaries.\n",
    "Writing a whole shard at once is one write and zero reads.\n",
    "\n",
    "The experiments below measure this on icechunk. `LatencyStorage` adds a fixed\n",
    "delay per storage operation (standing in for object-store latency) and\n",
    "`LoggingStore` counts the reads and writes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "0c23c8a2",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-06-11T15:26:56.479552Z",
     "iopub.status.busy": "2026-06-11T15:26:56.479210Z",
     "iopub.status.idle": "2026-06-11T15:26:56.948650Z",
     "shell.execute_reply": "2026-06-11T15:26:56.948183Z"
    }
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import time\n",
    "\n",
    "import numpy as np\n",
    "import zarr\n",
    "from zarr.storage import LoggingStore\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.ticker import NullFormatter\n",
    "\n",
    "import icechunk as ic\n",
    "from icechunk.testing import LatencyStorage\n",
    "\n",
    "# One-dimensional array whose single shard holds 64 inner chunks.\n",
    "ARRAY_SHAPE = (128_000,)\n",
    "INNER_CHUNK_SHAPE = (2_000,)\n",
    "SHARD_SHAPE = (128_000,)\n",
    "INNER_CHUNKS_PER_SHARD = ARRAY_SHAPE[0] // INNER_CHUNK_SHAPE[0]\n",
    "N = ARRAY_SHAPE[0]\n",
    "\n",
    "LATENCY_PER_OP_MS = 5  # delay per storage read/write, standing in for the cloud\n",
    "REPEATS = 5  # runs per measurement, to average out jitter\n",
    "GRANULARITIES = (64, 32, 16, 8, 4, 2, 1)  # inner chunks written per assignment\n",
    "\n",
    "# Same size, increasing compressibility.\n",
    "DATASETS = {\n",
    "    \"random\": np.random.default_rng(0).random(N),\n",
    "    \"ramp\": np.arange(N),\n",
    "    \"constant\": np.ones(N),\n",
    "}\n",
    "\n",
    "\n",
    "def fill_shard(values, inner_chunks_per_write, *, use_sharding, inline_threshold_bytes=512):\n",
    "    \"\"\"Fill a fresh array with `values`, `inner_chunks_per_write` chunks per write.\n",
    "\n",
    "    `inline_threshold_bytes` is icechunk's setting: objects bigger than it go to\n",
    "    object storage (so reading one back is a round-trip), smaller ones stay in\n",
    "    the session. Returns (seconds, reads, writes, stored_bytes).\n",
    "    \"\"\"\n",
    "    storage = LatencyStorage(\n",
    "        ic.in_memory_storage(),\n",
    "        write_latency_ms=LATENCY_PER_OP_MS,\n",
    "        read_latency_ms=LATENCY_PER_OP_MS,\n",
    "    )\n",
    "    config = ic.RepositoryConfig(inline_chunk_threshold_bytes=inline_threshold_bytes)\n",
    "    store = ic.Repository.create(storage, config=config).writable_session(\"main\").store\n",
    "    store = LoggingStore(store, log_level=\"WARNING\")  # silent, but counts calls\n",
    "\n",
    "    # With sharding, one shard holds every inner chunk; without it, each chunk is\n",
    "    # its own object.\n",
    "    options = {\"chunks\": INNER_CHUNK_SHAPE}\n",
    "    if use_sharding:\n",
    "        options[\"shards\"] = SHARD_SHAPE\n",
    "    array = zarr.create_array(store, name=\"a\", shape=ARRAY_SHAPE, dtype=\"float32\", **options)\n",
    "\n",
    "    store.counter.clear()  # count the fill, not array creation\n",
    "    values_per_write = inner_chunks_per_write * INNER_CHUNK_SHAPE[0]\n",
    "    start_time = time.perf_counter()\n",
    "    for start in range(0, N, values_per_write):\n",
    "        array[start : start + values_per_write] = values[start : start + values_per_write]\n",
    "    elapsed = time.perf_counter() - start_time\n",
    "\n",
    "    return elapsed, store.counter[\"get\"], store.counter[\"set\"], array.nbytes_stored()\n",
    "\n",
    "\n",
    "def measure(values, n, *, use_sharding):\n",
    "    \"\"\"Time fill_shard REPEATS times. Returns (times, reads, writes, stored).\"\"\"\n",
    "    times = []\n",
    "    reads = writes = stored = 0\n",
    "    for _ in range(REPEATS):\n",
    "        seconds, reads, writes, stored = fill_shard(values, n, use_sharding=use_sharding)\n",
    "        times.append(seconds)\n",
    "    return np.array(times), reads, writes, stored"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "244e433f",
   "metadata": {},
   "source": [
    "## 1. Write granularity\n",
    "\n",
    "Fill one shard while varying how many inner chunks each assignment writes, from\n",
    "the whole shard (64) down to one at a time. Slowdown is relative to writing the\n",
    "whole shard at once."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "74430a6b",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-06-11T15:26:56.950589Z",
     "iopub.status.busy": "2026-06-11T15:26:56.950409Z",
     "iopub.status.idle": "2026-06-11T15:27:19.415133Z",
     "shell.execute_reply": "2026-06-11T15:27:19.413759Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "chunks/write  reads  writes     time  slowdown\n",
      "-----------------------------------------------\n",
      "          64      0       1    0.02s      1.0x\n",
      "          32      2       2    0.04s      2.2x\n",
      "          16      4       4    0.08s      4.3x\n",
      "           8      8       8    0.16s      8.7x\n",
      "           4     16      16    0.32s     17.4x\n",
      "           2     32      32    0.63s     34.6x\n",
      "           1     64      64    1.25s     68.5x\n",
      "\n",
      "unsharded, one chunk per write: 0 reads, 64 writes, 0.63s\n"
     ]
    }
   ],
   "source": [
    "sharded = {n: measure(DATASETS[\"random\"], n, use_sharding=True) for n in GRANULARITIES}\n",
    "unsharded = {n: measure(DATASETS[\"random\"], n, use_sharding=False) for n in GRANULARITIES}\n",
    "whole_shard_seconds = sharded[INNER_CHUNKS_PER_SHARD][0].mean()\n",
    "\n",
    "print(f\"{'chunks/write':>12} {'reads':>6} {'writes':>7} {'time':>8} {'slowdown':>9}\")\n",
    "print(\"-\" * 47)\n",
    "for n in GRANULARITIES:\n",
    "    times, reads, writes, _ = sharded[n]\n",
    "    print(f\"{n:>12} {reads:>6} {writes:>7} {times.mean():>7.2f}s {times.mean() / whole_shard_seconds:>8.1f}x\")\n",
    "\n",
    "times, reads, writes, _ = unsharded[1]\n",
    "print(f\"\\nunsharded, one chunk per write: {reads} reads, {writes} writes, {times.mean():.2f}s\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "014b18ac",
   "metadata": {},
   "source": [
    "Every assignment that covers less than a full shard does one read (to recover\n",
    "the rest of the shard) plus one write, so `reads` matches `writes` everywhere\n",
    "except the whole-shard row, which writes once and reads nothing. The cost grows\n",
    "with the number of assignments. An unsharded array writes one object per chunk\n",
    "and never reads."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "77952e3b",
   "metadata": {},
   "source": [
    "## 2. Does compression change it?\n",
    "\n",
    "Repeat the sweep with data that compresses by very different amounts. The number\n",
    "of reads and writes depends only on the write size, not the data, so only timing\n",
    "could differ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "9d195234",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-06-11T15:27:19.431530Z",
     "iopub.status.busy": "2026-06-11T15:27:19.431336Z",
     "iopub.status.idle": "2026-06-11T15:27:25.195523Z",
     "shell.execute_reply": "2026-06-11T15:27:25.193879Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "compressed shard size (whole array = 512 KiB raw):\n",
      "  random     451.9 KiB\n",
      "  ramp       299.6 KiB\n",
      "  constant     3.4 KiB\n",
      "\n",
      "                            time to fill the shard\n",
      "chunks/write  reads  writes      random       ramp   constant\n",
      "------------------------------------------------------------\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "          64      0       1       0.02s      0.02s      0.03s\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "          16      4       4       0.08s      0.08s      0.09s\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "           4     16      16       0.29s      0.31s      0.32s\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "           1     64      64       1.26s      1.29s      1.29s\n"
     ]
    }
   ],
   "source": [
    "print(\"compressed shard size (whole array = 512 KiB raw):\")\n",
    "for name, values in DATASETS.items():\n",
    "    _, _, _, stored = fill_shard(values, INNER_CHUNKS_PER_SHARD, use_sharding=True)\n",
    "    print(f\"  {name:9s} {stored / 1024:6.1f} KiB\")\n",
    "\n",
    "print(\"\\n\" + \" \" * 28 + \"time to fill the shard\")\n",
    "print(f\"{'chunks/write':>12} {'reads':>6} {'writes':>7}   \" + \"  \".join(f\"{n:>9}\" for n in DATASETS))\n",
    "print(\"-\" * 60)\n",
    "for n in (64, 16, 4, 1):\n",
    "    runs = {name: fill_shard(values, n, use_sharding=True) for name, values in DATASETS.items()}\n",
    "    reads, writes = runs[\"random\"][1], runs[\"random\"][2]\n",
    "    row = \"  \".join(f\"{runs[name][0]:8.2f}s\" for name in DATASETS)\n",
    "    print(f\"{n:>12} {reads:>6} {writes:>7}   {row}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ae36e9e",
   "metadata": {},
   "source": [
    "The compressed shard size spans two orders of magnitude, but the fill time\n",
    "barely moves: the cost is the number of round-trips, not the bytes they carry.\n",
    "Compression saves storage and bandwidth, not the read-modify-write penalty."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c3426525",
   "metadata": {},
   "source": [
    "## 3. Where do the reads go?\n",
    "\n",
    "icechunk writes any object larger than `inline_chunk_threshold_bytes` to object\n",
    "storage and keeps only a reference, so reading it back is a real round-trip;\n",
    "smaller objects stay inline in the session. A real shard is far above the\n",
    "threshold. Raise the threshold above this tiny constant shard and it stays in the\n",
    "session, so the reads become free."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "62a49807",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-06-11T15:27:25.199603Z",
     "iopub.status.busy": "2026-06-11T15:27:25.199315Z",
     "iopub.status.idle": "2026-06-11T15:27:26.666216Z",
     "shell.execute_reply": "2026-06-11T15:27:26.665762Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "inline_threshold=  512 ->     object storage: 64 reads, 1.26s\n",
      "inline_threshold=65535 ->  inline in session: 64 reads, 0.12s\n"
     ]
    }
   ],
   "source": [
    "for threshold, where in [(512, \"object storage\"), (65535, \"inline in session\")]:\n",
    "    seconds, reads, _, _ = fill_shard(DATASETS[\"constant\"], 1, use_sharding=True, inline_threshold_bytes=threshold)\n",
    "    print(f\"inline_threshold={threshold:>5} -> {where:>18}: {reads} reads, {seconds:.2f}s\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d0ba1cc",
   "metadata": {},
   "source": [
    "The read count is identical either way; only the destination changes. The\n",
    "threshold caps at 64 KiB, so this isolates the cause rather than offering a fix\n",
    "for real-sized shards."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e5b62a7",
   "metadata": {},
   "source": [
    "## The curves\n",
    "\n",
    "Sharded versus unsharded across write granularity. The two cross: sharding wins\n",
    "when handed whole shards (one object write, no reads) and loses when fed small\n",
    "pieces (an extra read per partial write)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "6e05dcc2",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-06-11T15:27:26.668016Z",
     "iopub.status.busy": "2026-06-11T15:27:26.667918Z",
     "iopub.status.idle": "2026-06-11T15:27:26.775138Z",
     "shell.execute_reply": "2026-06-11T15:27:26.774642Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots()\n",
    "for label, sweep, marker in [(\"sharded\", sharded, \"o\"), (\"unsharded\", unsharded, \"s\")]:\n",
    "    means = [sweep[n][0].mean() for n in GRANULARITIES]\n",
    "    errors = [sweep[n][0].std() for n in GRANULARITIES]\n",
    "    ax.errorbar(GRANULARITIES, means, yerr=errors, marker=marker, capsize=3, label=label)\n",
    "ax.set_xscale(\"log\", base=2)\n",
    "ax.set_xticks(GRANULARITIES)\n",
    "ax.set_xticklabels([str(n) for n in GRANULARITIES])\n",
    "ax.xaxis.set_minor_formatter(NullFormatter())\n",
    "ax.set_xlabel(\"inner chunks per write (64 = whole shard)\")\n",
    "ax.set_ylabel(\"time to fill one shard (seconds)\")\n",
    "ax.set_title(f\"Filling one shard, {LATENCY_PER_OP_MS}ms/op latency (mean ± sd of {REPEATS} runs)\")\n",
    "ax.legend()\n",
    "ax.grid(True, which=\"both\", alpha=0.3)\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.14.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}