Repository navigation
Description
This is the plan and the gates for 26.11.1.post4, the release of all the glue work that follows 26.11.1.post3. The scope is all glue, not only the paths of the benchmark cells: every JSON text that crosses between Java and Python on a bulk or per-row path (#388), and the small per-call overheads that the CRUD audit found. The engine stays byte-identical to 26.11.1, as in post1 to post3.
Candidates, all drafts from the tag 26.11.1.post3, tests first, none of them measured yet: #389 native count(), #390 native create_vertices as a frame, #391 JVM graph_batch typed columns, #392 JVM insert_many typed columns, #393 native async create_record batch, #394 frame kinds for RID and number lists, #395 JVM get_rid readers, #396 JVM new_edge, #397 native reply tail and the dead entry, #398 native approximate vector search by pointer. #390 and #391 come first because the graph loads of the benchmark cells (create_vertices) run through them. I dropped the native columnar head frame (rank 4 of #388): by sizing it saves 0.03 to 0.34 ms per call and needs an API change.
What post3 taught me, and what changes for post4: its timed study had no figure for the exact shape of the benchmark cell that regressed (#400: a single-record UPDATE through command() in a begin and commit pair is about 26 percent slower than on 26.11.1), and it labelled one figure with the wrong auto-transaction mode. So the post4 study has a figure for the operation shape of every benchmark cell that a PR can touch, on both wheels, next to the figures of the PRs, and every figure is checked against the code path that it runs before it is credited to a PR.
Gates, all of them before a tag:
- the full CI matrix (all legs, both wheels) is green on the integration branch, which holds exactly the candidates that go in; the draft pull requests only run the light checks (the heavy legs are skipped on them), so one full run of the branch that ships replaces ten runs of the branches that do not
- a parity digest per figure: the stored data and the returned values are identical between the arms
- a pre-registered timed A/B per candidate against the released post3 wheel (ABBA, A/A control, latency and peak memory), and the figures of the benchmark cells as a regression guard; a candidate with a figure that is slower than post3 stays out
- the integration branch from the tag with the candidates that passed, its CI-built wheels measured as a whole (the gate run, as for post3)
- the same wheels and the published
26.11.1, post2 and post3 measured side by side, solo on the mini, before the cherry-pick tomain(post1 is left out: its native wheel was never published); each candidate marked in or out with the figure that decided it (post4: confirm each candidate solo on the mini against 26.11.1, post2 and post3, then cherry-pick only what passes #405) - the engine identity guard on the CI-built and on the published wheels
- Native: single-record UPDATE through command() is about 26 percent slower on post3 than on 26.11.1 in the l1tpc paper cells #400 is understood, and fixed in post4 or named as open in the release notes
- the docs describe what the tag contains and only the figures that were measured
Resources: CI is the authority for the full matrix. The laptop timed lane runs the A/B studies. The mini builds and tests the branches with Docker while it is idle (the first Java compile does not wait for the shared runner pool) and runs the benchmark cells solo. More timed lanes on the laptop and the mini come after their qualification (tracked in the control plane).
Schedule (estimates, not promises): first compile and test fixes of the candidates on 2026-11-15 and 16; the A/B studies on 2026-11-16 to 18; go or no-go on 2026-11-19; the tag on 2026-11-19 or 20; the mini reruns of the affected benchmark cells (graph loads on both wheels, about 8 hours) on 2026-11-20 and 21; landing on the page and in the paper notes on 2026-11-22 and 23; the paper deadline is 2026-11-24. A candidate that is not ready on the 19th goes into a later release.
Activity
tae898 commentedon Nov 14, 2026
Status of the ten candidates on 2026-11-14, evening. Every branch now has a CI-built wheel at its final head and a pre-registered per-candidate A/B in the timed queue. They wait for the A/A study, which is in its last rounds; it runs the released
26.11.1.post3wheel on both sides and validates the figures, the path probes and the scorer, not any candidate.Five branches had never run their new code in a full CI matrix, and the first matrix found real problems. #391 failed on a stale
tests/test_import_database.pyfrom the tag against the movinglatestengine image (it now takes the file frommain). #392 had a real parity gap: a row holding a NaN, an infinity or a subnormal double stored its whole numbers asIntegerwhere the old route storesLong; fixed in85332a9. #395 called the bridge class in the new getters without the fallback that every other reader has; fixed in84849b5. #393 and #396 had mistakes in their own tests, and the code of both is unchanged. #394 is green on the JVM wheel and on every Linux and macOS job of the native build; its Windows image build failed on a Maven Central fetch and I will re-run it before any merge. A JVM dispatch for an A/B now passes-f arcadedb-tag=26.11.1: the default takes the jars from thelatestimage, which is another engine.One change to the plan comes from #404. The native wheel on PyPI is a rebuild, and two builds of one commit differed by about 32 percent on the single-record
UPDATEin the cell's process state. So the A arm of every native run is the CI-builtpost3wheel, not the published one. A native guard figure that moves by 15 percent or more while the candidate's own figures are flat is flagged BUILD-SUSPECT, and the same commit is built again before the candidate is judged. The release gets a canary on the publishedpost4wheel too, with the cell shape as the figure.The schedule is as before: the per-candidate runs take about eight hours after the A/A study, the integration run follows, and the go or no-go is on 2026-11-19. Related: #404, #400.
tae898 commentedon Nov 15, 2026
Added one gate to the list above: the integration wheels and the published
26.11.1, post1, post2 and post3 measured side by side, solo on the mini, before the cherry-pick tomain(#405). Edits send no notification, so this comment says it.tae898 commentedon Nov 15, 2026
Changed the first gate above: the full CI matrix runs once on the integration branch (the one that ships), not on each of the ten draft branches. The drafts only run the light checks of a pull request (15 heavy legs are skipped on every one of them), so ten full runs would cost most of a day of runner time for branches that never ship as such, and the integration run is the stronger test because it covers the candidates together. A candidate that the integration run implicates still gets its own full run. Edits send no notification, so this comment says it.
Native create_vertices: a chunk of fewer than 64 rows keeps the JSON …
Native async create_record: the first 32 records of an executor go on…
Native create_vertices: the comment of the 64 row floor names the mic…
Tests: a def in the floor test, not an assigned lambda (ruff E731 of …
Native async create_record: a hand-over of fewer than 64 collected re…
Tests: nosec B404 and B603 on the subprocess of the floor-from-enviro…
tae898 commentedon Nov 15, 2026
The in or out rule for the candidates, written before the last verdicts are in (so that no verdict decides its own rule):
Where this stands: #393 and #395 (with its fix) are in unless the re-runs say otherwise; #390 is in if its small-batch fix clears
n_gb_v_1and the guardn_l2_read_pointis not slower on the new build; #389, #391, #392, #396, #397 are pending the mini and the replicates; #394 and #398 are not measured yet.Native async create_record: the first 96 records of an executor go on…
Native async create_record: the first 128 records of an executor go o…
tae898 commentedon Nov 16, 2026
Reading of the mini's integration gate
cand-integration-v5(post4 candidate B against the released post3 wheels A and Z), 2026-11-16 19:11 KST. This is the mini only: the laptop's gate-v5 is still running and decides #390 and the release. Facts fromab-score.md(rounds 0..20, 1386 kept runs, runs without CHECK ok: 0), generated by script from the file:n_gb_veclist_100k0.118 (Native: GraphBatch.create_vertices sends columns and reads the RIDs from an int64 buffer #390),n_async_nar_100k0.153 (Native: async create_record hands records over as columnar frames with per-record callbacks (refs #388, #315) #393),n_async_wide_100k0.208 (Native: async create_record hands records over as columnar frames with per-record callbacks (refs #388, #315) #393),n_async_nar_1k0.324 (Native: async create_record hands records over as columnar frames with per-record callbacks (refs #388, #315) #393).ok, and the digest of the stored and decoded values is the same for A and B on 174 of 174.n_async_nar_1001.050 (1.045, 1.052) (Native: async create_record hands records over as columnar frames with per-record callbacks (refs #388, #315) #393), the known small-executor cost with its waiver; its controln_async_ctl_keys_1k1.052 drifts the same way (CONTROL-DRIFT, voids nothing).n_gb_ctl_nested, reads 0.956: no slow control on the mini.n_l2_read_pointreads 1.230 (1.196, 1.248), marked PATH-FAIL: "probe of arm B: n:string at called 30 times, the row says never". A point read should not have changed. I read it against the laptop's gate and the build-to-build spread of Native wheels of one commit differ in speed: the published 26.11.1.post3 runs the single-record UPDATE about 32 percent slower than the CI build of the same commit #404 before any decision.NO-REGRESSIONis FAIL as a line, because of the PATH-FAIL (the candidate did not exercise the path the figure's row claims; 42 figures, 23 of them JVM targets: not a speed claim) and WEAK figures, not because of a regression.Memory (resource profile of the same file, INFO and never gating, 172 figures): median peak RSS B/A 1.004, median anonymous memory 1.000, so no systematic change; some figures are higher, the largest peaks
n_async_ctl_keys_1k1.39 (234 to 326 MiB),j_rid_ctl_get_100k1.29 (653 to 841 MiB),j_l2_update1.26 (458 to 576 MiB). The async batching of #393 holds up to 1,000 record copies before it hands them over, which is the likely reason for the higher async figures: the release note names it beside the small-executor cost (G8).Foreign load: the laptop's gate ran beside other work on 2026-11-16 (local test gates, a Stateloop build, the owner's use; temperature up to 99 C); the windows are in my local notes and every laptop figure that moved only inside them is not credited and is repeated.
Next: the mini now runs
cand-390fixandcand-393fix; when the laptop's gate ends I read both scores withscore_outliers.py(every row above 1.10 or below 0.90, all roles), then decide #390, then G4, G5 and G8.tae898 commentedon Nov 16, 2026
Reading of the laptop's integration gate
gate-v5(post4 candidate B against the released post3 wheels A and Z), finished 2026-11-16 20:35 KST, generated by script fromab-score.md(rounds 0..20, 1386 kept runs, runs without CHECK ok: 0). The mini's reading is in the comment above.score_outliers.py, every row above 1.10 or below 0.90, all roles).n_gb_ctl_nested, reads 0.960 [0.948, 0.978] here and 0.956 on the mini: on the shipping wheel the 2.2 times of the per-PR wheels is not there on either host (the mini's per-PRcand-390fixwheel reads 2.272 [2.216, 2.285], so that was a property of those per-PR wheels, not of the host).n_gb_veclist_100k0.134 [0.133, 0.135] IMPROVED,n_gb_v_100k0.778 [0.760, 0.786] IMPROVED,n_gb_v_1000.944 [0.911, 0.960] IMPROVED;n_gb_v_10.984 [0.958, 1.078] WEAK (the mini reads it 0.885 IMPROVED).n_async_nar_1001.060 [1.055, 1.067] REGRESSION (the waived small-executor cost), its controln_async_ctl_keys_1k1.082 [1.043, 1.142] drifts the same way; the larger async figures are IMPROVED (n_async_nar_100k0.166 [0.164, 0.167]).j_rid_vertex_100k0.604 [0.592, 0.622],j_rid_edge_100k0.616 [0.612, 0.626]).n_rep_vec_1(a figure of Native: a reply is read with no peek at its tail marker, and the unused arcadedb_command entry point is removed (refs #388) #397, which is out) reads 1.053 [1.039, 1.071] REGRESSION on this wheel; Native: a reply is read with no peek at its tail marker, and the unused arcadedb_command entry point is removed (refs #388) #397 is not in this build, so this is not an effect of Native: a reply is read with no peek at its tail marker, and the unused arcadedb_command entry point is removed (refs #388) #397's code; the mini reads the same figure 0.995 [0.954, 1.015] UNRESOLVED, so it is a laptop-only reading and I treat it as a laptop effect (the figure is of an excluded candidate and is not quoted).n_l2_read_point. Laptop 0.991 [0.973, 1.015] INVALID (the A/A of this figure is out on the laptop: the two copies of the same post3 wheel differ by 22 percent, so the reading is no claim). On the mini it reads 1.230 on three different builds that all contain Native: GraphBatch.create_vertices sends columns and reads the RIDs from an int64 buffer #390 (per-PR wheel 1.261 [1.230, 1.289], integration v4, integration v5), with a clean A/A, and its siblingn_l2_read_hop1reads about 0.78 on the same builds. That does not fit the rule's two clauses (slower on every build, or slower on one build against the build spread), so I am running a diagnostic on the idle mini instead of arguing it: the same shipper wheel with the new route switched off (ARCADEDB_NATIVE_GB_COLP=0), unitn_g_l2only, the registered harness unchanged; what each outcome means is written in my notes before the run (2026-11-16 20:40 KST).Both mini per-candidate runs of the queue finished (rc 0):
cand-390fix(rounds 0..20) andcand-393fix(rounds 0..12); they are evidence for G5 and I read them with the same script.Next: the diagnostic's result decides how I read the guard, then #390 in or out, then G4, G5 and G8 and the release script's dry run. The tag only after that.
tae898 commentedon Nov 16, 2026
Result of the guard diagnostic announced above (written down before it ran, 2026-11-16 20:40 KST; run 2026-11-16 20:40 to 20:44 KST on the idle mini, the registered harness unchanged, unit
n_g_l2only, same shipper wheel e83947e for B, A and Z the CI-built post3 wheel). Numbers by script from the twoab-score.mdfiles. Times are microseconds per operation, B/A below 1 means the candidate is faster.n_l2_create_verticesn_l2_read_pointn_l2_read_hop1n_l2_updaten_l2_deleteWith
ARCADEDB_NATIVE_GB_COLP=0(the new #390 load route off inside the same wheel) every figure of the unit is back at about 1.0, and the A/A of each is within 1.003 of 1 (one of them,n_l2_update, is marked INVALID by the strict rule because its A/A interval [1.001, 1.012] just excludes 1.00). So the new route is what changes them: the L2 load is faster (n_l2_create_vertices0.830), a hop read after it is faster (n_l2_read_hop10.774), and a point read after it is slower (n_l2_read_point1.230). The probe of the route-off run confirms the switch took effect (it reports the column route as never called). The mechanism is not known yet: the read code is unchanged, so it is a state of the process or of the stored records after a load by the new route.By the in or out rule above, a guard slower on every build is a regression and the candidate stays out. This one is a measured trade-off of the candidate, not noise and not a build draw (the second reading of the rule's third clause does not apply), so it is a release decision for the maintainer, with these numbers: native graph loads 1.1 to 8.5 times faster, a hop read after a load 23 percent faster, a point read after a load 23 percent slower (24 to 29 microseconds per read).
Caveats: the route-off run has 10 clean pairs (rounds 0..12, the registered rule stops there when no gating figure is WEAK), against 17 for the gate; it is a diagnostic, none of its figures enters release notes or the paper; I have not looked inside the engine for the mechanism.
Edited the A/A sentence after rereading the score: it was stated as clean for every figure.
tae898 commentedon Nov 16, 2026
The gates for 26.11.1.post4, read by me on 2026-11-16 (H =
e83947e646614bd43f149a8ea0054c8f682dcf11, the head ofpost4/integration-v5-core3; the dry run of the release script prints zero FAIL):gen_post4_figures.py --gateshas no FAIL: parity digests equal and no CHECK failure for every figure of Native: GraphBatch.create_vertices sends columns and reads the RIDs from an int64 buffer #390, Native: async create_record hands records over as columnar frames with per-record callbacks (refs #388, #315) #393 and JVM: get_rid, get_vertex, get_edge and get_element of a row and get_rid of a record cross once each (refs #388) #395; the two slower figures carry a recorded waiver (n_async_nar_100of Native: async create_record hands records over as columnar frames with per-record callbacks (refs #388, #315) #393, the guardn_l2_read_pointof Native: GraphBatch.create_vertices sends columns and reads the RIDs from an int64 buffer #390, with the diagnostic above); the engine identity of the CI-built wheels is recorded (runs 43704188082 and 43704185726 of the same engine part).gate-v5, minicand-integration-v5), results inin-out.jsonfacts.cand-390fix,cand-393fixand the integration gate ran on the same wheels, andcompare_hosts.pycompares them with the laptop; the extra comparison against the PyPI post3 file is not repeated for v5 (the A arm is the CI-built post3 wheel, Native wheels of one commit differ in speed: the published 26.11.1.post3 runs the single-record UPDATE about 32 percent slower than the CI build of the same commit #404).mainwith one Windows Python 3.14 parity test that missed a vector once; the job passed on its re-run, and the intermittent failure is Windows Python 3.14 parity: test_vector_read_your_writes missed 1 of 200 committed vectors once on main (intermittent) #409.Decision of the maintainer role on #390: it goes in with the trade-off named (the owner's decision of 2026-11-16 after the diagnostic). The benchmark paper's cells are not re-run for post4: the A/B leaves the TPC, dense and hybrid cells at about 1.00 and the L2 load about 4 percent faster.
Next:
release_post4.sh --applypushes the two branches and opens the merge pull request; then the tag.tae898 commentedon Nov 16, 2026
26.11.1.post4is released. This is what the gates ended with.e83947e646are JVM: get_rid, get_vertex, get_edge and get_element of a row and get_rid of a record cross once each (refs #388) #395, Native: async create_record hands records over as columnar frames with per-record callbacks (refs #388, #315) #393 and Native: GraphBatch.create_vertices sends columns and reads the RIDs from an int64 buffer #390).26.11.1.post4, release workflows native 43864070180 and JVM 43864070161, both success. Both packages are on PyPI. The release notes carry the figures and the costs.mainwith a merge commit (Merge the 26.11.1.post4 release line into main #410, 44 of 44 checks green after one re-run of the Linux 3.12 leg, which hit the intermittent failure of Windows Python 3.14 parity: test_vector_read_your_writes missed 1 of 200 committed vectors once on main (intermittent) #409). The tag is an ancestor ofmain.post1_identity_check.pyon the published post4 wheels against the published26.11.1wheels:RESULT: engine part identicalforarcadedb-jvmand forarcadedb. Only the expected files differ (the bridge jar, the native library,__version__, the source commit).arcadedb-jvm: 0 FAIL.arcadedb: every download, hash and fresh-install check passes on Python 3.12 and 3.14; the one FAIL line is the script looking for a publish step namedPublish to PyPI, while the native workflow names it after the action (pypa/gh-action-pypi-publish). The job and the step both concluded success. The copy of the script I ran came from the release commit;mainalready has the fix for the unnamed native step (after_tag_verify.sh: find the native publish step #274), so the script itself needs no change.UPDATEcell. The docs pull request follows.(Edited 2026-11-16: the sentence about the after-tag script needing a fix was wrong, see above.)
tae898 commentedon Nov 16, 2026
Correction to my comment above: the after-tag script on
mainalready accepts the unnamed native publish step (5f435e5); only the copy at the release commit was old. I edited the sentence in place.