Size and memory benchmarks

make memory       # for calibrating --max-memory

The footprint is an early warning rather than a guarantee. A third of the container memory is a sensible --max-memory: it covers both this 60–75% ratio and compact's 3× peak. Details in Limits.

The compressed columns are filled in only where they mean something: the wasm module and the client are fetched over HTTP, so what the browser pays is 324 KB brotli for both together. A binary you execute and an image whose layers are already compressed are not served that way, hence the dashes.

fenec-server stays on the release profile on purpose: a connection thread that panics unwinds and takes down only its own session, and the server stays up. The cli profile turns panic unwinding into abort, which is right for a single process with nothing to recover.

Where the module's bytes go. make size-report builds the module with its function names kept and puts each function's code where it is written: a method with its impl's module, a closure with its function, and an iterator adapter of the standard library — a fold, an extend — with the closure it runs, which it holds inlined. What is left of the standard library is split by what it is for. make size-report BASE=main shows what a change did against main, down to the ten functions that moved most, and every pull request's CI run shows the same against the branch it goes into.

The data section is another 67.6 KB. Most of the standard library's share is generic code compiled once for each type it is used with, so the module sorts few types and keeps few maps: ids as u64s, scored ids through one comparator that the text index's terms share, rows through one ordering that lookup shares, and a collection's indexes by field in a list rather than a map. That took the sort from eight element types to five and the maps from eleven entry types to seven, 28.5 KB of code; and later the stable sort of ids an in list's buckets went through — merged where their runs end now — and the maps of a database's collections by name and a load's by number, to five, 6.9 KB more. A function inlined into two callers is two copies of itself, and a generic one a copy for each type and closure it is called with: the handles' table each export reached through a closure of its own, build_index and facet inlined twice, the standard library's reading of an integer inlined at each of its three readers, were 8.6 KB, which each took one copy of. Writing a float was 20.8 KB more, Grisu and Dragon behind {}, until the module wrote its own: Ryu's shortest digits, the text {} writes to the byte, in 2.1 KB (num.rs). And 16.5 KB went with a panic's formatting of a char, kept by every slice of a string that could panic, the standard library's to_lowercase, to_uppercase and contains among them: the module slices without, and puts a string in a case through case.rs, character by character, the same text to the byte. The link writes its relocations short (--compress-relocations), 36 KB of padded LEBs, and V8 runs the smaller module faster: near 12%, a page of vectors as JSON 15% (make wasm-speed). make size-report WHY=<pattern> names what pulls a part in.

A page loads a module built with what it uses (A smaller module): make wasm FEATURES="text sorted", FEATURES=indexes or language for a group. make wasm-sizes builds the module with every feature (713.8 KB on disk), with none (432.5 KB), with each added to none and with every one but each, and measures each under gzip -9 and brotli -q 11. The two columns differ where features share code: the sort and the map the sparse index ranks through are the other indexes' too, and the ordered index's chunks are the index over several fields' and @geo's, so sorted left out takes both with it.

What stands in for a missing index is a type no value can have, so the compiler drops the index whole, and the engine's paths through it with it; a fold of no value does the same for nocase, and a function or an aggregate a feature brings is refused by name. A module without a feature opens every file: a collection declaring an index it lacks is answered by the scan, a point is read and written, and a statement over a collection whose nocase or collated field it cannot compare is refused, the feature named. Making these optional cost the module with every feature nothing: its code came out 14 bytes smaller, functions moved and closures renumbered, and its compressed sizes within the noise of a build's layout. Left in every module, measured: json fields and their paths, which would save 0.6 KB brotli, and @ttl, 0.7 KB.

Without the graph a near measures every vector, as near ... exact does in the full module, with the same rows and scores: the scan cost the modules without it 2.2 KB brotli. Measured with make wasm-exact-speed in Node, the median of 50 queries, limit 10, over clustered vectors under cosine:

The full module's exact scan reads its arena, the vectors already made unit ones; without the graph each is read out of its document and made one for the query, four lengths summed side by side, which is the rest of the difference: a near 2 to 40 times slower.