Repository navigation
A release of the Python bindings with three performance changes. The wheels still carry the 26.11.1 engine: the engine part of both wheels is identical to the 26.11.1 wheels (identity check on the CI-built wheels and again on the published ones). Parity of the stored and returned values holds on every measured figure.
What changed since 26.11.1.post3
Native GraphBatch.create_vertices sends columns (#390)
A chunk of rows with the same keys in the same order and plain values crosses into the library as typed columns by address, and the new record ids come back in one int64 buffer, instead of one JSON text per chunk and a JSON list of ids. A chunk that the columns cannot carry (other keys or key order, nested lists or maps, a mixed-type column, huge integers) keeps the JSON route, so nothing is lost. ARCADEDB_NATIVE_GB_COLP=0 switches the route off.
| operation | laptop (post4 over post3) | mini (post4 over post3) |
|---|---|---|
native GraphBatch.create_vertices, 100,000 rows, a vector given as a Python list |
0.134 [0.133, 0.135] | 0.118 [0.118, 0.118] |
native GraphBatch.create_vertices, 100,000 rows with an int and a str |
0.778 [0.760, 0.786] | 0.735 [0.734, 0.736] |
native GraphBatch.create_vertices, 100 rows per call, an int and a str |
0.944 [0.911, 0.960] | 0.894 [0.890, 0.901] |
native GraphBatch.create_vertices, 1 row per call |
no claim | 0.885 [0.872, 0.896] |
Native async create_record hands records over in batches (#393)
The async executor collects the records of one type and kind and hands up to 1,000 of them to the library at once as one columnar frame, with a callback and an error callback for every record. A thread of the executor hands a batch over after 50 ms, so a record is not held back.
| operation | laptop (post4 over post3) | mini (post4 over post3) |
|---|---|---|
native async create_record, 100,000 narrow records |
0.166 [0.164, 0.167] | 0.153 [0.150, 0.155] |
native async create_record, 100,000 wide records |
0.210 [0.209, 0.212] | 0.208 [0.206, 0.211] |
native async create_record, 1,000 narrow records |
0.342 [0.339, 0.345] | 0.324 [0.322, 0.326] |
native async create_record with a callback each, 1,000 records |
0.673 [0.668, 0.680] | 0.561 [0.556, 0.568] |
native async create_record with a callback each, 100,000 records |
0.703 [0.700, 0.706] | 0.591 [0.583, 0.599] |
JVM get_rid, get_vertex, get_edge and get_element cross once (#395)
On the JVM wheel each of these made three or four JPype calls; each is now one call into a small Java helper.
| operation | laptop (post4 over post3) | mini (post4 over post3) |
|---|---|---|
JVM Result.get_rid() over 100,000 rows of a vertex type |
0.604 [0.592, 0.622] | 0.599 [0.589, 0.605] |
JVM Result.get_rid() over 100,000 rows of an edge type |
0.616 [0.612, 0.626] | 0.595 [0.591, 0.600] |
JVM Result.get_rid() of 100,000 documents |
0.618 [0.605, 0.630] | 0.596 [0.592, 0.605] |
JVM Result.get_vertex() over 100,000 rows |
0.743 [0.728, 0.767] | 0.738 [0.724, 0.756] |
JVM Result.get_edge() over 100,000 rows |
0.742 [0.727, 0.752] | 0.739 [0.722, 0.763] |
JVM get_rid() of one document |
0.735 [0.699, 0.754] | 0.680 [0.666, 0.688] |
What it costs, stated plainly
- An async executor that receives only about 100 records pays for the per-record counter the batching needs:
n_async_nar_100reads 1.060 [1.055, 1.067] on the laptop and 1.050 [1.045, 1.052] on the mini, that is about 6 percent more time for executors of 100 records. Executors of 1,000 records or more are faster (table above). A linger thread shared by the process would remove this cost (#406). - After a vertex load by the new column route, reads behave differently, measured on the mini with the route switched off in the same wheel for comparison (the diagnostic of 2026-11-16): a point read of one vertex took 1.230 [1.196, 1.248] of the post3 time with the route on and 0.983 [0.976, 0.991] with it off, a read of the neighbours of one vertex 0.774 [0.769, 0.791] with the route on and 0.995 [0.985, 0.998] with it off, and the load itself 0.830 [0.829, 0.834]. If point reads matter more than the load for your workload, set
ARCADEDB_NATIVE_GB_COLP=0. The cause of the read difference is not known yet. - Memory: across 172 measured figures the median peak resident size of post4 over post3 is 1.004, that is no systematic change. The async figures that batch records hold up to 1,000 record copies before they hand them over and use more (for example
n_async_ctl_keys_1k234 to 326 MiB).
Known and open
- #400 stays open until a post4 native wheel has been measured in the single-record
UPDATEcell of the benchmark: the slowdown seen on the published26.11.1.post3native wheel is a property of that build, not of the bindings source (#404). - Candidates that were measured and are not in this release (#389, #391, #392, #394, #396, #397, #398) come back in a later release when they have a figure that is IMPROVED.
Every figure above is the text of a row of the study's score file (the median of the per-round ratios of post4 over post3, with its 95 percent interval, on one laptop and on one mini, both timed with the post3 wheel measured twice as an A/A control); a ratio below 1 means less time. A figure whose interval was too wide to claim is not quoted.
(Edited 2026-11-16: two rows of the JVM table carried the wrong labels. The rows now named get_rid() over vertex and edge rows are the ones first listed as get_vertex() and get_edge(), and the rows for get_vertex() and get_edge() themselves are added.)