From 7550766f67fee1ed32881c57527572f8df002717 Mon Sep 17 00:00:00 2001 From: Thomas Camlong Date: Mon, 10 Aug 2026 19:05:17 +0200 Subject: [PATCH] perf(media-releases): stop rendering 73 off-screen cards' images and layout Per-widget attribution of the dashboard found one widget responsible for 44% of the board's DOM: mediaReleases at 2,951 nodes and 8,387 fibers, including 1,935 Mantine Box components, against a board total of 9,293 nodes. The cause is that it maps over every release the integrations return, with no cap. Measured on a real board: the tile is 539 px tall and its content is 7,206 px, so of 80 rendered cards only 7 are visible. The other 73 cost DOM, fibers, and - most expensively - a poster and a CSS backdrop image each, all fetched and decoded for pixels nobody can see. Decoded bitmaps are far larger in memory than their files. Fixed with content-visibility: auto plus contain-intrinsic-size on each card, so the browser skips layout, paint, raster and background-image fetch for off-screen cards, and loading="lazy" on the poster. Nothing leaves the DOM, so scrolling and in-page search are unchanged, and the intrinsic size keeps the scrollbar from jumping. Measured over three repeats per side on identical restored data: image requests 135, 135, 135 -> 55, 55, 56 (-59%, deterministic) image bytes 12.27 MiB -> 8.41 MiB (-31%) layout objects 8346, 7815, 7815 -> 5117, 4696, 4636 (-41%) Two things this does NOT show, stated because a single run suggested otherwise: - JS heap did not clearly improve. Across four runs it was 46-88 MiB before against 74-86 MiB after; the before spread is 2x, so no claim either way. This is expected: decoded image memory lives outside JSHeapUsedSize, so the actual saving from 81 fewer image fetches is invisible to that metric. - Task duration and time-to-settled overlap between arms and support no conclusion. Adds the tools this needed: measure-widget-cost.mts (per-widget DOM nodes, fibers and heaviest components), measure-board-paint.mts (image requests, bytes, style/layout/task time, layout objects), measure-widget-overdraw.mjs (rendered versus visible rows). --- .../widgets/src/media-releases/component.tsx | 19 ++- scripts/benchmarks/measure-board-paint.mts | 79 ++++++++++ scripts/benchmarks/measure-widget-cost.mts | 139 ++++++++++++++++++ .../benchmarks/measure-widget-overdraw.mjs | 85 +++++++++++ 4 files changed, 321 insertions(+), 1 deletion(-) create mode 100644 scripts/benchmarks/measure-board-paint.mts create mode 100644 scripts/benchmarks/measure-widget-cost.mts create mode 100644 scripts/benchmarks/measure-widget-overdraw.mjs diff --git a/packages/widgets/src/media-releases/component.tsx b/packages/widgets/src/media-releases/component.tsx index 05ba18fe5..268264ac9 100644 --- a/packages/widgets/src/media-releases/component.tsx +++ b/packages/widgets/src/media-releases/component.tsx @@ -71,6 +71,19 @@ const Item = ({ item, options }: ItemProps) => { rel="noopener noreferrer" pos="relative" p={options.layout === "poster" ? 0 : 4} + style={{ + // This widget maps over every release the integrations return. Measured on a real board: + // 80 cards rendered into a 539 px tile whose content is 7,206 px tall, so 73 of them are + // scrolled out of view — along with their backdrop and poster images, which the browser + // otherwise fetches, decodes and rasterises for pixels nobody can see. + // + // content-visibility lets the browser skip layout, paint and raster for a card that is + // off-screen, and contain-intrinsic-size gives it a placeholder height so the scrollbar + // does not jump as cards enter and leave. Nothing is removed from the DOM, so scrolling + // and in-page search behave exactly as before. + contentVisibility: "auto", + containIntrinsicSize: "auto 88px", + }} > {options.layout === "backdrop" && ( { )} - {options.layout === "poster" && {item.title}} + {options.layout === "poster" && ( + // Only a handful of the rendered cards are on screen; loading the rest's posters + // eagerly costs a request and a decoded bitmap each for no visible benefit. + {item.title} + )} diff --git a/scripts/benchmarks/measure-board-paint.mts b/scripts/benchmarks/measure-board-paint.mts new file mode 100644 index 000000000..52adf6739 --- /dev/null +++ b/scripts/benchmarks/measure-board-paint.mts @@ -0,0 +1,79 @@ +/** + * Measures what off-screen rendering actually costs the browser: image requests, bytes fetched, + * and time spent in style, layout and paint. + * + * DOM node counts and JS heap do not move when `content-visibility` is applied — nothing leaves the + * DOM — so measuring those says nothing about it. What changes is whether the browser fetches, + * decodes and rasterises content that is scrolled out of view, and decoded bitmaps are far larger + * in memory than the files they came from. + * + * STRESS_BASE_URL=http://127.0.0.1:PORT STRESS_BOARD=default \ + * node --experimental-strip-types scripts/benchmarks/measure-board-paint.mts + */ +import { chromium } from "@playwright/test"; + +const baseUrl = process.env.STRESS_BASE_URL; +if (!baseUrl) throw new Error("STRESS_BASE_URL is required"); +const boardName = process.env.STRESS_BOARD ?? "default"; +const settleMs = Number(process.env.PAINT_SETTLE_MS ?? 10_000); + +const browser = await chromium.launch(); +const context = await browser.newContext({ viewport: { width: 1920, height: 1080 } }); +const page = await context.newPage(); + +await page.goto(`${baseUrl}/auth/login`, { waitUntil: "networkidle" }); +await page.getByLabel("Username").fill(process.env.STRESS_USERNAME ?? "demo"); +await page.locator("#password").fill(process.env.STRESS_PASSWORD ?? "demodemo"); +await page.locator("css=button[type='submit']").click(); +await page.waitForFunction(() => !window.location.pathname.includes("/auth/login"), undefined, { timeout: 60_000 }); + +// Count image traffic only for the board navigation, not the login page. +const images: { url: string; bytes: number }[] = []; +page.on("response", (response) => { + const type = response.request().resourceType(); + if (type !== "image") return; + const length = Number(response.headers()["content-length"] ?? 0); + images.push({ url: response.url(), bytes: Number.isFinite(length) ? length : 0 }); +}); + +const client = await context.newCDPSession(page); +await client.send("Performance.enable"); + +const startedAt = Date.now(); +await page.goto(`${baseUrl}/boards/${boardName}`, { waitUntil: "domcontentloaded" }); +await page.locator("[data-homarr-dev-benchmark-board]").waitFor({ state: "attached", timeout: 120_000 }); +await page + .waitForFunction( + () => { + const items = [...document.querySelectorAll('[data-type="item"]')]; + return items.length > 0 && items.every((i) => i.querySelector("[data-homarr-widget-ready],[data-homarr-widget-error]")); + }, + undefined, + { timeout: 120_000 }, + ) + .catch(() => console.log("warn: widgets did not all settle")); +const settledMs = Date.now() - startedAt; + +// Give lazy loading and raster a chance to do (or skip) their work. +await page.waitForTimeout(settleMs); + +const metrics = await client.send("Performance.getMetrics"); +const metric = (name: string) => metrics.metrics.find((entry) => entry.name === name)?.value ?? 0; + +const totalBytes = images.reduce((sum, image) => sum + image.bytes, 0); +const mediaImages = images.filter((image) => /image|poster|backdrop|tmdb|thetvdb|fanart|_next\/image/i.test(image.url)); + +console.log(`\n=== board "${boardName}" ===`); +console.log(` all widgets settled ${settledMs} ms`); +console.log(` image requests ${images.length}`); +console.log(` of those, media artwork ${mediaImages.length}`); +console.log(` image bytes (declared) ${(totalBytes / 1048576).toFixed(2)} MiB`); +console.log(`\n time in style recalc ${(metric("RecalcStyleDuration") * 1000).toFixed(0)} ms`); +console.log(` time in layout ${(metric("LayoutDuration") * 1000).toFixed(0)} ms`); +console.log(` script duration ${(metric("ScriptDuration") * 1000).toFixed(0)} ms`); +console.log(` task duration ${(metric("TaskDuration") * 1000).toFixed(0)} ms`); +console.log(` JS heap used ${(metric("JSHeapUsedSize") / 1048576).toFixed(1)} MiB`); +console.log(` DOM nodes ${metric("Nodes")}`); +console.log(` layout objects ${metric("LayoutObjects")}`); + +await browser.close(); diff --git a/scripts/benchmarks/measure-widget-cost.mts b/scripts/benchmarks/measure-widget-cost.mts new file mode 100644 index 000000000..0f227c1e6 --- /dev/null +++ b/scripts/benchmarks/measure-widget-cost.mts @@ -0,0 +1,139 @@ +/** + * Attributes the dashboard's browser cost to individual widgets: DOM nodes, React fibers, event + * listeners, and how long the page takes to become usable. + * + * Totals alone ("8,280 DOM nodes, 7,784 listeners") do not say what to fix. Per-widget figures do: + * a widget costing 300 nodes is a different problem from one costing 30, and the board renders many + * of each. Listener counts come from CDP's DOMDebugger, which is the only way to read them from + * outside DevTools, sampled per widget kind because it needs a round trip per node. + * + * STRESS_BASE_URL=http://127.0.0.1:PORT STRESS_BOARD=default \ + * node --experimental-strip-types scripts/benchmarks/measure-widget-cost.mts + */ +import { chromium } from "@playwright/test"; + +const baseUrl = process.env.STRESS_BASE_URL; +if (!baseUrl) throw new Error("STRESS_BASE_URL is required"); +const username = process.env.STRESS_USERNAME ?? "demo"; +const password = process.env.STRESS_PASSWORD ?? "demodemo"; +const boardName = process.env.STRESS_BOARD ?? "default"; + +const browser = await chromium.launch(); +const context = await browser.newContext({ viewport: { width: 1920, height: 1080 } }); +const page = await context.newPage(); +const client = await context.newCDPSession(page); +await client.send("Performance.enable"); + +await page.goto(`${baseUrl}/auth/login`, { waitUntil: "networkidle" }); +await page.getByLabel("Username").fill(username); +await page.locator("#password").fill(password); +await page.locator("css=button[type='submit']").click(); +await page.waitForFunction(() => !window.location.pathname.includes("/auth/login"), undefined, { timeout: 60_000 }); + +// Timed from navigation start so "how long until the board is usable" is measured, not guessed. +const startedAt = Date.now(); +await page.goto(`${baseUrl}/boards/${boardName}`, { waitUntil: "domcontentloaded" }); +const domContentLoadedMs = Date.now() - startedAt; +await page.locator("[data-homarr-dev-benchmark-board]").waitFor({ state: "attached", timeout: 120_000 }); +const boardAttachedMs = Date.now() - startedAt; +await page + .waitForFunction( + () => { + const items = [...document.querySelectorAll('[data-type="item"]')]; + return items.length > 0 && items.every((item) => item.querySelector("[data-homarr-widget-ready],[data-homarr-widget-error]")); + }, + undefined, + { timeout: 120_000 }, + ) + .catch(() => console.log("warn: widgets did not all settle")); +const allWidgetsReadyMs = Date.now() - startedAt; + +// Let the render storm settle so counts reflect steady state rather than mid-mount. +await page.waitForTimeout(4_000); + +const perWidget = await page.evaluate(() => { + /** Walks the React fiber subtree hanging off a DOM node, counting fibers and named components. */ + const fiberStats = (element: Element) => { + const key = Object.keys(element).find((name) => name.startsWith("__reactFiber$")); + if (!key) return { fibers: 0, top: [] as [string, number][] }; + const root = (element as unknown as Record)[key] as Record; + const counts = new Map(); + let fibers = 0; + const seen = new Set(); + const stack: (Record | null | undefined)[] = [root]; + while (stack.length) { + const fiber = stack.pop(); + if (!fiber || seen.has(fiber)) continue; + seen.add(fiber); + fibers++; + const type = (fiber.type ?? fiber.elementType) as { displayName?: string; name?: string } | string | null; + const name = + typeof type === "string" + ? `<${type}>` + : type && (type.displayName ?? type.name) + ? (type.displayName ?? type.name)! + : null; + if (name) counts.set(name, (counts.get(name) ?? 0) + 1); + stack.push(fiber.child as never, fiber.sibling as never); + } + return { fibers, top: [...counts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 4) }; + }; + + const byKind = new Map }>(); + for (const item of document.querySelectorAll('[data-type="item"]')) { + const kind = item.getAttribute("data-kind") ?? "(unknown)"; + const nodes = item.querySelectorAll("*").length; + const stats = fiberStats(item); + const acc = byKind.get(kind) ?? { count: 0, nodes: 0, fibers: 0, components: new Map() }; + acc.count++; + acc.nodes += nodes; + acc.fibers += stats.fibers; + for (const [name, n] of stats.top) acc.components.set(name, (acc.components.get(name) ?? 0) + n); + byKind.set(kind, acc); + } + + return { + totalNodes: document.querySelectorAll("*").length, + itemCount: document.querySelectorAll('[data-type="item"]').length, + kinds: [...byKind.entries()] + .map(([kind, acc]) => ({ + kind, + count: acc.count, + nodes: acc.nodes, + fibers: acc.fibers, + nodesEach: Math.round(acc.nodes / acc.count), + fibersEach: Math.round(acc.fibers / acc.count), + components: [...acc.components.entries()].sort((a, b) => b[1] - a[1]).slice(0, 3), + })) + .sort((a, b) => b.nodes - a.nodes), + }; +}); + +const metrics = await client.send("Performance.getMetrics"); +const metric = (name: string) => metrics.metrics.find((entry) => entry.name === name)?.value ?? 0; + +console.log(`\n=== board "${boardName}": load timings ===`); +console.log(` domContentLoaded ${domContentLoadedMs} ms`); +console.log(` board element present ${boardAttachedMs} ms`); +console.log(` all widgets settled ${allWidgetsReadyMs} ms`); + +console.log(`\n=== browser totals ===`); +console.log(` JS heap used ${(metric("JSHeapUsedSize") / 1048576).toFixed(1)} MiB`); +console.log(` JS heap total ${(metric("JSHeapTotalSize") / 1048576).toFixed(1)} MiB`); +console.log(` DOM nodes ${metric("Nodes")} (elements under body: ${perWidget.totalNodes})`); +console.log(` event listeners ${metric("JSEventListeners")}`); +console.log(` documents ${metric("Documents")}`); +console.log(` widgets on board ${perWidget.itemCount}`); + +console.log(`\n=== cost per widget kind, heaviest first ===`); +console.log(`${"nodes".padStart(7)} ${"each".padStart(6)} ${"fibers".padStart(7)} ${"each".padStart(6)} ${"n".padStart(3)} kind / heaviest components`); +for (const kind of perWidget.kinds) { + console.log( + `${String(kind.nodes).padStart(7)} ${String(kind.nodesEach).padStart(6)} ${String(kind.fibers).padStart(7)} ${String(kind.fibersEach).padStart(6)} ${String(kind.count).padStart(3)} ${kind.kind}`, + ); + if (kind.components.length) { + console.log(`${" ".repeat(33)}${kind.components.map(([name, n]) => `${name}×${n}`).join(" ")}`); + } +} + +await browser.close(); diff --git a/scripts/benchmarks/measure-widget-overdraw.mjs b/scripts/benchmarks/measure-widget-overdraw.mjs new file mode 100644 index 000000000..96586698f --- /dev/null +++ b/scripts/benchmarks/measure-widget-overdraw.mjs @@ -0,0 +1,85 @@ +/** + * Rendered rows versus visible rows, per widget. + * + * A dashboard tile shows a handful of rows at a time, but a widget that maps over its whole result + * set renders every row into the DOM regardless. Those off-screen rows cost nodes, fibers and heap + * while painting nothing, and totals like "9,293 DOM nodes" never reveal it — only the ratio does. + * + * Rows are found by looking for the deepest container whose children are numerous and similarly + * sized, rather than by guessing at the markup: widgets nest differently and a fixed selector finds + * nothing. + * + * STRESS_BASE_URL=http://127.0.0.1:PORT node scripts/benchmarks/measure-widget-overdraw.mjs + */ +import { chromium } from "@playwright/test"; + +const baseUrl = process.env.STRESS_BASE_URL; +if (!baseUrl) throw new Error("STRESS_BASE_URL is required"); +const boardName = process.env.STRESS_BOARD ?? "default"; + +const browser = await chromium.launch(); +const context = await browser.newContext({ viewport: { width: 1920, height: 1080 } }); +const page = await context.newPage(); + +await page.goto(`${baseUrl}/auth/login`, { waitUntil: "networkidle" }); +await page.getByLabel("Username").fill(process.env.STRESS_USERNAME ?? "demo"); +await page.locator("#password").fill(process.env.STRESS_PASSWORD ?? "demodemo"); +await page.locator("css=button[type='submit']").click(); +await page.waitForFunction(() => !window.location.pathname.includes("/auth/login"), undefined, { timeout: 60_000 }); +await page.goto(`${baseUrl}/boards/${boardName}`, { waitUntil: "domcontentloaded" }); +await page.locator("[data-homarr-dev-benchmark-board]").waitFor({ state: "attached", timeout: 120_000 }); +await page.waitForTimeout(8_000); + +const result = await page.evaluate(() => { + const report = []; + for (const item of document.querySelectorAll('[data-type="item"]')) { + const kind = item.getAttribute("data-kind") ?? "?"; + const tile = item.getBoundingClientRect(); + + // The repeated-row container is whichever element has the most children that are all roughly + // the same height — that is what a mapped list looks like regardless of wrapper markup. + let best = null; + for (const element of item.querySelectorAll("*")) { + const children = [...element.children]; + if (children.length < 4) continue; + const heights = children.map((c) => c.getBoundingClientRect().height).filter((h) => h > 4); + if (heights.length < 4) continue; + const min = Math.min(...heights); + const max = Math.max(...heights); + if (max > min * 3) continue; // not a uniform list + if (!best || children.length > best.rows) { + best = { rows: children.length, container: element }; + } + } + if (!best) continue; + + const rows = [...best.container.children]; + const visible = rows.filter((row) => { + const r = row.getBoundingClientRect(); + return r.bottom > tile.top && r.top < tile.bottom && r.height > 0; + }); + const nodes = item.querySelectorAll("*").length; + report.push({ + kind, + rows: rows.length, + visibleRows: visible.length, + nodes, + nodesPerRow: Math.round(nodes / rows.length), + wastedNodes: Math.round((nodes / rows.length) * (rows.length - visible.length)), + }); + } + return report.sort((a, b) => b.wastedNodes - a.wastedNodes); +}); + +console.log( + `${"nodes".padStart(6)} ${"rows".padStart(5)} ${"vis".padStart(4)} ${"n/row".padStart(6)} ${"offscreen".padStart(10)} kind`, +); +let wasted = 0; +for (const r of result) { + wasted += r.wastedNodes; + console.log( + `${String(r.nodes).padStart(6)} ${String(r.rows).padStart(5)} ${String(r.visibleRows).padStart(4)} ${String(r.nodesPerRow).padStart(6)} ${String(r.wastedNodes).padStart(10)} ${r.kind}`, + ); +} +console.log(`\nDOM elements rendered for rows that are scrolled out of view: ~${wasted}`); +await browser.close();