@delali/narsil 0.3.1-next.86 → 0.3.1-next.88
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/browser/chunk-3GZQKGVQ.mjs +2719 -0
- package/dist/browser/chunk-3ZRMZIH4.mjs +3959 -0
- package/dist/browser/chunk-FHFFWLEK.mjs +669 -0
- package/dist/browser/chunk-HOZW3PKP.mjs +9 -0
- package/dist/browser/chunk-JACCR3BJ.mjs +602 -0
- package/dist/browser/chunk-NQW2YXEX.mjs +346 -0
- package/dist/browser/chunk-RAHUQOJL.mjs +24103 -0
- package/dist/browser/durability-wiring-VSUBLUDK.mjs +3250 -0
- package/dist/browser/module-E25UDADM.mjs +2766 -0
- package/dist/browser/snapshot-5MXBEDXF.mjs +888 -0
- package/dist/browser/write-6SBYTS62.mjs +206 -0
- package/dist/{capabilities-CAdkp2P-.d.ts → capabilities-SJPttcgQ.d.ts} +2 -2
- package/dist/chunk-37CD3OKS.mjs +87 -0
- package/dist/{chunk-4VBG6PEH.mjs → chunk-A3UB2MXL.mjs} +175 -124
- package/dist/{chunk-OLXM65YH.mjs → chunk-AV4IJKD2.mjs} +1 -18
- package/dist/{chunk-LS5IRM23.mjs → chunk-BVOJIYRV.mjs} +2 -25
- package/dist/chunk-C7SLA6CM.mjs +19 -0
- package/dist/chunk-CL4OM7GB.mjs +522 -0
- package/dist/{chunk-KJ7LB3TR.mjs → chunk-CVQWQVFX.mjs} +3 -22
- package/dist/{chunk-4D6OH4EF.mjs → chunk-DCK4P5BI.mjs} +32 -32
- package/dist/chunk-DJHHF2L5.mjs +17 -0
- package/dist/{chunk-XPK3GB2P.mjs → chunk-EMXAYPTQ.mjs} +1776 -3336
- package/dist/chunk-FGMGUDHX.mjs +21 -0
- package/dist/{chunk-2453RJYK.mjs → chunk-J2BPXTD7.mjs} +167 -176
- package/dist/chunk-L5ORED7V.mjs +25 -0
- package/dist/chunk-MWJIAREY.mjs +614 -0
- package/dist/chunk-MXS5HWIH.mjs +515 -0
- package/dist/chunk-P36MUFEJ.mjs +10 -0
- package/dist/chunk-PR4O7CAP.mjs +18 -0
- package/dist/{chunk-ZCKPRCYI.mjs → chunk-Q5DC6WAB.mjs} +1 -1
- package/dist/chunk-QAMUC2BJ.mjs +1730 -0
- package/dist/{chunk-NFF5TDRG.mjs → chunk-QZN3MIJ3.mjs} +1 -16
- package/dist/chunk-R6BMMQXH.mjs +7316 -0
- package/dist/chunk-R7OSDAFK.mjs +44 -0
- package/dist/chunk-RVM7AODE.mjs +73 -0
- package/dist/chunk-S4LQDSUL.mjs +462 -0
- package/dist/{chunk-SREPGC6O.mjs → chunk-T6CNO72J.mjs} +1 -1
- package/dist/chunk-UKSUENHK.mjs +997 -0
- package/dist/{chunk-B3F7LZXM.mjs → chunk-ULRPNYAG.mjs} +1220 -2318
- package/dist/{chunk-GNYXCLJS.mjs → chunk-URGLSNKR.mjs} +4 -3
- package/dist/chunk-V7YUSKKZ.mjs +703 -0
- package/dist/chunk-VY4DXZ5P.mjs +631 -0
- package/dist/{chunk-XYDP7CCJ.mjs → chunk-X4SEXL4U.mjs} +54 -14
- package/dist/{chunk-RM6FRYEC.mjs → chunk-XSZVS4S3.mjs} +3 -2
- package/dist/chunk-Y2F66IQJ.mjs +74 -0
- package/dist/chunk-YCJLVNWR.mjs +262 -0
- package/dist/{client-CKUtkLz3.d.ts → client-BMK53IR2.d.ts} +3 -3
- package/dist/client.d.ts +8 -8
- package/dist/{config-CSDEPraV.d.ts → config-BUR-7eVQ.d.ts} +2 -2
- package/dist/{config-BuIkeM5C.d.ts → config-UJx1dyX1.d.ts} +2 -2
- package/dist/direct-executor-EGESD26S.mjs +18 -0
- package/dist/distribution/coordinator/etcd.d.ts +2 -2
- package/dist/distribution/coordinator/in-memory.d.ts +2 -2
- package/dist/distribution.d.ts +8 -8
- package/dist/distribution.mjs +35 -33
- package/dist/durability-wiring-ZLRQU6FG.mjs +2797 -0
- package/dist/{engine-DMNZJAUq.d.ts → engine-9X6W5naj.d.ts} +2 -2
- package/dist/{index-DzONZUKE.d.ts → index-vCMu8OeQ.d.ts} +1 -1
- package/dist/index.browser.mjs +2 -38128
- package/dist/index.d.ts +23 -9
- package/dist/index.mjs +18 -14
- package/dist/{memory-BPKNx9Tl.d.ts → memory-CV9NAxLY.d.ts} +1 -1
- package/dist/module-WIDYIJLY.mjs +1819 -0
- package/dist/partial-words.mjs +5 -3
- package/dist/pattern.mjs +3 -2
- package/dist/persistence/durability/checkpoint-worker.d.ts +1 -1
- package/dist/persistence/durability/checkpoint-worker.mjs +23 -13
- package/dist/react.d.ts +7 -7
- package/dist/{schema-DgyDijhf.d.ts → schema-DtsgmNfU.d.ts} +1 -1
- package/dist/server.d.ts +10 -10
- package/dist/server.mjs +14 -9
- package/dist/snapshot-22CUEYYW.mjs +469 -0
- package/dist/{tasks-DGyz586z.d.ts → tasks-BGaZJyoY.d.ts} +1 -1
- package/dist/{thread-EUUNJNKU.mjs → thread-ZP3UMIZT.mjs} +12 -9
- package/dist/vector/search-worker.d.ts +30 -3
- package/dist/vector/search-worker.mjs +6 -2
- package/dist/workers/entry.mjs +5 -3
- package/dist/write-PXDKPG2R.mjs +233 -0
- package/package.json +17 -8
- package/dist/chunk-IDLP54FH.mjs +0 -15198
- package/dist/direct-executor-SI2QV4YI.mjs +0 -19
- package/dist/simd-DW5AtJ6B.d.ts +0 -41
|
@@ -1,189 +1,11 @@
|
|
|
1
|
-
import {
|
|
2
|
-
import {
|
|
3
|
-
import {
|
|
1
|
+
import { readTrailer, unpackLevels, stageQueryLevels, osqCodeBytes, osqStagedQueryBytes, osqRecordBytes, writeRecord } from './chunk-37CD3OKS.mjs';
|
|
2
|
+
import { stopUsingTheNativeSearchCore, noteFallback, nativeSearchCoreIsEnabled } from './chunk-DJHHF2L5.mjs';
|
|
3
|
+
import { markSimdUnavailable, MAX_WASM_PAGES, WASM_PAGE_BYTES, VECTOR_SCRATCH_SLOTS, UNPLACED_FLAG_CHUNK_ORDINALS, VECTOR_BLOCK_INITIAL_SLOTS, MAX_VECTOR_ORDINALS, VECTOR_STORE_INITIAL_CAPACITY, LOCK_SPIN_ITERATIONS, LOCK_WAIT_SLICE_MS, NATIVE_ATTACH_RETRY_MS, GRAPH_LOCK_WAIT_SLICE_MS, MAX_DOC_ID_TABLE_BYTES } from './chunk-Y2F66IQJ.mjs';
|
|
4
|
+
import { OSQ_STEPS, OSQ_GRID, OSQ_QUERY_BITS, OSQ_REFINE_ROUNDS, OSQ_REFINE_TOLERANCE, OSQ4_NARROW_DIMENSION_LIMIT, DEFAULT_OSQ4_NARROW_OVERSAMPLE, DEFAULT_OVERSAMPLE_BY_BITS, OSQ_LAMBDA } from './chunk-ZJ4CSAB2.mjs';
|
|
5
|
+
import { loadNativeCore } from './chunk-QZN3MIJ3.mjs';
|
|
6
|
+
import { COMPACTION_TOMBSTONE_RATIO, COMPACTION_ABSOLUTE_THRESHOLD, PLACEMENT_ROOM_REQUESTS, MAX_LAYER_CAP, INITIAL_LIST_CAPACITY, DEFAULT_EF_SEARCH, INITIAL_UPPER_SLOTS } from './chunk-KEHK2O6P.mjs';
|
|
4
7
|
import { compareCodePoints } from './chunk-YTJCGKM4.mjs';
|
|
5
8
|
import { NarsilError, ErrorCodes } from './chunk-TPJU7NDJ.mjs';
|
|
6
|
-
import { readSync, closeSync, openSync } from 'fs';
|
|
7
|
-
|
|
8
|
-
// src/vector/constants.ts
|
|
9
|
-
var WASM_PAGE_BYTES = 65536;
|
|
10
|
-
var MAX_WASM_PAGES = 65536;
|
|
11
|
-
var VECTOR_STORE_INITIAL_CAPACITY = 16;
|
|
12
|
-
var VECTOR_BLOCK_INITIAL_SLOTS = 256;
|
|
13
|
-
var DISK_STORAGE_BLOCK_BYTES = 67108864;
|
|
14
|
-
var MAX_VECTOR_ORDINALS = 16777216;
|
|
15
|
-
var UNPLACED_FLAG_CHUNK_ORDINALS = 1024;
|
|
16
|
-
var VECTOR_SCRATCH_SLOTS = 64;
|
|
17
|
-
var SCRATCH_SLOTS_PER_THREAD_POOL = 31;
|
|
18
|
-
var MAX_DOC_ID_TABLE_BYTES = 1073741824;
|
|
19
|
-
var MAX_WORKER_COPIES = 64;
|
|
20
|
-
var VECTOR_SEARCH_TIMEOUT_MS = 3e4;
|
|
21
|
-
var VECTOR_SEARCH_LOAD_TIMEOUT_MS = 3e5;
|
|
22
|
-
var VECTOR_INSERT_TIMEOUT_MS = 6e5;
|
|
23
|
-
var NATIVE_ATTACH_RETRY_MS = 1e3;
|
|
24
|
-
var LOCK_SPIN_ITERATIONS = 128;
|
|
25
|
-
var LOCK_WAIT_SLICE_MS = 20;
|
|
26
|
-
var GRAPH_LOCK_WAIT_SLICE_MS = 1;
|
|
27
|
-
var GRAPH_BUILD_DISPATCH_CHUNK = 64;
|
|
28
|
-
var GRAPH_BUILD_CHUNKS_IN_FLIGHT_PER_WORKER = 2;
|
|
29
|
-
|
|
30
|
-
// src/vector/simd-wasm-binary.ts
|
|
31
|
-
var SIMD_DISTANCE_WASM_BASE64 = "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";
|
|
32
|
-
var SIMD_DISTANCE_SHARED_MEMORY_WASM_BASE64 = "AGFzbQEAAAABIgVgA39/fwF9YAJ/fwF9YAN/f38Bf2ABewF/YAR/f39/AX8CEgEDZW52Bm1lbW9yeQIDAYCABAMPDgABAAACAgMCAgQCBAICB5sBCQtkb3RfcHJvZHVjdAAACW1hZ25pdHVkZQABGnNxdWFyZWRfZXVjbGlkZWFuX2Rpc3RhbmNlAAISZXVjbGlkZWFuX2Rpc3RhbmNlAAMGZG90X3U4AAQJc3FkaXN0X3U4AAUMb3NxX2RvdF9iaXRzAAkRb3NxX2RvdF9iaXRzX3BhaXIACxNvc3FfZG90X25pYmJsZXNfNHg0AA0K2RQOygIEAX8EewF9BH8gAkFwcSEJIAJBfHEhCv0MAAAAAAAAAAAAAAAAAAAAACEEQQAhAwJAA0AgAyAJTw0BIAAgA0ECdGohCyABIANBAnRqIQwgBCAL/QAEACAM/QAEAP3mAf3kASEEIAUgC/0ABBAgDP0ABBD95gH95AEhBSAGIAv9AAQgIAz9AAQg/eYB/eQBIQYgByAL/QAEMCAM/QAEMP3mAf3kASEHIANBEGohAwwACwsCQANAIAMgCk8NASAEIAAgA0ECdGr9AAQAIAEgA0ECdGr9AAQA/eYB/eQBIQQgA0EEaiEDDAALCyAEIAX95AEgBiAH/eQB/eQBIQQgBP0fACAE/R8BkiAE/R8CIAT9HwOSkiEIAkADQCADIAJPDQEgCCAAIANBAnRqKgIAIAEgA0ECdGoqAgCUkiEIIANBAWohAwwACwsgCAupAQQBfwJ7AX0BfyABQXxxIQb9DAAAAAAAAAAAAAAAAAAAAAAhA0EAIQICQANAIAIgBk8NASAAIAJBAnRq/QAEACEEIAMgBCAE/eYB/eQBIQMgAkEEaiECDAALCyAD/R8AIAP9HwGSIAP9HwIgA/0fA5KSIQUCQANAIAIgAU8NASAFIAAgAkECdGoqAgAgACACQQJ0aioCAJSSIQUgAkEBaiECDAALCyAFkQvAAQUBfwJ7AX0BfwF9IAJBfHEhB/0MAAAAAAAAAAAAAAAAAAAAACEEQQAhAwJAA0AgAyAHTw0BIAAgA0ECdGr9AAQAIAEgA0ECdGr9AAQA/eUBIQUgBCAFIAX95gH95AEhBCADQQRqIQMMAAsLIAT9HwAgBP0fAZIgBP0fAiAE/R8DkpIhBgJAA0AgAyACTw0BIAAgA0ECdGoqAgAgASADQQJ0aioCAJMhCCAGIAggCJSSIQYgA0EBaiEDDAALCyAGCwsAIAAgASACEAKRC7QBAwF/A3sCfyACQXBxIQhBAP0RIQRBACEDAkADQCADIAhPDQEgACADav0ABAAhBSABIANq/QAEACEGIAQgBf2JASAG/YkB/boB/a4BIQQgBCAF/YoBIAb9igH9ugH9rgEhBCADQRBqIQMMAAsLIAT9GwAgBP0bAWogBP0bAiAE/RsDamohBwJAA0AgAyACTw0BIAcgACADai0AACABIANqLQAAbGohByADQQFqIQMMAAsLIAcLzQEDAX8FewN/IAJBcHEhC0EA/REhBEEAIQMCQANAIAMgC08NASAAIANq/QAEACEFIAEgA2r9AAQAIQYgBf2JASAG/YkB/ZEBIQcgBf2KASAG/YoB/ZEBIQggBCAHIAf9ugH9rgEhBCAEIAggCP26Af2uASEEIANBEGohAwwACwsgBP0bACAE/RsBaiAE/RsCIAT9GwNqaiEJAkADQCADIAJPDQEgACADai0AACABIANqLQAAayEKIAkgCiAKbGohCSADQQFqIQMMAAsLIAkLIQEBeyAA/X8hASAB/RsAIAH9GwFqIAH9GwIgAf0bA2pqC68CAwh/A3sBfyABIAJqIQggCCACaiEJIAkgAmohCiACQXBxIQUCQANAIAMgBU8NASADQYAQaiEGIAYgBUsEQCAFIQYLQQD9ECENA0AgACADav0ABAAhCyALIAogA2r9AAQA/U79YiEMIAwgDP1uIAsgCSADav0ABAD9Tv1i/W4hDCAMIAz9biALIAggA2r9AAQA/U79Yv1uIQwgDCAM/W4gCyABIANq/QAEAP1O/WL9biEMIA0gDP19/Y4BIQ0gA0EQaiEDIAMgBkkNAAsgByANEAZqIQcMAAsLAkADQCADIAJPDQEgACADai0AACEOQQAhBAJAA0AgBEEETw0BIAcgDiABIAIgBGxqIANqLQAAcWkgBHRqIQcgBEEBaiEEDAALCyADQQFqIQMMAAsLIAcLhwMDCH8IewF/IAEgAmohCCAIIAJqIQkgCSACaiEKQQP9DyERIAJBcHEhBQJAA0AgAyAFTw0BIANBgBBqIQYgBiAFSwRAIAUhBgtBAP0QIRIDQCAAIANq/QAEACELIAsgEf1OIQwgC0EC/W0gEf1OIQ0gC0EE/W0gEf1OIQ4gC0EG/W0hDyABIANq/QAEACEQIBIgDCAQ/Z4BIAwgEP2fAf2OAf2OASESIAggA2r9AAQAIRAgEiANIBD9ngEgDSAQ/Z8B/Y4B/Y4BIRIgCSADav0ABAAhECASIA4gEP2eASAOIBD9nwH9jgH9jgEhEiAKIANq/QAEACEQIBIgDyAQ/Z4BIA8gEP2fAf2OAf2OASESIANBEGohAyADIAZJDQALIAcgEhAGaiEHDAALCwJAA0AgAyACTw0BIAAgA2otAAAhE0EAIQQCQANAIARBBE8NASAHIBMgBEEBdHZBA3EgASACIARsaiADai0AAGxqIQcgBEEBaiEEDAALCyADQQFqIQMMAAsLIAcLGwAgA0ECRgR/IAAgASACEAgFIAAgASACEAcLC54BAgR/AXsgAkFwcSEEAkADQCADIARPDQEgA0GAEGohBSAFIARLBEAgBCEFC0EA/RAhBwNAIAcgACADav0ABAAgASADav0ABAD9Tv1i/X39jgEhByADQRBqIQMgAyAFSQ0ACyAGIAcQBmohBgwACwsCQANAIAMgAk8NASAGIAAgA2otAAAgASADai0AAHFpaiEGIANBAWohAwwACwsgBgsbACADQQJGBH8gACABIAIQDAUgACABIAIQCgsL2gIDBH8IewR/QdUAIRFB1QAhEkHVAP0PIQdBqgH9DyEIIAJBcHEhBAJAA0AgAyAETw0BIANB4ANqIQUgBSAESwRAIAQhBQtBAP0PIQ5BAP0PIQxBAP0PIQ0DQCAAIANq/QAEACEJIAEgA2r9AAQAIQogCSAK/U4hCyAOIAv9Yv1uIQ4gDCALIAj9Tv1i/W4hDCANIAkgCkEB/W0gB/1OIApBAf1rIAj9Tv1Q/U79Yv1uIQ0gA0EQaiEDIAMgBUkNAAsgBiAO/X0QBiAM/X0QBkEDbCAN/X0QBkEBdGpqaiEGDAALCwJAA0AgAyACTw0BIAAgA2otAAAhDyABIANqLQAAIRAgBiAPIBFxIBBxaSAPIBFxIBBBAXYgEnFxaUEBdGogD0EBdiAScSAQIBFxcWlBAXQgD0EBdiAScSAQQQF2IBJxcWlBAnRqamohBiADQQFqIQMMAAsLIAYL/AEDA38IewJ/IAJBcHEhBEEP/Q8hDEEA/REhDUEAIQMCQANAIAMgBE8NASAAIANq/QAEACEGIAEgA2r9AAQAIQcgBiAM/U4hCCAGQQT9bSEJIAcgDP1OIQogB0EE/W0hCyANIAggCv2eASAJIAv9ngH9jgH9fyAIIAr9nwEgCSAL/Z8B/Y4B/X/9rgH9rgEhDSADQRBqIQMMAAsLIA39GwAgDf0bAWogDf0bAiAN/RsDamohBQJAA0AgAyACTw0BIAAgA2otAAAhDyABIANqLQAAIQ4gBSAPQQ9xIA5BD3FsIA9BBHYgDkEEdmxqaiEFIANBAWohAwwACwsgBQs=";
|
|
33
|
-
|
|
34
|
-
// src/vector/simd.ts
|
|
35
|
-
var wasmExports = null;
|
|
36
|
-
var f32View = null;
|
|
37
|
-
function decodeBase64(base64) {
|
|
38
|
-
if (typeof Buffer !== "undefined") {
|
|
39
|
-
return new Uint8Array(Buffer.from(base64, "base64"));
|
|
40
|
-
}
|
|
41
|
-
const binary = atob(base64);
|
|
42
|
-
const bytes = new Uint8Array(binary.length);
|
|
43
|
-
for (let i = 0; i < binary.length; i++) {
|
|
44
|
-
bytes[i] = binary.charCodeAt(i);
|
|
45
|
-
}
|
|
46
|
-
return bytes;
|
|
47
|
-
}
|
|
48
|
-
try {
|
|
49
|
-
const bytes = decodeBase64(SIMD_DISTANCE_WASM_BASE64);
|
|
50
|
-
const wasmBuffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
|
|
51
|
-
if (typeof WebAssembly !== "undefined" && typeof WebAssembly.validate === "function" && WebAssembly.validate(wasmBuffer)) {
|
|
52
|
-
const module = new WebAssembly.Module(wasmBuffer);
|
|
53
|
-
const instance = new WebAssembly.Instance(module);
|
|
54
|
-
wasmExports = instance.exports;
|
|
55
|
-
f32View = new Float32Array(wasmExports.memory.buffer);
|
|
56
|
-
}
|
|
57
|
-
} catch {
|
|
58
|
-
wasmExports = null;
|
|
59
|
-
f32View = null;
|
|
60
|
-
}
|
|
61
|
-
var OFFSET_B_BYTES = 16384;
|
|
62
|
-
function ensureMemory(dim) {
|
|
63
|
-
if (!wasmExports || !f32View) return;
|
|
64
|
-
const needed = OFFSET_B_BYTES + dim * 4;
|
|
65
|
-
const currentSize = wasmExports.memory.buffer.byteLength;
|
|
66
|
-
if (needed > currentSize) {
|
|
67
|
-
const pagesNeeded = Math.ceil(needed / 65536);
|
|
68
|
-
const currentPages = currentSize / 65536;
|
|
69
|
-
wasmExports.memory.grow(pagesNeeded - currentPages);
|
|
70
|
-
f32View = new Float32Array(wasmExports.memory.buffer);
|
|
71
|
-
}
|
|
72
|
-
}
|
|
73
|
-
function getF32View() {
|
|
74
|
-
if (!f32View) {
|
|
75
|
-
throw new Error("SIMD memory is not initialized");
|
|
76
|
-
}
|
|
77
|
-
return f32View;
|
|
78
|
-
}
|
|
79
|
-
function copyOneVector(a) {
|
|
80
|
-
getF32View().set(a, 0);
|
|
81
|
-
}
|
|
82
|
-
function copyTwoVectors(a, b) {
|
|
83
|
-
const view = getF32View();
|
|
84
|
-
view.set(a, 0);
|
|
85
|
-
view.set(b, OFFSET_B_BYTES / 4);
|
|
86
|
-
}
|
|
87
|
-
function simdDotProduct(a, b) {
|
|
88
|
-
if (!wasmExports || !f32View) return null;
|
|
89
|
-
ensureMemory(a.length);
|
|
90
|
-
copyTwoVectors(a, b);
|
|
91
|
-
return wasmExports.dot_product(0, OFFSET_B_BYTES, a.length);
|
|
92
|
-
}
|
|
93
|
-
function simdMagnitude(a) {
|
|
94
|
-
if (!wasmExports || !f32View) return null;
|
|
95
|
-
ensureMemory(a.length);
|
|
96
|
-
copyOneVector(a);
|
|
97
|
-
return wasmExports.magnitude(0, a.length);
|
|
98
|
-
}
|
|
99
|
-
function simdSquaredEuclideanDistance(a, b) {
|
|
100
|
-
if (!wasmExports || !f32View) return null;
|
|
101
|
-
ensureMemory(a.length);
|
|
102
|
-
copyTwoVectors(a, b);
|
|
103
|
-
return wasmExports.squared_euclidean_distance(0, OFFSET_B_BYTES, a.length);
|
|
104
|
-
}
|
|
105
|
-
function isSimdAvailable() {
|
|
106
|
-
return wasmExports !== null;
|
|
107
|
-
}
|
|
108
|
-
var arenaModule;
|
|
109
|
-
function getArenaModule() {
|
|
110
|
-
if (arenaModule !== void 0) return arenaModule;
|
|
111
|
-
try {
|
|
112
|
-
const bytes = decodeBase64(SIMD_DISTANCE_WASM_BASE64);
|
|
113
|
-
const wasmBuffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
|
|
114
|
-
if (typeof WebAssembly === "undefined" || typeof WebAssembly.validate !== "function" || !WebAssembly.validate(wasmBuffer)) {
|
|
115
|
-
arenaModule = null;
|
|
116
|
-
return null;
|
|
117
|
-
}
|
|
118
|
-
arenaModule = new WebAssembly.Module(wasmBuffer);
|
|
119
|
-
} catch {
|
|
120
|
-
arenaModule = null;
|
|
121
|
-
}
|
|
122
|
-
return arenaModule;
|
|
123
|
-
}
|
|
124
|
-
function createArenaSimd() {
|
|
125
|
-
try {
|
|
126
|
-
const module = getArenaModule();
|
|
127
|
-
if (module === null) return null;
|
|
128
|
-
const instance = new WebAssembly.Instance(module);
|
|
129
|
-
const exports$1 = instance.exports;
|
|
130
|
-
if (typeof exports$1.dot_u8 !== "function" || typeof exports$1.sqdist_u8 !== "function" || typeof exports$1.osq_dot_nibbles_4x4 !== "function" || typeof exports$1.osq_dot_bits !== "function" || typeof exports$1.osq_dot_bits_pair !== "function" || typeof exports$1.dot_product !== "function" || typeof exports$1.magnitude !== "function" || typeof exports$1.squared_euclidean_distance !== "function" || !(exports$1.memory instanceof WebAssembly.Memory)) {
|
|
131
|
-
return null;
|
|
132
|
-
}
|
|
133
|
-
return exports$1;
|
|
134
|
-
} catch {
|
|
135
|
-
return null;
|
|
136
|
-
}
|
|
137
|
-
}
|
|
138
|
-
var sharedMemoryModule;
|
|
139
|
-
function getSharedMemoryModule() {
|
|
140
|
-
if (sharedMemoryModule !== void 0) return sharedMemoryModule;
|
|
141
|
-
try {
|
|
142
|
-
const bytes = decodeBase64(SIMD_DISTANCE_SHARED_MEMORY_WASM_BASE64);
|
|
143
|
-
const wasmBuffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
|
|
144
|
-
if (typeof WebAssembly === "undefined" || typeof WebAssembly.validate !== "function" || !WebAssembly.validate(wasmBuffer)) {
|
|
145
|
-
sharedMemoryModule = null;
|
|
146
|
-
return null;
|
|
147
|
-
}
|
|
148
|
-
sharedMemoryModule = new WebAssembly.Module(wasmBuffer);
|
|
149
|
-
} catch {
|
|
150
|
-
sharedMemoryModule = null;
|
|
151
|
-
}
|
|
152
|
-
return sharedMemoryModule;
|
|
153
|
-
}
|
|
154
|
-
function createSharedArenaSimd(memory) {
|
|
155
|
-
try {
|
|
156
|
-
const module = getSharedMemoryModule();
|
|
157
|
-
if (module === null) return null;
|
|
158
|
-
const instance = new WebAssembly.Instance(module, { env: { memory } });
|
|
159
|
-
const exports$1 = instance.exports;
|
|
160
|
-
if (typeof exports$1.dot_u8 !== "function" || typeof exports$1.sqdist_u8 !== "function" || typeof exports$1.osq_dot_nibbles_4x4 !== "function" || typeof exports$1.osq_dot_bits !== "function" || typeof exports$1.osq_dot_bits_pair !== "function" || typeof exports$1.dot_product !== "function" || typeof exports$1.magnitude !== "function" || typeof exports$1.squared_euclidean_distance !== "function") {
|
|
161
|
-
return null;
|
|
162
|
-
}
|
|
163
|
-
return {
|
|
164
|
-
memory,
|
|
165
|
-
dot_product: exports$1.dot_product,
|
|
166
|
-
magnitude: exports$1.magnitude,
|
|
167
|
-
squared_euclidean_distance: exports$1.squared_euclidean_distance,
|
|
168
|
-
dot_u8: exports$1.dot_u8,
|
|
169
|
-
sqdist_u8: exports$1.sqdist_u8,
|
|
170
|
-
osq_dot_nibbles_4x4: exports$1.osq_dot_nibbles_4x4,
|
|
171
|
-
osq_dot_bits: exports$1.osq_dot_bits,
|
|
172
|
-
osq_dot_bits_pair: exports$1.osq_dot_bits_pair
|
|
173
|
-
};
|
|
174
|
-
} catch {
|
|
175
|
-
return null;
|
|
176
|
-
}
|
|
177
|
-
}
|
|
178
|
-
function arenaFloat32Distance(simd, byteA, byteB, dimension, metric, magnitudeA, magnitudeB) {
|
|
179
|
-
if (metric === "euclidean") {
|
|
180
|
-
return Math.sqrt(simd.squared_euclidean_distance(byteA, byteB, dimension));
|
|
181
|
-
}
|
|
182
|
-
const dot = simd.dot_product(byteA, byteB, dimension);
|
|
183
|
-
if (metric === "dotProduct") return -dot;
|
|
184
|
-
if (magnitudeA === 0 || magnitudeB === 0) return 1;
|
|
185
|
-
return 1 - dot / (magnitudeA * magnitudeB);
|
|
186
|
-
}
|
|
187
9
|
|
|
188
10
|
// src/vector/shared-buffers/growable.ts
|
|
189
11
|
function sharedMemoryAvailable() {
|
|
@@ -317,1114 +139,1378 @@ function graphShapeOf(header) {
|
|
|
317
139
|
};
|
|
318
140
|
}
|
|
319
141
|
|
|
320
|
-
// src/vector/
|
|
321
|
-
var
|
|
322
|
-
var
|
|
323
|
-
function
|
|
324
|
-
|
|
325
|
-
}
|
|
326
|
-
function computeVectorBlockLayout(dimension, blockBytes2 = BLOCK_MAX_BYTES) {
|
|
327
|
-
const scratchStride = alignUp(dimension * 4);
|
|
328
|
-
const slotsOffset = alignUp(VECTOR_SCRATCH_SLOTS * scratchStride);
|
|
329
|
-
const slotStride = alignUp(dimension * 4);
|
|
142
|
+
// src/vector/hnsw/locks.ts
|
|
143
|
+
var FREE = 0;
|
|
144
|
+
var EXCLUSIVE = -1;
|
|
145
|
+
function openGraphLocks(handles, threadSlot) {
|
|
146
|
+
let words = fixedView(handles.locks, Int32Array);
|
|
330
147
|
return {
|
|
331
|
-
|
|
332
|
-
|
|
333
|
-
|
|
334
|
-
|
|
335
|
-
|
|
148
|
+
threadSlot,
|
|
149
|
+
header: handles.header,
|
|
150
|
+
held: handles.heldLocks,
|
|
151
|
+
words(ord) {
|
|
152
|
+
if (ord < words.length) return words;
|
|
153
|
+
if (ord * 4 >= handles.locks.byteLength) growBufferTo(handles.locks, (ord + 1) * 4);
|
|
154
|
+
words = fixedView(handles.locks, Int32Array);
|
|
155
|
+
return words;
|
|
156
|
+
}
|
|
336
157
|
};
|
|
337
158
|
}
|
|
338
|
-
|
|
339
|
-
|
|
159
|
+
var blockingAllowed = typeof document === "undefined";
|
|
160
|
+
function canWait(words) {
|
|
161
|
+
return blockingAllowed && sharedMemoryAvailable() && words.buffer instanceof SharedArrayBuffer;
|
|
340
162
|
}
|
|
341
|
-
function
|
|
342
|
-
|
|
163
|
+
function waitOn(words, index, seen, sliceMs = LOCK_WAIT_SLICE_MS) {
|
|
164
|
+
if (!canWait(words)) return;
|
|
165
|
+
Atomics.wait(words, index, seen, sliceMs);
|
|
343
166
|
}
|
|
344
|
-
function
|
|
345
|
-
|
|
346
|
-
try {
|
|
347
|
-
const memory = new WebAssembly.Memory({ initial: pages, maximum: MAX_WASM_PAGES, shared: true });
|
|
348
|
-
return createSharedArenaSimd(memory) === null ? null : memory;
|
|
349
|
-
} catch {
|
|
350
|
-
return null;
|
|
351
|
-
}
|
|
167
|
+
function heldIndex(locks, kind) {
|
|
168
|
+
return locks.threadSlot * HELD_WORDS_PER_THREAD + kind;
|
|
352
169
|
}
|
|
353
|
-
function
|
|
354
|
-
|
|
355
|
-
|
|
356
|
-
|
|
357
|
-
|
|
358
|
-
|
|
359
|
-
|
|
360
|
-
|
|
361
|
-
|
|
170
|
+
function acquireExclusive(words, index) {
|
|
171
|
+
let spins = 0;
|
|
172
|
+
for (; ; ) {
|
|
173
|
+
const seen = Atomics.compareExchange(words, index, FREE, EXCLUSIVE);
|
|
174
|
+
if (seen === FREE) return;
|
|
175
|
+
if (spins < LOCK_SPIN_ITERATIONS) {
|
|
176
|
+
spins += 1;
|
|
177
|
+
continue;
|
|
178
|
+
}
|
|
179
|
+
waitOn(words, index, seen, GRAPH_LOCK_WAIT_SLICE_MS);
|
|
362
180
|
}
|
|
363
|
-
return { layout, storage: { kind: "bytes", buffer: createGrowableBuffer(initialBytes, fullBlockBytes(layout)) } };
|
|
364
|
-
}
|
|
365
|
-
function fullBlockBytes(layout) {
|
|
366
|
-
return Math.min(BLOCK_MAX_BYTES, layout.slotsOffset + layout.capacity * layout.slotStride);
|
|
367
181
|
}
|
|
368
|
-
function
|
|
369
|
-
|
|
370
|
-
if (
|
|
371
|
-
memory.grow(pagesFor(nextGrowthTarget(have, bytes, fullBlockBytes(layout))) - have / WASM_PAGE_BYTES);
|
|
182
|
+
function releaseExclusive(words, index) {
|
|
183
|
+
Atomics.store(words, index, FREE);
|
|
184
|
+
if (canWait(words)) Atomics.notify(words, index);
|
|
372
185
|
}
|
|
373
|
-
|
|
374
|
-
|
|
375
|
-
|
|
376
|
-
|
|
377
|
-
|
|
378
|
-
|
|
186
|
+
var WRITE_HELD = 1;
|
|
187
|
+
var WRITER_WAITING = 2;
|
|
188
|
+
var VERSION_STEP = 4;
|
|
189
|
+
function beginNodeRead(locks, ord) {
|
|
190
|
+
const words = locks.words(ord);
|
|
191
|
+
for (; ; ) {
|
|
192
|
+
const seen = Atomics.load(words, ord);
|
|
193
|
+
if ((seen & WRITE_HELD) === 0) return seen;
|
|
379
194
|
}
|
|
380
|
-
growMemoryTo(storage.kind === "shared-memory" ? storage.memory : storage.simd.memory, bytes, handle.layout);
|
|
381
|
-
}
|
|
382
|
-
function blockBuffer(handle) {
|
|
383
|
-
const storage = handle.storage;
|
|
384
|
-
if (storage.kind === "bytes") return storage.buffer;
|
|
385
|
-
return storage.kind === "shared-memory" ? storage.memory.buffer : storage.simd.memory.buffer;
|
|
386
195
|
}
|
|
387
|
-
|
|
388
|
-
|
|
389
|
-
|
|
390
|
-
const { layout, storage } = handle;
|
|
391
|
-
const simd = storage.kind === "shared-memory" ? createSharedArenaSimd(storage.memory) : storage.kind === "private-memory" ? storage.simd : null;
|
|
392
|
-
const hasScratch = simd !== null && threadSlot >= 0 && threadSlot < VECTOR_SCRATCH_SLOTS;
|
|
393
|
-
const scratchSlot = hasScratch ? threadSlot : 0;
|
|
394
|
-
let float32View;
|
|
395
|
-
let byteView;
|
|
396
|
-
let dataView;
|
|
397
|
-
function rebindViews() {
|
|
398
|
-
const buffer = blockBuffer(handle);
|
|
399
|
-
float32View = fixedView(buffer, Float32Array);
|
|
400
|
-
byteView = fixedView(buffer, Uint8Array);
|
|
401
|
-
dataView = new DataView(buffer, 0, byteView.length);
|
|
402
|
-
}
|
|
403
|
-
rebindViews();
|
|
404
|
-
return {
|
|
405
|
-
handle,
|
|
406
|
-
simd,
|
|
407
|
-
hasScratch,
|
|
408
|
-
scratchByteOffset: scratchSlot * layout.scratchStride,
|
|
409
|
-
stagedOrdinal: NOTHING_STAGED,
|
|
410
|
-
float32(neededLength) {
|
|
411
|
-
if (neededLength > float32View.length) rebindViews();
|
|
412
|
-
return float32View;
|
|
413
|
-
},
|
|
414
|
-
bytes(neededLength) {
|
|
415
|
-
if (neededLength > byteView.length) rebindViews();
|
|
416
|
-
return byteView;
|
|
417
|
-
},
|
|
418
|
-
data(neededLength) {
|
|
419
|
-
if (neededLength > byteView.length) rebindViews();
|
|
420
|
-
return dataView;
|
|
421
|
-
}
|
|
422
|
-
};
|
|
423
|
-
}
|
|
424
|
-
function slotByteOffset(layout, localOrdinal) {
|
|
425
|
-
return layout.slotsOffset + localOrdinal * layout.slotStride;
|
|
196
|
+
function nodeReadHeld(locks, ord, version) {
|
|
197
|
+
Atomics.add(locks.held, heldIndex(locks, HELD_FENCE), 0);
|
|
198
|
+
return Atomics.load(locks.words(ord), ord) === version;
|
|
426
199
|
}
|
|
427
|
-
|
|
428
|
-
|
|
429
|
-
|
|
430
|
-
for (
|
|
431
|
-
|
|
432
|
-
|
|
433
|
-
|
|
434
|
-
|
|
435
|
-
|
|
200
|
+
function lockNodeWrite(locks, ord) {
|
|
201
|
+
const words = locks.words(ord);
|
|
202
|
+
let spins = 0;
|
|
203
|
+
for (; ; ) {
|
|
204
|
+
const seen = Atomics.load(words, ord);
|
|
205
|
+
if ((seen & WRITE_HELD) === 0) {
|
|
206
|
+
const claimed = seen | WRITE_HELD;
|
|
207
|
+
if (Atomics.compareExchange(words, ord, seen, claimed) === seen) {
|
|
208
|
+
Atomics.store(locks.held, heldIndex(locks, HELD_WRITE_VERSION), claimed);
|
|
209
|
+
Atomics.store(locks.held, heldIndex(locks, HELD_WRITE), ord + 1);
|
|
210
|
+
return;
|
|
211
|
+
}
|
|
212
|
+
continue;
|
|
213
|
+
}
|
|
214
|
+
if (spins < LOCK_SPIN_ITERATIONS) {
|
|
215
|
+
spins += 1;
|
|
216
|
+
continue;
|
|
217
|
+
}
|
|
218
|
+
const waiting = seen | WRITER_WAITING;
|
|
219
|
+
if (waiting === seen || Atomics.compareExchange(words, ord, seen, waiting) === seen) {
|
|
220
|
+
waitOn(words, ord, waiting);
|
|
221
|
+
}
|
|
436
222
|
}
|
|
437
|
-
POPCOUNT[value] = count;
|
|
438
223
|
}
|
|
439
|
-
|
|
440
|
-
|
|
441
|
-
|
|
442
|
-
|
|
443
|
-
for (let n = 0; n < bytes; n++) {
|
|
444
|
-
const left = a[aOffset + n];
|
|
445
|
-
const right = b[bOffset + n];
|
|
446
|
-
total += (left & 15) * (right & 15) + (left >> 4) * (right >> 4);
|
|
447
|
-
}
|
|
448
|
-
return total;
|
|
224
|
+
function releaseWrite(words, ord) {
|
|
225
|
+
const seen = Atomics.load(words, ord);
|
|
226
|
+
const previous = Atomics.exchange(words, ord, (seen & -4) + VERSION_STEP);
|
|
227
|
+
if ((previous & WRITER_WAITING) !== 0 && canWait(words)) Atomics.notify(words, ord);
|
|
449
228
|
}
|
|
450
|
-
function
|
|
451
|
-
|
|
452
|
-
|
|
453
|
-
|
|
454
|
-
|
|
455
|
-
|
|
229
|
+
function unlockNodeWrite(locks, ord) {
|
|
230
|
+
releaseWrite(locks.words(ord), ord);
|
|
231
|
+
Atomics.store(locks.held, heldIndex(locks, HELD_WRITE), 0);
|
|
232
|
+
}
|
|
233
|
+
function lockGraphShared(locks) {
|
|
234
|
+
const { header } = locks;
|
|
235
|
+
let spins = 0;
|
|
236
|
+
for (; ; ) {
|
|
237
|
+
const seen = Atomics.load(header, GRAPH_LOCK);
|
|
238
|
+
if (seen >= FREE && Atomics.load(header, GRAPH_WRITERS_WAITING) === 0) {
|
|
239
|
+
if (Atomics.compareExchange(header, GRAPH_LOCK, seen, seen + 1) === seen) {
|
|
240
|
+
Atomics.store(locks.held, heldIndex(locks, HELD_GRAPH), 1);
|
|
241
|
+
return;
|
|
242
|
+
}
|
|
243
|
+
continue;
|
|
244
|
+
}
|
|
245
|
+
if (spins < LOCK_SPIN_ITERATIONS) {
|
|
246
|
+
spins += 1;
|
|
247
|
+
continue;
|
|
456
248
|
}
|
|
249
|
+
waitOn(header, GRAPH_LOCK, seen, GRAPH_LOCK_WAIT_SLICE_MS);
|
|
457
250
|
}
|
|
458
|
-
return total;
|
|
459
251
|
}
|
|
460
|
-
function
|
|
461
|
-
|
|
462
|
-
|
|
463
|
-
|
|
464
|
-
const plane = stagedOffset + p * codeBytes;
|
|
465
|
-
let bitsSet = 0;
|
|
466
|
-
for (let n = 0; n < codeBytes; n++) bitsSet += POPCOUNT[document2[documentOffset + n] & staged[plane + n]];
|
|
467
|
-
total += 2 ** p * bitsSet;
|
|
468
|
-
}
|
|
469
|
-
return total;
|
|
252
|
+
function unlockGraphShared(locks) {
|
|
253
|
+
const { header } = locks;
|
|
254
|
+
Atomics.store(locks.held, heldIndex(locks, HELD_GRAPH), 0);
|
|
255
|
+
if (Atomics.sub(header, GRAPH_LOCK, 1) === 1 && canWait(header)) Atomics.notify(header, GRAPH_LOCK);
|
|
470
256
|
}
|
|
471
|
-
function
|
|
472
|
-
|
|
473
|
-
|
|
474
|
-
|
|
475
|
-
|
|
476
|
-
|
|
477
|
-
|
|
478
|
-
|
|
479
|
-
}
|
|
257
|
+
function lockGraphExclusive(locks) {
|
|
258
|
+
Atomics.store(locks.held, heldIndex(locks, HELD_GRAPH_WAITING), 1);
|
|
259
|
+
Atomics.add(locks.header, GRAPH_WRITERS_WAITING, 1);
|
|
260
|
+
try {
|
|
261
|
+
acquireExclusive(locks.header, GRAPH_LOCK);
|
|
262
|
+
} finally {
|
|
263
|
+
Atomics.sub(locks.header, GRAPH_WRITERS_WAITING, 1);
|
|
264
|
+
Atomics.store(locks.held, heldIndex(locks, HELD_GRAPH_WAITING), 0);
|
|
480
265
|
}
|
|
481
|
-
return total;
|
|
482
|
-
}
|
|
483
|
-
function osqByteLevelProducts(document2, documentOffset, query, queryOffset, dimension) {
|
|
484
|
-
let total = 0;
|
|
485
|
-
for (let i = 0; i < dimension; i++) total += document2[documentOffset + i] * query[queryOffset + i];
|
|
486
|
-
return total;
|
|
487
266
|
}
|
|
488
|
-
function
|
|
489
|
-
|
|
490
|
-
const queryStep = (query.upper - query.lower) / OSQ_STEPS[queryBits];
|
|
491
|
-
const centred = document2.lower * query.lower * dimension + query.lower * documentStep * document2.sum + document2.lower * queryStep * query.sum + documentStep * queryStep * products;
|
|
492
|
-
if (metric === "euclidean") return Math.sqrt(Math.max(0, document2.correction + query.correction - 2 * centred));
|
|
493
|
-
const similarity = centred + document2.correction + query.correction - centroidDot;
|
|
494
|
-
if (metric === "cosine") return Math.min(Math.max(similarity, -1), 1);
|
|
495
|
-
return similarity;
|
|
267
|
+
function unlockGraphExclusive(locks) {
|
|
268
|
+
releaseExclusive(locks.header, GRAPH_LOCK);
|
|
496
269
|
}
|
|
497
|
-
function
|
|
498
|
-
|
|
499
|
-
case "cosine":
|
|
500
|
-
return 1 - estimate;
|
|
501
|
-
case "dotProduct":
|
|
502
|
-
return -estimate;
|
|
503
|
-
case "euclidean":
|
|
504
|
-
return estimate;
|
|
505
|
-
}
|
|
270
|
+
function lockEntry(locks) {
|
|
271
|
+
acquireExclusive(locks.header, GRAPH_ENTRY_LOCK);
|
|
506
272
|
}
|
|
507
|
-
function
|
|
508
|
-
|
|
273
|
+
function unlockEntry(locks) {
|
|
274
|
+
releaseExclusive(locks.header, GRAPH_ENTRY_LOCK);
|
|
509
275
|
}
|
|
510
|
-
|
|
511
|
-
|
|
512
|
-
|
|
513
|
-
|
|
514
|
-
|
|
515
|
-
|
|
516
|
-
var TRAILER_SUM = 12;
|
|
517
|
-
var QUERY_PLANES_FOR_NARROW_CODES = 4;
|
|
518
|
-
var LEVELS_IN_A_TWO_BIT_BYTE = 4;
|
|
519
|
-
function osqCodeBytes(dimension, bits) {
|
|
520
|
-
return Math.ceil(dimension * bits / 8);
|
|
521
|
-
}
|
|
522
|
-
function osqRecordBytes(dimension, bits) {
|
|
523
|
-
return osqCodeBytes(dimension, bits) + OSQ_RECORD_TRAILER_BYTES;
|
|
524
|
-
}
|
|
525
|
-
function packLevels(levels, bits, target, offset) {
|
|
526
|
-
const dimension = levels.length;
|
|
527
|
-
if (bits === 8) {
|
|
528
|
-
target.set(levels, offset);
|
|
529
|
-
return;
|
|
276
|
+
function releaseLocksHeldBy(handles, threadSlot) {
|
|
277
|
+
const held = handles.heldLocks;
|
|
278
|
+
const words = new Int32Array(handles.locks);
|
|
279
|
+
const base = threadSlot * HELD_WORDS_PER_THREAD;
|
|
280
|
+
if (Atomics.exchange(held, base + HELD_GRAPH_WAITING, 0) === 1) {
|
|
281
|
+
Atomics.sub(handles.header, GRAPH_WRITERS_WAITING, 1);
|
|
530
282
|
}
|
|
531
|
-
const
|
|
532
|
-
|
|
533
|
-
|
|
534
|
-
const
|
|
535
|
-
if (
|
|
536
|
-
|
|
283
|
+
const writeOrd = Atomics.exchange(held, base + HELD_WRITE, 0) - 1;
|
|
284
|
+
const writeVersion = Atomics.load(held, base + HELD_WRITE_VERSION);
|
|
285
|
+
if (writeOrd >= 0 && writeOrd < words.length) {
|
|
286
|
+
const seen = Atomics.load(words, writeOrd);
|
|
287
|
+
if ((seen & ~WRITER_WAITING) === writeVersion) releaseWrite(words, writeOrd);
|
|
288
|
+
}
|
|
289
|
+
if (Atomics.exchange(held, base + HELD_GRAPH, 0) !== 1) return;
|
|
290
|
+
for (; ; ) {
|
|
291
|
+
const readers = Atomics.load(handles.header, GRAPH_LOCK);
|
|
292
|
+
if (readers <= FREE) return;
|
|
293
|
+
if (Atomics.compareExchange(handles.header, GRAPH_LOCK, readers, readers - 1) === readers) {
|
|
294
|
+
if (canWait(handles.header)) Atomics.notify(handles.header, GRAPH_LOCK);
|
|
295
|
+
return;
|
|
296
|
+
}
|
|
537
297
|
}
|
|
538
298
|
}
|
|
539
|
-
|
|
540
|
-
|
|
541
|
-
|
|
542
|
-
|
|
543
|
-
|
|
299
|
+
|
|
300
|
+
// src/vector/simd-wasm-binary.ts
|
|
301
|
+
var SIMD_DISTANCE_WASM_BASE64 = "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";
|
|
302
|
+
var SIMD_DISTANCE_SHARED_MEMORY_WASM_BASE64 = "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";
|
|
303
|
+
|
|
304
|
+
// src/vector/simd.ts
|
|
305
|
+
var wasmExports = null;
|
|
306
|
+
var f32View = null;
|
|
307
|
+
function decodeBase64(base64) {
|
|
308
|
+
if (typeof Buffer !== "undefined") {
|
|
309
|
+
return new Uint8Array(Buffer.from(base64, "base64"));
|
|
544
310
|
}
|
|
545
|
-
const
|
|
546
|
-
const
|
|
547
|
-
for (let i = 0; i <
|
|
548
|
-
|
|
311
|
+
const binary = atob(base64);
|
|
312
|
+
const bytes = new Uint8Array(binary.length);
|
|
313
|
+
for (let i = 0; i < binary.length; i++) {
|
|
314
|
+
bytes[i] = binary.charCodeAt(i);
|
|
549
315
|
}
|
|
550
|
-
return
|
|
551
|
-
}
|
|
552
|
-
function osqStagedQueryBytes(dimension, documentBits) {
|
|
553
|
-
if (documentBits === 8) return dimension;
|
|
554
|
-
if (documentBits === 4) return osqCodeBytes(dimension, 4);
|
|
555
|
-
return QUERY_PLANES_FOR_NARROW_CODES * osqCodeBytes(dimension, documentBits);
|
|
316
|
+
return bytes;
|
|
556
317
|
}
|
|
557
|
-
|
|
558
|
-
|
|
559
|
-
|
|
560
|
-
|
|
318
|
+
try {
|
|
319
|
+
const bytes = decodeBase64(SIMD_DISTANCE_WASM_BASE64);
|
|
320
|
+
const wasmBuffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
|
|
321
|
+
if (typeof WebAssembly !== "undefined" && typeof WebAssembly.validate === "function" && WebAssembly.validate(wasmBuffer)) {
|
|
322
|
+
const module = new WebAssembly.Module(wasmBuffer);
|
|
323
|
+
const instance = new WebAssembly.Instance(module);
|
|
324
|
+
wasmExports = instance.exports;
|
|
325
|
+
f32View = new Float32Array(wasmExports.memory.buffer);
|
|
561
326
|
}
|
|
562
|
-
|
|
563
|
-
|
|
564
|
-
|
|
565
|
-
|
|
566
|
-
|
|
567
|
-
|
|
568
|
-
|
|
327
|
+
} catch {
|
|
328
|
+
wasmExports = null;
|
|
329
|
+
f32View = null;
|
|
330
|
+
}
|
|
331
|
+
if (wasmExports === null) markSimdUnavailable();
|
|
332
|
+
var OFFSET_B_BYTES = 16384;
|
|
333
|
+
function ensureMemory(dim) {
|
|
334
|
+
if (!wasmExports || !f32View) return;
|
|
335
|
+
const needed = OFFSET_B_BYTES + dim * 4;
|
|
336
|
+
const currentSize = wasmExports.memory.buffer.byteLength;
|
|
337
|
+
if (needed > currentSize) {
|
|
338
|
+
const pagesNeeded = Math.ceil(needed / 65536);
|
|
339
|
+
const currentPages = currentSize / 65536;
|
|
340
|
+
wasmExports.memory.grow(pagesNeeded - currentPages);
|
|
341
|
+
f32View = new Float32Array(wasmExports.memory.buffer);
|
|
569
342
|
}
|
|
570
|
-
|
|
571
|
-
|
|
572
|
-
|
|
573
|
-
|
|
574
|
-
const bit = 1 << (i & 7);
|
|
575
|
-
for (let plane = 0; plane < QUERY_PLANES_FOR_NARROW_CODES; plane++) {
|
|
576
|
-
if (value >> plane & 1) target[plane * planeBytes + byte] |= bit;
|
|
577
|
-
}
|
|
343
|
+
}
|
|
344
|
+
function getF32View() {
|
|
345
|
+
if (!f32View) {
|
|
346
|
+
throw new Error("SIMD memory is not initialized");
|
|
578
347
|
}
|
|
348
|
+
return f32View;
|
|
579
349
|
}
|
|
580
|
-
function
|
|
581
|
-
|
|
582
|
-
const at = offset + osqCodeBytes(code.levels.length, bits);
|
|
583
|
-
trailer.setFloat32(at + TRAILER_LOWER, code.lower, true);
|
|
584
|
-
trailer.setFloat32(at + TRAILER_UPPER, code.upper, true);
|
|
585
|
-
trailer.setFloat32(at + TRAILER_CORRECTION, code.correction, true);
|
|
586
|
-
trailer.setUint32(at + TRAILER_SUM, code.sum, true);
|
|
350
|
+
function copyOneVector(a) {
|
|
351
|
+
getF32View().set(a, 0);
|
|
587
352
|
}
|
|
588
|
-
function
|
|
589
|
-
const
|
|
590
|
-
|
|
591
|
-
|
|
592
|
-
into.correction = trailer.getFloat32(at + TRAILER_CORRECTION, true);
|
|
593
|
-
into.sum = trailer.getUint32(at + TRAILER_SUM, true);
|
|
594
|
-
return into;
|
|
353
|
+
function copyTwoVectors(a, b) {
|
|
354
|
+
const view = getF32View();
|
|
355
|
+
view.set(a, 0);
|
|
356
|
+
view.set(b, OFFSET_B_BYTES / 4);
|
|
595
357
|
}
|
|
596
|
-
|
|
597
|
-
|
|
598
|
-
|
|
599
|
-
|
|
600
|
-
|
|
601
|
-
const queryBytes = osqStagedQueryBytes(dimension, bits);
|
|
602
|
-
const scratchStride = alignUp(queryBytes);
|
|
603
|
-
const slotsOffset = alignUp(VECTOR_SCRATCH_SLOTS * scratchStride);
|
|
604
|
-
const slotStride = osqRecordBytes(dimension, bits);
|
|
605
|
-
return {
|
|
606
|
-
dimension,
|
|
607
|
-
bits,
|
|
608
|
-
queryBits,
|
|
609
|
-
codeBytes,
|
|
610
|
-
queryBytes,
|
|
611
|
-
scratchStride,
|
|
612
|
-
slotsOffset,
|
|
613
|
-
slotStride,
|
|
614
|
-
capacity: Math.floor((BLOCK_MAX_BYTES - slotsOffset) / slotStride)
|
|
615
|
-
};
|
|
358
|
+
function simdDotProduct(a, b) {
|
|
359
|
+
if (!wasmExports || !f32View) return null;
|
|
360
|
+
ensureMemory(a.length);
|
|
361
|
+
copyTwoVectors(a, b);
|
|
362
|
+
return wasmExports.dot_product(0, OFFSET_B_BYTES, a.length);
|
|
616
363
|
}
|
|
617
|
-
|
|
618
|
-
|
|
619
|
-
|
|
620
|
-
|
|
621
|
-
|
|
622
|
-
var STORE_CALIBRATED = 3;
|
|
623
|
-
var STORE_CODE_COUNT = 4;
|
|
624
|
-
var STORE_DOC_ID_BYTES = 5;
|
|
625
|
-
var STORE_CODE_BLOCK_COUNT = 6;
|
|
626
|
-
var STORE_CALIBRATION_GENERATION = 7;
|
|
627
|
-
var STORE_RELEASED_VECTORS_TO_DISK = 8;
|
|
628
|
-
var STORE_UNPLACED_COUNT = 9;
|
|
629
|
-
var STORE_REMOVED_COUNT = 10;
|
|
630
|
-
var STORE_HEADER_WORDS = 16;
|
|
631
|
-
var IN_MEMORY = -1;
|
|
632
|
-
function fixedInt32(words) {
|
|
633
|
-
return new Int32Array(createFixedBuffer(words * 4), 0, words);
|
|
364
|
+
function simdMagnitude(a) {
|
|
365
|
+
if (!wasmExports || !f32View) return null;
|
|
366
|
+
ensureMemory(a.length);
|
|
367
|
+
copyOneVector(a);
|
|
368
|
+
return wasmExports.magnitude(0, a.length);
|
|
634
369
|
}
|
|
635
|
-
function
|
|
636
|
-
|
|
370
|
+
function simdSquaredEuclideanDistance(a, b) {
|
|
371
|
+
if (!wasmExports || !f32View) return null;
|
|
372
|
+
ensureMemory(a.length);
|
|
373
|
+
copyTwoVectors(a, b);
|
|
374
|
+
return wasmExports.squared_euclidean_distance(0, OFFSET_B_BYTES, a.length);
|
|
637
375
|
}
|
|
638
|
-
|
|
639
|
-
|
|
376
|
+
var arenaModule;
|
|
377
|
+
function getArenaModule() {
|
|
378
|
+
if (arenaModule !== void 0) return arenaModule;
|
|
379
|
+
try {
|
|
380
|
+
const bytes = decodeBase64(SIMD_DISTANCE_WASM_BASE64);
|
|
381
|
+
const wasmBuffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
|
|
382
|
+
if (typeof WebAssembly === "undefined" || typeof WebAssembly.validate !== "function" || !WebAssembly.validate(wasmBuffer)) {
|
|
383
|
+
arenaModule = null;
|
|
384
|
+
return null;
|
|
385
|
+
}
|
|
386
|
+
arenaModule = new WebAssembly.Module(wasmBuffer);
|
|
387
|
+
} catch {
|
|
388
|
+
arenaModule = null;
|
|
389
|
+
}
|
|
390
|
+
return arenaModule;
|
|
640
391
|
}
|
|
641
|
-
function
|
|
642
|
-
|
|
643
|
-
|
|
644
|
-
(
|
|
645
|
-
|
|
392
|
+
function createArenaSimd() {
|
|
393
|
+
try {
|
|
394
|
+
const module = getArenaModule();
|
|
395
|
+
if (module === null) return null;
|
|
396
|
+
const instance = new WebAssembly.Instance(module);
|
|
397
|
+
const exports$1 = instance.exports;
|
|
398
|
+
if (typeof exports$1.dot_u8 !== "function" || typeof exports$1.sqdist_u8 !== "function" || typeof exports$1.osq_dot_nibbles_4x4 !== "function" || typeof exports$1.osq_dot_bits !== "function" || typeof exports$1.osq_dot_bits_pair !== "function" || typeof exports$1.dot_product !== "function" || typeof exports$1.magnitude !== "function" || typeof exports$1.squared_euclidean_distance !== "function" || !(exports$1.memory instanceof WebAssembly.Memory)) {
|
|
399
|
+
return null;
|
|
400
|
+
}
|
|
401
|
+
return exports$1;
|
|
402
|
+
} catch {
|
|
403
|
+
return null;
|
|
404
|
+
}
|
|
646
405
|
}
|
|
647
|
-
|
|
648
|
-
|
|
649
|
-
|
|
650
|
-
|
|
406
|
+
var sharedMemoryModule;
|
|
407
|
+
function getSharedMemoryModule() {
|
|
408
|
+
if (sharedMemoryModule !== void 0) return sharedMemoryModule;
|
|
409
|
+
try {
|
|
410
|
+
const bytes = decodeBase64(SIMD_DISTANCE_SHARED_MEMORY_WASM_BASE64);
|
|
411
|
+
const wasmBuffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
|
|
412
|
+
if (typeof WebAssembly === "undefined" || typeof WebAssembly.validate !== "function" || !WebAssembly.validate(wasmBuffer)) {
|
|
413
|
+
sharedMemoryModule = null;
|
|
414
|
+
return null;
|
|
415
|
+
}
|
|
416
|
+
sharedMemoryModule = new WebAssembly.Module(wasmBuffer);
|
|
417
|
+
} catch {
|
|
418
|
+
sharedMemoryModule = null;
|
|
419
|
+
}
|
|
420
|
+
return sharedMemoryModule;
|
|
651
421
|
}
|
|
652
|
-
function
|
|
653
|
-
|
|
654
|
-
|
|
655
|
-
|
|
656
|
-
|
|
657
|
-
|
|
658
|
-
|
|
659
|
-
|
|
660
|
-
|
|
661
|
-
|
|
662
|
-
|
|
663
|
-
|
|
664
|
-
|
|
665
|
-
|
|
666
|
-
|
|
667
|
-
|
|
668
|
-
|
|
669
|
-
|
|
670
|
-
|
|
671
|
-
|
|
672
|
-
|
|
673
|
-
|
|
674
|
-
|
|
675
|
-
};
|
|
422
|
+
function createSharedArenaSimd(memory) {
|
|
423
|
+
try {
|
|
424
|
+
const module = getSharedMemoryModule();
|
|
425
|
+
if (module === null) return null;
|
|
426
|
+
const instance = new WebAssembly.Instance(module, { env: { memory } });
|
|
427
|
+
const exports$1 = instance.exports;
|
|
428
|
+
if (typeof exports$1.dot_u8 !== "function" || typeof exports$1.sqdist_u8 !== "function" || typeof exports$1.osq_dot_nibbles_4x4 !== "function" || typeof exports$1.osq_dot_bits !== "function" || typeof exports$1.osq_dot_bits_pair !== "function" || typeof exports$1.dot_product !== "function" || typeof exports$1.magnitude !== "function" || typeof exports$1.squared_euclidean_distance !== "function") {
|
|
429
|
+
return null;
|
|
430
|
+
}
|
|
431
|
+
return {
|
|
432
|
+
memory,
|
|
433
|
+
dot_product: exports$1.dot_product,
|
|
434
|
+
magnitude: exports$1.magnitude,
|
|
435
|
+
squared_euclidean_distance: exports$1.squared_euclidean_distance,
|
|
436
|
+
dot_u8: exports$1.dot_u8,
|
|
437
|
+
sqdist_u8: exports$1.sqdist_u8,
|
|
438
|
+
osq_dot_nibbles_4x4: exports$1.osq_dot_nibbles_4x4,
|
|
439
|
+
osq_dot_bits: exports$1.osq_dot_bits,
|
|
440
|
+
osq_dot_bits_pair: exports$1.osq_dot_bits_pair
|
|
441
|
+
};
|
|
442
|
+
} catch {
|
|
443
|
+
return null;
|
|
444
|
+
}
|
|
676
445
|
}
|
|
677
|
-
function
|
|
678
|
-
|
|
679
|
-
|
|
680
|
-
if (block !== null) bytes += blockBuffer(block).byteLength;
|
|
446
|
+
function arenaFloat32Distance(simd, byteA, byteB, dimension, metric, magnitudeA, magnitudeB) {
|
|
447
|
+
if (metric === "euclidean") {
|
|
448
|
+
return Math.sqrt(simd.squared_euclidean_distance(byteA, byteB, dimension));
|
|
681
449
|
}
|
|
682
|
-
|
|
683
|
-
|
|
684
|
-
|
|
685
|
-
|
|
686
|
-
bytes += handles.unplacedChunks.byteLength;
|
|
687
|
-
bytes += handles.removed.byteLength;
|
|
688
|
-
bytes += handles.partitions.byteLength;
|
|
689
|
-
bytes += handles.docIdBytes.byteLength;
|
|
690
|
-
bytes += handles.docIdOffsets.byteLength;
|
|
691
|
-
bytes += handles.codePresent.byteLength;
|
|
692
|
-
bytes += handles.diskFile.byteLength;
|
|
693
|
-
bytes += handles.diskOffset.byteLength;
|
|
694
|
-
return bytes;
|
|
450
|
+
const dot = simd.dot_product(byteA, byteB, dimension);
|
|
451
|
+
if (metric === "dotProduct") return -dot;
|
|
452
|
+
if (magnitudeA === 0 || magnitudeB === 0) return 1;
|
|
453
|
+
return 1 - dot / (magnitudeA * magnitudeB);
|
|
695
454
|
}
|
|
696
455
|
|
|
697
|
-
// src/vector/
|
|
698
|
-
|
|
699
|
-
|
|
700
|
-
|
|
701
|
-
|
|
702
|
-
|
|
703
|
-
|
|
704
|
-
|
|
705
|
-
return
|
|
456
|
+
// src/vector/similarity.ts
|
|
457
|
+
function magnitude(v) {
|
|
458
|
+
const result = simdMagnitude(v);
|
|
459
|
+
if (result !== null) return result;
|
|
460
|
+
let sum = 0;
|
|
461
|
+
for (let i = 0; i < v.length; i++) {
|
|
462
|
+
sum += v[i] * v[i];
|
|
463
|
+
}
|
|
464
|
+
return Math.sqrt(sum);
|
|
706
465
|
}
|
|
707
|
-
function
|
|
708
|
-
|
|
466
|
+
function cosineSimilarityWithMagnitudes(a, b, magA, magB) {
|
|
467
|
+
if (magA === 0 || magB === 0) return 0;
|
|
468
|
+
return dotProduct(a, b) / (magA * magB);
|
|
709
469
|
}
|
|
710
|
-
function
|
|
711
|
-
const
|
|
712
|
-
if (
|
|
713
|
-
|
|
714
|
-
|
|
470
|
+
function dotProduct(a, b) {
|
|
471
|
+
const result = simdDotProduct(a, b);
|
|
472
|
+
if (result !== null) return result;
|
|
473
|
+
let sum = 0;
|
|
474
|
+
for (let i = 0; i < a.length; i++) {
|
|
475
|
+
sum += a[i] * b[i];
|
|
715
476
|
}
|
|
716
|
-
return
|
|
477
|
+
return sum;
|
|
717
478
|
}
|
|
718
|
-
function
|
|
719
|
-
|
|
720
|
-
|
|
721
|
-
|
|
722
|
-
|
|
723
|
-
|
|
724
|
-
|
|
725
|
-
|
|
726
|
-
|
|
727
|
-
|
|
728
|
-
if (!regions.every(isSharedMemory)) return null;
|
|
729
|
-
const codeBlocks = [];
|
|
730
|
-
for (const block of store.codeBlocks) {
|
|
731
|
-
const bytes = blockBytes(block);
|
|
732
|
-
if (bytes === null) return null;
|
|
733
|
-
codeBlocks.push(bytes);
|
|
734
|
-
}
|
|
735
|
-
const vectorBlocks = [];
|
|
736
|
-
for (const block of store.blocks) {
|
|
737
|
-
const bytes = block === null ? null : blockBytes(block);
|
|
738
|
-
if (block !== null && bytes === null) return null;
|
|
739
|
-
vectorBlocks.push(bytes);
|
|
479
|
+
function euclideanDistance(a, b) {
|
|
480
|
+
return Math.sqrt(squaredEuclideanDistance(a, b));
|
|
481
|
+
}
|
|
482
|
+
function squaredEuclideanDistance(a, b) {
|
|
483
|
+
const result = simdSquaredEuclideanDistance(a, b);
|
|
484
|
+
if (result !== null) return result;
|
|
485
|
+
let sum = 0;
|
|
486
|
+
for (let i = 0; i < a.length; i++) {
|
|
487
|
+
const diff = a[i] - b[i];
|
|
488
|
+
sum += diff * diff;
|
|
740
489
|
}
|
|
490
|
+
return sum;
|
|
491
|
+
}
|
|
492
|
+
|
|
493
|
+
// src/vector/hnsw/adjacency/views.ts
|
|
494
|
+
var ABSENT = -1;
|
|
495
|
+
function openAdjacency(handles, m, mMax0) {
|
|
741
496
|
return {
|
|
742
|
-
|
|
743
|
-
|
|
744
|
-
|
|
745
|
-
|
|
746
|
-
|
|
747
|
-
|
|
748
|
-
|
|
749
|
-
|
|
750
|
-
|
|
751
|
-
|
|
752
|
-
|
|
753
|
-
vectorOffset: fixedView(store.diskOffset, Uint32Array),
|
|
754
|
-
vectorFiles: [...store.vectorFiles],
|
|
755
|
-
codeBlocks,
|
|
756
|
-
vectorBlocks
|
|
497
|
+
m,
|
|
498
|
+
mMax0,
|
|
499
|
+
level0Stride: mMax0 + 2,
|
|
500
|
+
upperStride: m + 2,
|
|
501
|
+
handles,
|
|
502
|
+
header: handles.header,
|
|
503
|
+
nodeLevels: fixedView(handles.nodeLevels, Uint8Array),
|
|
504
|
+
level0: fixedView(handles.level0, Int32Array),
|
|
505
|
+
upperBase: fixedView(handles.upperBase, Int32Array),
|
|
506
|
+
upper: fixedView(handles.upper, Int32Array),
|
|
507
|
+
incoming: fixedView(handles.incoming, Int32Array)
|
|
757
508
|
};
|
|
758
509
|
}
|
|
759
|
-
function
|
|
760
|
-
|
|
761
|
-
|
|
762
|
-
|
|
763
|
-
|
|
764
|
-
|
|
765
|
-
|
|
766
|
-
|
|
767
|
-
|
|
510
|
+
function rebindNodes(adj) {
|
|
511
|
+
adj.nodeLevels = fixedView(adj.handles.nodeLevels, Uint8Array);
|
|
512
|
+
adj.incoming = fixedView(adj.handles.incoming, Int32Array);
|
|
513
|
+
adj.level0 = fixedView(adj.handles.level0, Int32Array);
|
|
514
|
+
adj.upperBase = fixedView(adj.handles.upperBase, Int32Array);
|
|
515
|
+
}
|
|
516
|
+
function rebindUpper(adj) {
|
|
517
|
+
adj.upper = fixedView(adj.handles.upper, Int32Array);
|
|
518
|
+
}
|
|
519
|
+
function reachNode(adj, ord) {
|
|
520
|
+
if (ord < adj.nodeLevels.length) return true;
|
|
521
|
+
if (ord >= adj.handles.nodeLevels.byteLength) return false;
|
|
522
|
+
rebindNodes(adj);
|
|
523
|
+
return ord < adj.nodeLevels.length;
|
|
524
|
+
}
|
|
525
|
+
function reachUpper(adj, end) {
|
|
526
|
+
if (end <= adj.upper.length) return true;
|
|
527
|
+
if (end * 4 > adj.handles.upper.byteLength) return false;
|
|
528
|
+
rebindUpper(adj);
|
|
529
|
+
return end <= adj.upper.length;
|
|
530
|
+
}
|
|
531
|
+
function adjacencySlots(adj) {
|
|
532
|
+
return Atomics.load(adj.header, GRAPH_SLOTS);
|
|
533
|
+
}
|
|
534
|
+
function upperUsed(adj) {
|
|
535
|
+
return Atomics.load(adj.header, GRAPH_UPPER_USED);
|
|
536
|
+
}
|
|
537
|
+
function ensureAdjacencyCapacity(adj, needed) {
|
|
538
|
+
if (needed <= adj.nodeLevels.length) return;
|
|
539
|
+
const { handles } = adj;
|
|
540
|
+
if (needed <= handles.nodeLevels.byteLength) {
|
|
541
|
+
rebindNodes(adj);
|
|
542
|
+
return;
|
|
543
|
+
}
|
|
544
|
+
const capacity = Math.max(needed, Math.min(handles.nodeLevels.byteLength * 2, handles.nodeLevels.maxByteLength));
|
|
545
|
+
growBufferToExactly(handles.level0, capacity * adj.level0Stride * 4);
|
|
546
|
+
growBufferToExactly(handles.upperBase, capacity * 4);
|
|
547
|
+
growBufferToExactly(handles.locks, capacity * 4);
|
|
548
|
+
growBufferToExactly(handles.tombstones, capacity);
|
|
549
|
+
growBufferToExactly(handles.incoming, capacity * 4);
|
|
550
|
+
growBufferToExactly(handles.nodeLevels, capacity);
|
|
551
|
+
publishGraphCapacity(handles);
|
|
552
|
+
rebindNodes(adj);
|
|
553
|
+
}
|
|
554
|
+
function growUpperTo(adj, entries) {
|
|
555
|
+
const held = adj.handles.upper.byteLength;
|
|
556
|
+
growBufferTo(adj.handles.upper, entries * 4);
|
|
557
|
+
if (adj.handles.upper.byteLength !== held) publishGraphCapacity(adj.handles);
|
|
558
|
+
}
|
|
559
|
+
function ensureUpperCapacity(adj, entries) {
|
|
560
|
+
growUpperTo(adj, entries);
|
|
561
|
+
rebindUpper(adj);
|
|
562
|
+
}
|
|
563
|
+
function ensureUpperRoom(adj, levels) {
|
|
564
|
+
if (levels < 1) return;
|
|
565
|
+
growUpperTo(adj, Atomics.load(adj.header, GRAPH_UPPER_USED) + levels * adj.upperStride);
|
|
566
|
+
}
|
|
567
|
+
function allocateUpperBlock(adj, levels) {
|
|
568
|
+
const size = levels * adj.upperStride;
|
|
569
|
+
for (; ; ) {
|
|
570
|
+
const offset = Atomics.load(adj.header, GRAPH_UPPER_USED);
|
|
571
|
+
growUpperTo(adj, offset + size);
|
|
572
|
+
if (Atomics.compareExchange(adj.header, GRAPH_UPPER_USED, offset, offset + size) !== offset) continue;
|
|
573
|
+
rebindUpper(adj);
|
|
574
|
+
return offset;
|
|
575
|
+
}
|
|
576
|
+
}
|
|
577
|
+
function raiseSlots(adj, slots) {
|
|
578
|
+
for (; ; ) {
|
|
579
|
+
const seen = Atomics.load(adj.header, GRAPH_SLOTS);
|
|
580
|
+
if (seen >= slots) return;
|
|
581
|
+
if (Atomics.compareExchange(adj.header, GRAPH_SLOTS, seen, slots) === seen) return;
|
|
768
582
|
}
|
|
769
|
-
return {
|
|
770
|
-
core,
|
|
771
|
-
handle,
|
|
772
|
-
layoutRevision: store.layoutRevision,
|
|
773
|
-
vectorBlockCount: store.blocks.length,
|
|
774
|
-
codeBlockCount: store.codeBlocks.length,
|
|
775
|
-
retryAt: handle === null ? Date.now() + NATIVE_ATTACH_RETRY_MS : Number.POSITIVE_INFINITY,
|
|
776
|
-
ordinals: new Int32Array(0),
|
|
777
|
-
distances: new Float64Array(0)
|
|
778
|
-
};
|
|
779
583
|
}
|
|
780
|
-
function
|
|
781
|
-
|
|
584
|
+
function createNode(adj, ord, maxLayer) {
|
|
585
|
+
ensureAdjacencyCapacity(adj, ord + 1);
|
|
586
|
+
adj.upperBase[ord] = maxLayer >= 1 ? allocateUpperBlock(adj, maxLayer) + 1 : 0;
|
|
587
|
+
adj.level0[ord * adj.level0Stride] = 0;
|
|
588
|
+
raiseSlots(adj, ord + 1);
|
|
589
|
+
Atomics.store(adj.nodeLevels, ord, maxLayer + 1);
|
|
782
590
|
}
|
|
783
|
-
function
|
|
784
|
-
|
|
591
|
+
function deleteNode(adj, ord) {
|
|
592
|
+
if (ord < 0 || !reachNode(adj, ord)) return;
|
|
593
|
+
Atomics.store(adj.nodeLevels, ord, 0);
|
|
594
|
+
adj.upperBase[ord] = 0;
|
|
595
|
+
adj.level0[ord * adj.level0Stride] = 0;
|
|
596
|
+
Atomics.store(adj.incoming, ord, 0);
|
|
785
597
|
}
|
|
786
|
-
function
|
|
787
|
-
|
|
788
|
-
|
|
789
|
-
|
|
790
|
-
|
|
791
|
-
|
|
792
|
-
|
|
793
|
-
|
|
794
|
-
|
|
795
|
-
|
|
598
|
+
function resetAdjacency(adj) {
|
|
599
|
+
rebindNodes(adj);
|
|
600
|
+
rebindUpper(adj);
|
|
601
|
+
adj.incoming.fill(0);
|
|
602
|
+
adj.nodeLevels.fill(0);
|
|
603
|
+
adj.level0.fill(0);
|
|
604
|
+
adj.upperBase.fill(0);
|
|
605
|
+
adj.upper.fill(0);
|
|
606
|
+
Atomics.store(adj.header, GRAPH_UPPER_USED, 0);
|
|
607
|
+
Atomics.store(adj.header, GRAPH_SLOTS, 0);
|
|
796
608
|
}
|
|
797
|
-
function
|
|
798
|
-
|
|
799
|
-
return
|
|
609
|
+
function nodeLevel(adj, ord) {
|
|
610
|
+
if (ord < 0 || !reachNode(adj, ord)) return ABSENT;
|
|
611
|
+
return adj.nodeLevels[ord] - 1;
|
|
800
612
|
}
|
|
801
|
-
function
|
|
802
|
-
|
|
803
|
-
return attached === null ? 0 : attached.ordinals.byteLength + attached.distances.byteLength;
|
|
613
|
+
function hasNode(adj, ord) {
|
|
614
|
+
return nodeLevel(adj, ord) !== ABSENT;
|
|
804
615
|
}
|
|
805
|
-
function
|
|
806
|
-
|
|
807
|
-
|
|
808
|
-
if (core === null) return null;
|
|
809
|
-
let attached = attachedStores.get(store);
|
|
810
|
-
if (attached !== void 0 && !stillCurrent(attached, store)) {
|
|
811
|
-
detachNativeStore(store);
|
|
812
|
-
attached = void 0;
|
|
813
|
-
}
|
|
814
|
-
if (attached === void 0) {
|
|
815
|
-
attached = attach(core, store);
|
|
816
|
-
attachedStores.set(store, attached);
|
|
817
|
-
}
|
|
818
|
-
return isUsable(attached) ? attached : null;
|
|
616
|
+
function graphBytes(adj) {
|
|
617
|
+
const handles = adj.handles;
|
|
618
|
+
return handles.header.byteLength + handles.nodeLevels.byteLength + handles.level0.byteLength + handles.upperBase.byteLength + handles.upper.byteLength + handles.locks.byteLength + handles.tombstones.byteLength + handles.incoming.byteLength + handles.heldLocks.byteLength;
|
|
819
619
|
}
|
|
820
|
-
|
|
821
|
-
|
|
822
|
-
|
|
823
|
-
|
|
620
|
+
|
|
621
|
+
// src/vector/hnsw/adjacency/incoming.ts
|
|
622
|
+
function incomingCount(adj, ord) {
|
|
623
|
+
if (ord < 0 || !reachNode(adj, ord)) return 0;
|
|
624
|
+
return Atomics.load(adj.incoming, ord);
|
|
824
625
|
}
|
|
825
|
-
function
|
|
826
|
-
if (
|
|
827
|
-
|
|
828
|
-
try {
|
|
829
|
-
status = store.core.score(store.handle, query, nativeMetricCode(metric), store.ordinals, count, store.distances);
|
|
830
|
-
} catch (error) {
|
|
831
|
-
stopUsingTheNativeSearchCore(error);
|
|
832
|
-
return null;
|
|
833
|
-
}
|
|
834
|
-
return status === NATIVE_OK ? store.distances : null;
|
|
626
|
+
function noteLinked(adj, ord) {
|
|
627
|
+
if (ord < 0 || !reachNode(adj, ord)) return;
|
|
628
|
+
Atomics.add(adj.incoming, ord, 1);
|
|
835
629
|
}
|
|
836
|
-
function
|
|
837
|
-
|
|
838
|
-
|
|
839
|
-
|
|
840
|
-
|
|
841
|
-
|
|
630
|
+
function noteUnlinked(adj, ord) {
|
|
631
|
+
if (ord < 0 || !reachNode(adj, ord)) return 0;
|
|
632
|
+
for (; ; ) {
|
|
633
|
+
const seen = Atomics.load(adj.incoming, ord);
|
|
634
|
+
if (seen <= 0) return 0;
|
|
635
|
+
if (Atomics.compareExchange(adj.incoming, ord, seen, seen - 1) === seen) return seen - 1;
|
|
636
|
+
}
|
|
842
637
|
}
|
|
843
|
-
function
|
|
844
|
-
if (
|
|
845
|
-
for (
|
|
846
|
-
const
|
|
847
|
-
if (
|
|
848
|
-
|
|
849
|
-
try {
|
|
850
|
-
status = store.core[work](store.handle, nativeMetricCode(metric), ordinals, ordinals.length);
|
|
851
|
-
} catch (error) {
|
|
852
|
-
stopUsingTheNativeSearchCore(error);
|
|
853
|
-
return false;
|
|
854
|
-
}
|
|
855
|
-
if (status === NATIVE_OK) return true;
|
|
856
|
-
if (status !== NATIVE_NEEDS_ROOM) return false;
|
|
857
|
-
detachNativeStore(handles);
|
|
638
|
+
function releaseUnlessLast(adj, ord) {
|
|
639
|
+
if (ord < 0 || !reachNode(adj, ord)) return true;
|
|
640
|
+
for (; ; ) {
|
|
641
|
+
const seen = Atomics.load(adj.incoming, ord);
|
|
642
|
+
if (seen <= 1) return false;
|
|
643
|
+
if (Atomics.compareExchange(adj.incoming, ord, seen, seen - 1) === seen) return true;
|
|
858
644
|
}
|
|
859
|
-
return false;
|
|
860
645
|
}
|
|
861
|
-
function
|
|
862
|
-
return
|
|
646
|
+
function holdsNodeAt(adj, ord) {
|
|
647
|
+
return ord >= 0 && ord < adj.nodeLevels.length && adj.nodeLevels[ord] !== 0;
|
|
863
648
|
}
|
|
864
|
-
function
|
|
865
|
-
if (
|
|
866
|
-
|
|
649
|
+
function countLinksOutOf(adj, ord, step) {
|
|
650
|
+
if (!holdsNodeAt(adj, ord)) return;
|
|
651
|
+
const incoming = adj.incoming;
|
|
652
|
+
const level0 = adj.level0;
|
|
653
|
+
const base = ord * adj.level0Stride;
|
|
654
|
+
const count = level0[base];
|
|
655
|
+
for (let i = 1; i <= count; i++) {
|
|
656
|
+
const neighbour = level0[base + i];
|
|
657
|
+
if (neighbour === ord || !holdsNodeAt(adj, neighbour)) continue;
|
|
658
|
+
if (incoming[neighbour] + step >= 0) incoming[neighbour] += step;
|
|
659
|
+
}
|
|
660
|
+
}
|
|
661
|
+
function countEveryLink(adj, slots) {
|
|
662
|
+
for (let ord = 0; ord < slots; ord++) countLinksOutOf(adj, ord, 1);
|
|
867
663
|
}
|
|
868
664
|
|
|
869
|
-
// src/vector/
|
|
870
|
-
|
|
871
|
-
|
|
872
|
-
var WAKE_LIST_WORDS = WAKE_COUNT_WORDS + WAKES_THE_CORE_KEEPS_PER_CALL;
|
|
873
|
-
var WAKE_ENTRY_LOCK = -1;
|
|
874
|
-
var attachedGraphs = /* @__PURE__ */ new WeakMap();
|
|
875
|
-
function graphMemory(graph) {
|
|
876
|
-
const regions = [
|
|
877
|
-
graph.header.buffer,
|
|
878
|
-
graph.nodeLevels,
|
|
879
|
-
graph.level0,
|
|
880
|
-
graph.upperBase,
|
|
881
|
-
graph.upper,
|
|
882
|
-
graph.locks,
|
|
883
|
-
graph.tombstones,
|
|
884
|
-
graph.incoming,
|
|
885
|
-
graph.heldLocks.buffer
|
|
886
|
-
];
|
|
887
|
-
if (!regions.every(isSharedMemory)) return null;
|
|
888
|
-
return {
|
|
889
|
-
graphHeader: graph.header,
|
|
890
|
-
nodeLevels: fixedView(graph.nodeLevels, Uint8Array),
|
|
891
|
-
level0: fixedView(graph.level0, Int32Array),
|
|
892
|
-
upperBase: fixedView(graph.upperBase, Int32Array),
|
|
893
|
-
upper: fixedView(graph.upper, Int32Array),
|
|
894
|
-
locks: fixedView(graph.locks, Int32Array),
|
|
895
|
-
tombstones: fixedView(graph.tombstones, Uint8Array),
|
|
896
|
-
incoming: fixedView(graph.incoming, Int32Array),
|
|
897
|
-
heldLocks: graph.heldLocks
|
|
898
|
-
};
|
|
665
|
+
// src/vector/hnsw/adjacency/neighbors.ts
|
|
666
|
+
function layerArray(adj, layer) {
|
|
667
|
+
return layer === 0 ? adj.level0 : adj.upper;
|
|
899
668
|
}
|
|
900
|
-
function
|
|
901
|
-
const
|
|
902
|
-
|
|
903
|
-
if (
|
|
904
|
-
|
|
905
|
-
|
|
906
|
-
|
|
907
|
-
|
|
908
|
-
}
|
|
909
|
-
}
|
|
910
|
-
return { handle, field: null };
|
|
669
|
+
function layerBase(adj, ord, layer) {
|
|
670
|
+
const level2 = nodeLevel(adj, ord);
|
|
671
|
+
if (level2 === ABSENT || layer > level2) return ABSENT;
|
|
672
|
+
if (layer === 0) return ord * adj.level0Stride;
|
|
673
|
+
const base = adj.upperBase[ord];
|
|
674
|
+
if (base === 0) return ABSENT;
|
|
675
|
+
const start = base - 1 + (layer - 1) * adj.upperStride;
|
|
676
|
+
return reachUpper(adj, start + adj.upperStride) ? start : ABSENT;
|
|
911
677
|
}
|
|
912
|
-
|
|
913
|
-
|
|
914
|
-
|
|
915
|
-
|
|
916
|
-
if (owner !== void 0 && owner !== state) return perField;
|
|
917
|
-
workspaceOwner = new WeakRef(state);
|
|
918
|
-
return perField + field.core.workspaceBytes();
|
|
678
|
+
function neighborCount(adj, ord, layer) {
|
|
679
|
+
const base = layerBase(adj, ord, layer);
|
|
680
|
+
if (base === ABSENT) return 0;
|
|
681
|
+
return layerArray(adj, layer)[base];
|
|
919
682
|
}
|
|
920
|
-
function
|
|
921
|
-
|
|
922
|
-
|
|
683
|
+
function readNeighbors(adj, ord, layer, out) {
|
|
684
|
+
const base = layerBase(adj, ord, layer);
|
|
685
|
+
if (base === ABSENT) return 0;
|
|
686
|
+
const array = layerArray(adj, layer);
|
|
687
|
+
const count = Math.min(array[base], out.length);
|
|
688
|
+
for (let i = 0; i < count; i++) out[i] = array[base + i + 1];
|
|
689
|
+
return count;
|
|
923
690
|
}
|
|
924
|
-
function
|
|
925
|
-
|
|
926
|
-
|
|
927
|
-
|
|
928
|
-
const
|
|
929
|
-
|
|
930
|
-
let
|
|
931
|
-
|
|
932
|
-
|
|
933
|
-
|
|
934
|
-
|
|
935
|
-
if (
|
|
936
|
-
|
|
937
|
-
|
|
691
|
+
function collectNeighbors(adj, ord, layer) {
|
|
692
|
+
const base = layerBase(adj, ord, layer);
|
|
693
|
+
if (base === ABSENT) return [];
|
|
694
|
+
const array = layerArray(adj, layer);
|
|
695
|
+
const count = array[base];
|
|
696
|
+
const collected = new Array(count);
|
|
697
|
+
for (let i = 0; i < count; i++) collected[i] = array[base + i + 1];
|
|
698
|
+
return collected;
|
|
699
|
+
}
|
|
700
|
+
function addNeighbor(adj, ord, layer, neighborOrd) {
|
|
701
|
+
const base = layerBase(adj, ord, layer);
|
|
702
|
+
if (base === ABSENT) return;
|
|
703
|
+
const array = layerArray(adj, layer);
|
|
704
|
+
const count = array[base];
|
|
705
|
+
for (let i = 1; i <= count; i++) {
|
|
706
|
+
if (array[base + i] === neighborOrd) return;
|
|
938
707
|
}
|
|
939
|
-
|
|
940
|
-
return
|
|
708
|
+
const stride = layer === 0 ? adj.level0Stride : adj.upperStride;
|
|
709
|
+
if (count + 1 > stride - 1) return;
|
|
710
|
+
array[base + count + 1] = neighborOrd;
|
|
711
|
+
array[base] = count + 1;
|
|
712
|
+
if (layer === 0) noteLinked(adj, neighborOrd);
|
|
941
713
|
}
|
|
942
|
-
function
|
|
943
|
-
const
|
|
944
|
-
if (
|
|
945
|
-
|
|
714
|
+
function removeNeighbor(adj, ord, layer, neighborOrd) {
|
|
715
|
+
const base = layerBase(adj, ord, layer);
|
|
716
|
+
if (base === ABSENT) return;
|
|
717
|
+
const array = layerArray(adj, layer);
|
|
718
|
+
const count = array[base];
|
|
946
719
|
for (let i = 1; i <= count; i++) {
|
|
947
|
-
|
|
948
|
-
|
|
949
|
-
|
|
950
|
-
continue;
|
|
720
|
+
if (array[base + i] !== neighborOrd) continue;
|
|
721
|
+
for (let j = i; j < count; j++) {
|
|
722
|
+
array[base + j] = array[base + j + 1];
|
|
951
723
|
}
|
|
952
|
-
|
|
953
|
-
|
|
724
|
+
array[base] = count - 1;
|
|
725
|
+
if (layer === 0) noteUnlinked(adj, neighborOrd);
|
|
726
|
+
return;
|
|
954
727
|
}
|
|
955
728
|
}
|
|
956
|
-
|
|
957
|
-
|
|
958
|
-
|
|
959
|
-
|
|
960
|
-
|
|
961
|
-
|
|
962
|
-
|
|
963
|
-
|
|
964
|
-
stopUsingTheNativeSearchCore(error);
|
|
965
|
-
return CALL_RAISED;
|
|
729
|
+
function writeNeighbors(adj, ord, layer, neighbors, count) {
|
|
730
|
+
const base = layerBase(adj, ord, layer);
|
|
731
|
+
if (base === ABSENT) return;
|
|
732
|
+
const array = layerArray(adj, layer);
|
|
733
|
+
const stride = layer === 0 ? adj.level0Stride : adj.upperStride;
|
|
734
|
+
const limit = Math.min(count, stride - 1);
|
|
735
|
+
for (let i = 0; i < limit; i++) {
|
|
736
|
+
array[base + i + 1] = neighbors[i];
|
|
966
737
|
}
|
|
967
|
-
|
|
968
|
-
return status;
|
|
738
|
+
array[base] = limit;
|
|
969
739
|
}
|
|
970
|
-
function
|
|
971
|
-
|
|
972
|
-
|
|
973
|
-
field,
|
|
974
|
-
() => field.core.place(
|
|
975
|
-
field.graph,
|
|
976
|
-
field.store.handle,
|
|
977
|
-
nativeMetricCode(metric),
|
|
978
|
-
ordinal,
|
|
979
|
-
topLayer,
|
|
980
|
-
graphHeldAlone ? 1 : 0,
|
|
981
|
-
state.locks.threadSlot,
|
|
982
|
-
field.wakes
|
|
983
|
-
)
|
|
984
|
-
);
|
|
985
|
-
if (status === NATIVE_OK) return "placed";
|
|
986
|
-
return status === NATIVE_NEEDS_ROOM ? "needsRoom" : "failed";
|
|
740
|
+
function holds(neighbors, count, ord) {
|
|
741
|
+
for (let i = 0; i < count; i++) if (neighbors[i] === ord) return true;
|
|
742
|
+
return false;
|
|
987
743
|
}
|
|
988
|
-
function
|
|
989
|
-
const
|
|
990
|
-
|
|
744
|
+
function replaceNeighbors(adj, ord, layer, neighbors, count) {
|
|
745
|
+
const base = layerBase(adj, ord, layer);
|
|
746
|
+
if (base === ABSENT) return;
|
|
747
|
+
if (layer > 0) {
|
|
748
|
+
writeNeighbors(adj, ord, layer, neighbors, count);
|
|
749
|
+
return;
|
|
750
|
+
}
|
|
751
|
+
const array = adj.level0;
|
|
752
|
+
const held = array.slice(base + 1, base + 1 + array[base]);
|
|
753
|
+
const limit = Math.min(count, adj.level0Stride - 1);
|
|
754
|
+
for (const former of held) if (!holds(neighbors, limit, former)) noteUnlinked(adj, former);
|
|
755
|
+
for (let i = 0; i < limit; i++) if (!holds(held, held.length, neighbors[i])) noteLinked(adj, neighbors[i]);
|
|
756
|
+
writeNeighbors(adj, ord, 0, neighbors, count);
|
|
991
757
|
}
|
|
992
|
-
|
|
993
|
-
|
|
994
|
-
|
|
758
|
+
|
|
759
|
+
// src/vector/hnsw/shared.ts
|
|
760
|
+
function entryPointOf(state) {
|
|
761
|
+
return Atomics.load(state.header, GRAPH_ENTRY_POINT);
|
|
995
762
|
}
|
|
996
|
-
function
|
|
997
|
-
|
|
998
|
-
field.graph,
|
|
999
|
-
field.store.handle,
|
|
1000
|
-
nativeMetricCode(metric),
|
|
1001
|
-
nearby,
|
|
1002
|
-
state.locks.threadSlot,
|
|
1003
|
-
field.wakes
|
|
1004
|
-
);
|
|
1005
|
-
return writeToTheGraph(state, field, connect) === NATIVE_OK;
|
|
763
|
+
function topLayerOf(state) {
|
|
764
|
+
return Atomics.load(state.header, GRAPH_TOP_LAYER);
|
|
1006
765
|
}
|
|
1007
|
-
|
|
1008
|
-
|
|
1009
|
-
var ABSENT = -1;
|
|
1010
|
-
function openAdjacency(handles, m, mMax0) {
|
|
1011
|
-
return {
|
|
1012
|
-
m,
|
|
1013
|
-
mMax0,
|
|
1014
|
-
level0Stride: mMax0 + 2,
|
|
1015
|
-
upperStride: m + 2,
|
|
1016
|
-
handles,
|
|
1017
|
-
header: handles.header,
|
|
1018
|
-
nodeLevels: fixedView(handles.nodeLevels, Uint8Array),
|
|
1019
|
-
level0: fixedView(handles.level0, Int32Array),
|
|
1020
|
-
upperBase: fixedView(handles.upperBase, Int32Array),
|
|
1021
|
-
upper: fixedView(handles.upper, Int32Array),
|
|
1022
|
-
incoming: fixedView(handles.incoming, Int32Array)
|
|
1023
|
-
};
|
|
766
|
+
function nodeCountOf(state) {
|
|
767
|
+
return Atomics.load(state.header, GRAPH_NODE_COUNT);
|
|
1024
768
|
}
|
|
1025
|
-
function
|
|
1026
|
-
|
|
1027
|
-
adj.incoming = fixedView(adj.handles.incoming, Int32Array);
|
|
1028
|
-
adj.level0 = fixedView(adj.handles.level0, Int32Array);
|
|
1029
|
-
adj.upperBase = fixedView(adj.handles.upperBase, Int32Array);
|
|
769
|
+
function tombstoneCountOf(state) {
|
|
770
|
+
return Atomics.load(state.header, GRAPH_TOMBSTONE_COUNT);
|
|
1030
771
|
}
|
|
1031
|
-
function
|
|
1032
|
-
|
|
772
|
+
function ensureCapacity(state, needed) {
|
|
773
|
+
ensureAdjacencyCapacity(state.adjacency, needed);
|
|
774
|
+
ensureVisited(state, needed);
|
|
1033
775
|
}
|
|
1034
|
-
function
|
|
1035
|
-
if (
|
|
1036
|
-
|
|
1037
|
-
|
|
1038
|
-
|
|
776
|
+
function ensureVisited(state, needed) {
|
|
777
|
+
if (needed <= state.visited.length) return;
|
|
778
|
+
let capacity = state.visited.length === 0 ? 16 : state.visited.length;
|
|
779
|
+
while (capacity < needed) capacity *= 2;
|
|
780
|
+
const next = new Uint32Array(capacity);
|
|
781
|
+
next.set(state.visited);
|
|
782
|
+
state.visited = next;
|
|
1039
783
|
}
|
|
1040
|
-
function
|
|
1041
|
-
|
|
1042
|
-
if (
|
|
1043
|
-
|
|
1044
|
-
|
|
784
|
+
function nextVisitStamp(state) {
|
|
785
|
+
state.visitStamp++;
|
|
786
|
+
if (state.visitStamp === 4294967295) {
|
|
787
|
+
state.visited.fill(0);
|
|
788
|
+
state.visitStamp = 1;
|
|
789
|
+
}
|
|
790
|
+
return state.visitStamp;
|
|
1045
791
|
}
|
|
1046
|
-
function
|
|
1047
|
-
|
|
792
|
+
function reachTombstone(state, ord) {
|
|
793
|
+
if (ord < state.tombstones.length) return true;
|
|
794
|
+
if (ord >= state.adjacency.handles.tombstones.byteLength) return false;
|
|
795
|
+
state.tombstones = fixedView(state.adjacency.handles.tombstones, Uint8Array);
|
|
796
|
+
return ord < state.tombstones.length;
|
|
1048
797
|
}
|
|
1049
|
-
function
|
|
1050
|
-
return
|
|
798
|
+
function isTombstoned(state, ord) {
|
|
799
|
+
return ord >= 0 && reachTombstone(state, ord) && state.tombstones[ord] === 1;
|
|
1051
800
|
}
|
|
1052
|
-
function
|
|
1053
|
-
|
|
1054
|
-
|
|
1055
|
-
|
|
1056
|
-
|
|
1057
|
-
|
|
801
|
+
function nodeExists(state, ord) {
|
|
802
|
+
return hasNode(state.adjacency, ord);
|
|
803
|
+
}
|
|
804
|
+
function nodeMaxLayer(state, ord) {
|
|
805
|
+
return nodeLevel(state.adjacency, ord);
|
|
806
|
+
}
|
|
807
|
+
function toDistance(a, b, magA, magB, metric) {
|
|
808
|
+
switch (metric) {
|
|
809
|
+
case "cosine":
|
|
810
|
+
return 1 - cosineSimilarityWithMagnitudes(a, b, magA, magB);
|
|
811
|
+
case "dotProduct":
|
|
812
|
+
return -dotProduct(a, b);
|
|
813
|
+
case "euclidean":
|
|
814
|
+
return euclideanDistance(a, b);
|
|
1058
815
|
}
|
|
1059
|
-
const capacity = Math.max(needed, Math.min(handles.nodeLevels.byteLength * 2, handles.nodeLevels.maxByteLength));
|
|
1060
|
-
growBufferToExactly(handles.level0, capacity * adj.level0Stride * 4);
|
|
1061
|
-
growBufferToExactly(handles.upperBase, capacity * 4);
|
|
1062
|
-
growBufferToExactly(handles.locks, capacity * 4);
|
|
1063
|
-
growBufferToExactly(handles.tombstones, capacity);
|
|
1064
|
-
growBufferToExactly(handles.incoming, capacity * 4);
|
|
1065
|
-
growBufferToExactly(handles.nodeLevels, capacity);
|
|
1066
|
-
publishGraphCapacity(handles);
|
|
1067
|
-
rebindNodes(adj);
|
|
1068
816
|
}
|
|
1069
|
-
function
|
|
1070
|
-
|
|
1071
|
-
|
|
1072
|
-
|
|
817
|
+
function toScore(distance, metric) {
|
|
818
|
+
switch (metric) {
|
|
819
|
+
case "cosine":
|
|
820
|
+
return 1 - distance;
|
|
821
|
+
case "dotProduct":
|
|
822
|
+
return -distance;
|
|
823
|
+
case "euclidean":
|
|
824
|
+
return 1 / (1 + distance);
|
|
825
|
+
}
|
|
826
|
+
}
|
|
827
|
+
function randomLevel(mL) {
|
|
828
|
+
let u = Math.random();
|
|
829
|
+
if (u === 0) u = Number.MIN_VALUE;
|
|
830
|
+
return Math.min(Math.floor(-Math.log(u) * mL), MAX_LAYER_CAP);
|
|
831
|
+
}
|
|
832
|
+
function entryForOrd(state, ord) {
|
|
833
|
+
return state.store.entryForOrdinal(ord);
|
|
834
|
+
}
|
|
835
|
+
function buildsFromCodes(state) {
|
|
836
|
+
return activeQuantizer(state) !== void 0;
|
|
837
|
+
}
|
|
838
|
+
function activeQuantizer(state) {
|
|
839
|
+
const quantizer = state.quantizer;
|
|
840
|
+
if (quantizer === void 0 || !quantizer.isCalibrated()) return void 0;
|
|
841
|
+
return quantizer;
|
|
842
|
+
}
|
|
843
|
+
function nodeDistanceByOrd(state, aOrd, bOrd, metric) {
|
|
844
|
+
if (buildsFromCodes(state) && state.quantizer !== void 0) {
|
|
845
|
+
const estimated = state.quantizer.distanceBetweenOrdinals(aOrd, bOrd);
|
|
846
|
+
if (estimated !== Number.POSITIVE_INFINITY) return estimated;
|
|
847
|
+
}
|
|
848
|
+
return state.store.distanceByOrdinal(aOrd, bOrd, metric);
|
|
849
|
+
}
|
|
850
|
+
function nodeDistanceFunction(state, metric) {
|
|
851
|
+
const storeDistance = state.store.pairDistance(metric);
|
|
852
|
+
const quantizer = state.quantizer;
|
|
853
|
+
if (quantizer === void 0) return storeDistance;
|
|
854
|
+
const codeDistance = quantizer.pairDistance();
|
|
855
|
+
return (aOrd, bOrd) => {
|
|
856
|
+
if (buildsFromCodes(state)) {
|
|
857
|
+
const estimated = codeDistance(aOrd, bOrd);
|
|
858
|
+
if (estimated !== Number.POSITIVE_INFINITY) return estimated;
|
|
859
|
+
}
|
|
860
|
+
return storeDistance(aOrd, bOrd);
|
|
861
|
+
};
|
|
862
|
+
}
|
|
863
|
+
function queryDistanceByOrd(state, qVec, qMag, ord, metric) {
|
|
864
|
+
const entry = state.store.entryForOrdinal(ord);
|
|
865
|
+
if (!entry) return Number.POSITIVE_INFINITY;
|
|
866
|
+
return toDistance(qVec, entry.vector, qMag, entry.magnitude, metric);
|
|
867
|
+
}
|
|
868
|
+
function maxConns(state, layer) {
|
|
869
|
+
return layer === 0 ? state.Mmax0 : state.M;
|
|
870
|
+
}
|
|
871
|
+
function addConnection(connections, ord) {
|
|
872
|
+
for (let i = 0; i < connections.length; i++) {
|
|
873
|
+
if (connections[i] === ord) return;
|
|
874
|
+
}
|
|
875
|
+
connections.push(ord);
|
|
876
|
+
}
|
|
877
|
+
|
|
878
|
+
// src/vector/vector-store/blocks.ts
|
|
879
|
+
var SCRATCH_ALIGNMENT_BYTES = 16;
|
|
880
|
+
var BLOCK_MAX_BYTES = MAX_WASM_PAGES * WASM_PAGE_BYTES;
|
|
881
|
+
function alignUp(bytes) {
|
|
882
|
+
return Math.ceil(bytes / SCRATCH_ALIGNMENT_BYTES) * SCRATCH_ALIGNMENT_BYTES;
|
|
1073
883
|
}
|
|
1074
|
-
function
|
|
1075
|
-
|
|
1076
|
-
|
|
884
|
+
function computeVectorBlockLayout(dimension, blockBytes2 = BLOCK_MAX_BYTES) {
|
|
885
|
+
const scratchStride = alignUp(dimension * 4);
|
|
886
|
+
const slotsOffset = alignUp(VECTOR_SCRATCH_SLOTS * scratchStride);
|
|
887
|
+
const slotStride = alignUp(dimension * 4);
|
|
888
|
+
return {
|
|
889
|
+
dimension,
|
|
890
|
+
scratchStride,
|
|
891
|
+
slotsOffset,
|
|
892
|
+
slotStride,
|
|
893
|
+
capacity: Math.max(1, Math.floor((Math.min(blockBytes2, BLOCK_MAX_BYTES) - slotsOffset) / slotStride))
|
|
894
|
+
};
|
|
1077
895
|
}
|
|
1078
|
-
function
|
|
1079
|
-
|
|
1080
|
-
growUpperTo(adj, Atomics.load(adj.header, GRAPH_UPPER_USED) + levels * adj.upperStride);
|
|
896
|
+
function initialBlockBytes(layout) {
|
|
897
|
+
return layout.slotsOffset + VECTOR_BLOCK_INITIAL_SLOTS * layout.slotStride;
|
|
1081
898
|
}
|
|
1082
|
-
function
|
|
1083
|
-
|
|
1084
|
-
|
|
1085
|
-
|
|
1086
|
-
|
|
1087
|
-
|
|
1088
|
-
|
|
1089
|
-
return
|
|
899
|
+
function pagesFor(bytes) {
|
|
900
|
+
return Math.ceil(bytes / WASM_PAGE_BYTES);
|
|
901
|
+
}
|
|
902
|
+
function createSharedMemory(pages) {
|
|
903
|
+
if (!sharedMemoryAvailable() || typeof WebAssembly === "undefined") return null;
|
|
904
|
+
try {
|
|
905
|
+
const memory = new WebAssembly.Memory({ initial: pages, maximum: MAX_WASM_PAGES, shared: true });
|
|
906
|
+
return createSharedArenaSimd(memory) === null ? null : memory;
|
|
907
|
+
} catch {
|
|
908
|
+
return null;
|
|
1090
909
|
}
|
|
1091
910
|
}
|
|
1092
|
-
function
|
|
1093
|
-
|
|
1094
|
-
|
|
1095
|
-
|
|
1096
|
-
|
|
911
|
+
function createVectorBlock(layout) {
|
|
912
|
+
const initialBytes = initialBlockBytes(layout);
|
|
913
|
+
const shared = createSharedMemory(pagesFor(initialBytes));
|
|
914
|
+
if (shared !== null) return { layout, storage: { kind: "shared-memory", memory: shared } };
|
|
915
|
+
const simd = createArenaSimd();
|
|
916
|
+
if (simd !== null) {
|
|
917
|
+
const missing = pagesFor(initialBytes) - simd.memory.buffer.byteLength / WASM_PAGE_BYTES;
|
|
918
|
+
if (missing > 0) simd.memory.grow(missing);
|
|
919
|
+
return { layout, storage: { kind: "private-memory", simd } };
|
|
1097
920
|
}
|
|
921
|
+
return { layout, storage: { kind: "bytes", buffer: createGrowableBuffer(initialBytes, fullBlockBytes(layout)) } };
|
|
1098
922
|
}
|
|
1099
|
-
function
|
|
1100
|
-
|
|
1101
|
-
adj.upperBase[ord] = maxLayer >= 1 ? allocateUpperBlock(adj, maxLayer) + 1 : 0;
|
|
1102
|
-
adj.level0[ord * adj.level0Stride] = 0;
|
|
1103
|
-
raiseSlots(adj, ord + 1);
|
|
1104
|
-
Atomics.store(adj.nodeLevels, ord, maxLayer + 1);
|
|
923
|
+
function fullBlockBytes(layout) {
|
|
924
|
+
return Math.min(BLOCK_MAX_BYTES, layout.slotsOffset + layout.capacity * layout.slotStride);
|
|
1105
925
|
}
|
|
1106
|
-
function
|
|
1107
|
-
|
|
1108
|
-
|
|
1109
|
-
|
|
1110
|
-
adj.level0[ord * adj.level0Stride] = 0;
|
|
1111
|
-
Atomics.store(adj.incoming, ord, 0);
|
|
926
|
+
function growMemoryTo(memory, bytes, layout) {
|
|
927
|
+
const have = memory.buffer.byteLength;
|
|
928
|
+
if (have >= bytes) return;
|
|
929
|
+
memory.grow(pagesFor(nextGrowthTarget(have, bytes, fullBlockBytes(layout))) - have / WASM_PAGE_BYTES);
|
|
1112
930
|
}
|
|
1113
|
-
function
|
|
1114
|
-
|
|
1115
|
-
|
|
1116
|
-
|
|
1117
|
-
|
|
1118
|
-
|
|
1119
|
-
|
|
1120
|
-
|
|
1121
|
-
Atomics.store(adj.header, GRAPH_UPPER_USED, 0);
|
|
1122
|
-
Atomics.store(adj.header, GRAPH_SLOTS, 0);
|
|
931
|
+
function ensureBlockSlots(handle, slots) {
|
|
932
|
+
const bytes = handle.layout.slotsOffset + Math.min(slots, handle.layout.capacity) * handle.layout.slotStride;
|
|
933
|
+
const storage = handle.storage;
|
|
934
|
+
if (storage.kind === "bytes") {
|
|
935
|
+
growBufferTo(storage.buffer, bytes);
|
|
936
|
+
return;
|
|
937
|
+
}
|
|
938
|
+
growMemoryTo(storage.kind === "shared-memory" ? storage.memory : storage.simd.memory, bytes, handle.layout);
|
|
1123
939
|
}
|
|
1124
|
-
function
|
|
1125
|
-
|
|
1126
|
-
|
|
940
|
+
function blockBuffer(handle) {
|
|
941
|
+
const storage = handle.storage;
|
|
942
|
+
if (storage.kind === "bytes") return storage.buffer;
|
|
943
|
+
return storage.kind === "shared-memory" ? storage.memory.buffer : storage.simd.memory.buffer;
|
|
1127
944
|
}
|
|
1128
|
-
|
|
1129
|
-
|
|
945
|
+
var NOTHING_STAGED = -1;
|
|
946
|
+
var QUERY_STAGED = -2;
|
|
947
|
+
function openVectorBlock(handle, threadSlot) {
|
|
948
|
+
const { layout, storage } = handle;
|
|
949
|
+
const simd = storage.kind === "shared-memory" ? createSharedArenaSimd(storage.memory) : storage.kind === "private-memory" ? storage.simd : null;
|
|
950
|
+
const hasScratch = simd !== null && threadSlot >= 0 && threadSlot < VECTOR_SCRATCH_SLOTS;
|
|
951
|
+
const scratchSlot = hasScratch ? threadSlot : 0;
|
|
952
|
+
let float32View;
|
|
953
|
+
let byteView;
|
|
954
|
+
let dataView;
|
|
955
|
+
function rebindViews() {
|
|
956
|
+
const buffer = blockBuffer(handle);
|
|
957
|
+
float32View = fixedView(buffer, Float32Array);
|
|
958
|
+
byteView = fixedView(buffer, Uint8Array);
|
|
959
|
+
dataView = new DataView(buffer, 0, byteView.length);
|
|
960
|
+
}
|
|
961
|
+
rebindViews();
|
|
962
|
+
return {
|
|
963
|
+
handle,
|
|
964
|
+
simd,
|
|
965
|
+
hasScratch,
|
|
966
|
+
scratchByteOffset: scratchSlot * layout.scratchStride,
|
|
967
|
+
stagedOrdinal: NOTHING_STAGED,
|
|
968
|
+
float32(neededLength) {
|
|
969
|
+
if (neededLength > float32View.length) rebindViews();
|
|
970
|
+
return float32View;
|
|
971
|
+
},
|
|
972
|
+
bytes(neededLength) {
|
|
973
|
+
if (neededLength > byteView.length) rebindViews();
|
|
974
|
+
return byteView;
|
|
975
|
+
},
|
|
976
|
+
data(neededLength) {
|
|
977
|
+
if (neededLength > byteView.length) rebindViews();
|
|
978
|
+
return dataView;
|
|
979
|
+
}
|
|
980
|
+
};
|
|
1130
981
|
}
|
|
1131
|
-
function
|
|
1132
|
-
|
|
1133
|
-
return handles.header.byteLength + handles.nodeLevels.byteLength + handles.level0.byteLength + handles.upperBase.byteLength + handles.upper.byteLength + handles.locks.byteLength + handles.tombstones.byteLength + handles.incoming.byteLength + handles.heldLocks.byteLength;
|
|
982
|
+
function slotByteOffset(layout, localOrdinal) {
|
|
983
|
+
return layout.slotsOffset + localOrdinal * layout.slotStride;
|
|
1134
984
|
}
|
|
1135
985
|
|
|
1136
|
-
// src/vector/
|
|
1137
|
-
|
|
1138
|
-
|
|
1139
|
-
|
|
986
|
+
// src/vector/osq/estimate.ts
|
|
987
|
+
var POPCOUNT = new Uint8Array(256);
|
|
988
|
+
for (let value = 0; value < 256; value++) {
|
|
989
|
+
let count = 0;
|
|
990
|
+
let rest = value;
|
|
991
|
+
while (rest !== 0) {
|
|
992
|
+
count += rest & 1;
|
|
993
|
+
rest >>= 1;
|
|
994
|
+
}
|
|
995
|
+
POPCOUNT[value] = count;
|
|
1140
996
|
}
|
|
1141
|
-
|
|
1142
|
-
|
|
1143
|
-
|
|
997
|
+
var LEVEL_BIT_MASK = { 1: 255, 2: 85 };
|
|
998
|
+
var STAGED_QUERY_PLANES = 4;
|
|
999
|
+
function osqNibbleProducts(a, aOffset, b, bOffset, bytes) {
|
|
1000
|
+
let total = 0;
|
|
1001
|
+
for (let n = 0; n < bytes; n++) {
|
|
1002
|
+
const left = a[aOffset + n];
|
|
1003
|
+
const right = b[bOffset + n];
|
|
1004
|
+
total += (left & 15) * (right & 15) + (left >> 4) * (right >> 4);
|
|
1005
|
+
}
|
|
1006
|
+
return total;
|
|
1144
1007
|
}
|
|
1145
|
-
function
|
|
1146
|
-
|
|
1147
|
-
for (; ; ) {
|
|
1148
|
-
const
|
|
1149
|
-
|
|
1150
|
-
|
|
1008
|
+
function twoBitStagedProducts(document2, documentOffset, streams, streamsOffset, streamBytes) {
|
|
1009
|
+
let total = 0;
|
|
1010
|
+
for (let n = 0; n < streamBytes; n++) {
|
|
1011
|
+
const packed = document2[documentOffset + n];
|
|
1012
|
+
for (let k = 0; k < STAGED_QUERY_PLANES; k++) {
|
|
1013
|
+
total += (packed >> 2 * k & 3) * streams[streamsOffset + k * streamBytes + n];
|
|
1014
|
+
}
|
|
1015
|
+
}
|
|
1016
|
+
return total;
|
|
1017
|
+
}
|
|
1018
|
+
function osqStagedQueryProducts(document2, documentOffset, documentBits, staged, stagedOffset, codeBytes) {
|
|
1019
|
+
if (documentBits === 2) return twoBitStagedProducts(document2, documentOffset, staged, stagedOffset, codeBytes);
|
|
1020
|
+
let total = 0;
|
|
1021
|
+
for (let p = 0; p < STAGED_QUERY_PLANES; p++) {
|
|
1022
|
+
const plane = stagedOffset + p * codeBytes;
|
|
1023
|
+
let bitsSet = 0;
|
|
1024
|
+
for (let n = 0; n < codeBytes; n++) bitsSet += POPCOUNT[document2[documentOffset + n] & staged[plane + n]];
|
|
1025
|
+
total += 2 ** p * bitsSet;
|
|
1151
1026
|
}
|
|
1027
|
+
return total;
|
|
1152
1028
|
}
|
|
1153
|
-
function
|
|
1154
|
-
|
|
1155
|
-
|
|
1156
|
-
|
|
1157
|
-
|
|
1158
|
-
|
|
1029
|
+
function osqNarrowPairProducts(a, aOffset, b, bOffset, bits, bytes) {
|
|
1030
|
+
const mask = LEVEL_BIT_MASK[bits];
|
|
1031
|
+
let total = 0;
|
|
1032
|
+
for (let j = 0; j < bits; j++) {
|
|
1033
|
+
for (let l = 0; l < bits; l++) {
|
|
1034
|
+
let bitsSet = 0;
|
|
1035
|
+
for (let n = 0; n < bytes; n++) bitsSet += POPCOUNT[a[aOffset + n] >> j & b[bOffset + n] >> l & mask];
|
|
1036
|
+
total += 2 ** (j + l) * bitsSet;
|
|
1037
|
+
}
|
|
1159
1038
|
}
|
|
1039
|
+
return total;
|
|
1160
1040
|
}
|
|
1161
|
-
function
|
|
1162
|
-
|
|
1041
|
+
function osqByteLevelProducts(document2, documentOffset, query, queryOffset, dimension) {
|
|
1042
|
+
let total = 0;
|
|
1043
|
+
for (let i = 0; i < dimension; i++) total += document2[documentOffset + i] * query[queryOffset + i];
|
|
1044
|
+
return total;
|
|
1163
1045
|
}
|
|
1164
|
-
function
|
|
1165
|
-
|
|
1166
|
-
const
|
|
1167
|
-
const
|
|
1168
|
-
|
|
1169
|
-
const
|
|
1170
|
-
|
|
1171
|
-
|
|
1172
|
-
|
|
1173
|
-
|
|
1046
|
+
function osqEstimate(products, document2, documentBits, query, queryBits, dimension, centroidDot, metric) {
|
|
1047
|
+
const documentStep = (document2.upper - document2.lower) / OSQ_STEPS[documentBits];
|
|
1048
|
+
const queryStep = (query.upper - query.lower) / OSQ_STEPS[queryBits];
|
|
1049
|
+
const centred = document2.lower * query.lower * dimension + query.lower * documentStep * document2.sum + document2.lower * queryStep * query.sum + documentStep * queryStep * products;
|
|
1050
|
+
if (metric === "euclidean") return Math.sqrt(Math.max(0, document2.correction + query.correction - 2 * centred));
|
|
1051
|
+
const similarity = centred + document2.correction + query.correction - centroidDot;
|
|
1052
|
+
if (metric === "cosine") return Math.min(Math.max(similarity, -1), 1);
|
|
1053
|
+
return similarity;
|
|
1054
|
+
}
|
|
1055
|
+
function osqDistance(estimate, metric) {
|
|
1056
|
+
switch (metric) {
|
|
1057
|
+
case "cosine":
|
|
1058
|
+
return 1 - estimate;
|
|
1059
|
+
case "dotProduct":
|
|
1060
|
+
return -estimate;
|
|
1061
|
+
case "euclidean":
|
|
1062
|
+
return estimate;
|
|
1174
1063
|
}
|
|
1175
1064
|
}
|
|
1176
|
-
function
|
|
1177
|
-
|
|
1065
|
+
function osqQueryBits(bits) {
|
|
1066
|
+
return OSQ_QUERY_BITS[bits];
|
|
1178
1067
|
}
|
|
1179
1068
|
|
|
1180
|
-
// src/vector/
|
|
1181
|
-
function
|
|
1182
|
-
|
|
1069
|
+
// src/vector/vector-store/code-blocks.ts
|
|
1070
|
+
function computeCodeBlockLayout(dimension, bits) {
|
|
1071
|
+
const queryBits = osqQueryBits(bits);
|
|
1072
|
+
const codeBytes = osqCodeBytes(dimension, bits);
|
|
1073
|
+
const queryBytes = osqStagedQueryBytes(dimension, bits);
|
|
1074
|
+
const scratchStride = alignUp(queryBytes);
|
|
1075
|
+
const slotsOffset = alignUp(VECTOR_SCRATCH_SLOTS * scratchStride);
|
|
1076
|
+
const slotStride = osqRecordBytes(dimension, bits);
|
|
1077
|
+
return {
|
|
1078
|
+
dimension,
|
|
1079
|
+
bits,
|
|
1080
|
+
queryBits,
|
|
1081
|
+
codeBytes,
|
|
1082
|
+
queryBytes,
|
|
1083
|
+
scratchStride,
|
|
1084
|
+
slotsOffset,
|
|
1085
|
+
slotStride,
|
|
1086
|
+
capacity: Math.floor((BLOCK_MAX_BYTES - slotsOffset) / slotStride)
|
|
1087
|
+
};
|
|
1183
1088
|
}
|
|
1184
|
-
|
|
1185
|
-
|
|
1186
|
-
|
|
1187
|
-
|
|
1188
|
-
|
|
1189
|
-
|
|
1190
|
-
|
|
1191
|
-
|
|
1089
|
+
|
|
1090
|
+
// src/vector/vector-store/handles.ts
|
|
1091
|
+
var STORE_SLOTS = 0;
|
|
1092
|
+
var STORE_LIVE_COUNT = 1;
|
|
1093
|
+
var STORE_BLOCK_COUNT = 2;
|
|
1094
|
+
var STORE_CALIBRATED = 3;
|
|
1095
|
+
var STORE_CODE_COUNT = 4;
|
|
1096
|
+
var STORE_DOC_ID_BYTES = 5;
|
|
1097
|
+
var STORE_CODE_BLOCK_COUNT = 6;
|
|
1098
|
+
var STORE_CALIBRATION_GENERATION = 7;
|
|
1099
|
+
var STORE_RELEASED_VECTORS_TO_DISK = 8;
|
|
1100
|
+
var STORE_UNPLACED_COUNT = 9;
|
|
1101
|
+
var STORE_REMOVED_COUNT = 10;
|
|
1102
|
+
var STORE_HEADER_WORDS = 16;
|
|
1103
|
+
var IN_MEMORY = -1;
|
|
1104
|
+
function fixedInt32(words) {
|
|
1105
|
+
return new Int32Array(createFixedBuffer(words * 4), 0, words);
|
|
1192
1106
|
}
|
|
1193
|
-
function
|
|
1194
|
-
|
|
1195
|
-
if (base === ABSENT) return 0;
|
|
1196
|
-
return layerArray(adj, layer)[base];
|
|
1107
|
+
function fixedFloat32(length) {
|
|
1108
|
+
return new Float32Array(createFixedBuffer(length * 4), 0, length);
|
|
1197
1109
|
}
|
|
1198
|
-
function
|
|
1199
|
-
|
|
1200
|
-
if (base === ABSENT) return 0;
|
|
1201
|
-
const array = layerArray(adj, layer);
|
|
1202
|
-
const count = Math.min(array[base], out.length);
|
|
1203
|
-
for (let i = 0; i < count; i++) out[i] = array[base + i + 1];
|
|
1204
|
-
return count;
|
|
1110
|
+
function unplacedChunkCount(ordinals) {
|
|
1111
|
+
return Math.floor(ordinals / UNPLACED_FLAG_CHUNK_ORDINALS) + 1;
|
|
1205
1112
|
}
|
|
1206
|
-
function
|
|
1207
|
-
|
|
1208
|
-
|
|
1209
|
-
|
|
1210
|
-
|
|
1211
|
-
const collected = new Array(count);
|
|
1212
|
-
for (let i = 0; i < count; i++) collected[i] = array[base + i + 1];
|
|
1213
|
-
return collected;
|
|
1113
|
+
function perOrdinal2(bytesPerOrdinal) {
|
|
1114
|
+
return createGrowableBuffer(
|
|
1115
|
+
VECTOR_STORE_INITIAL_CAPACITY * bytesPerOrdinal,
|
|
1116
|
+
(MAX_VECTOR_ORDINALS + 1) * bytesPerOrdinal
|
|
1117
|
+
);
|
|
1214
1118
|
}
|
|
1215
|
-
function
|
|
1216
|
-
const
|
|
1217
|
-
|
|
1218
|
-
|
|
1219
|
-
const count = array[base];
|
|
1220
|
-
for (let i = 1; i <= count; i++) {
|
|
1221
|
-
if (array[base + i] === neighborOrd) return;
|
|
1222
|
-
}
|
|
1223
|
-
const stride = layer === 0 ? adj.level0Stride : adj.upperStride;
|
|
1224
|
-
if (count + 1 > stride - 1) return;
|
|
1225
|
-
array[base + count + 1] = neighborOrd;
|
|
1226
|
-
array[base] = count + 1;
|
|
1227
|
-
if (layer === 0) noteLinked(adj, neighborOrd);
|
|
1119
|
+
function inMemoryTable() {
|
|
1120
|
+
const buffer = perOrdinal2(4);
|
|
1121
|
+
new Int32Array(buffer).fill(IN_MEMORY);
|
|
1122
|
+
return buffer;
|
|
1228
1123
|
}
|
|
1229
|
-
function
|
|
1230
|
-
|
|
1231
|
-
|
|
1232
|
-
|
|
1233
|
-
|
|
1234
|
-
|
|
1235
|
-
|
|
1236
|
-
|
|
1237
|
-
|
|
1238
|
-
|
|
1239
|
-
|
|
1240
|
-
|
|
1241
|
-
|
|
1242
|
-
|
|
1124
|
+
function createSharedVectorStoreHandles(dimension, codeBits, blockBytes2 = BLOCK_MAX_BYTES) {
|
|
1125
|
+
return {
|
|
1126
|
+
dimension,
|
|
1127
|
+
codeBits,
|
|
1128
|
+
layout: computeVectorBlockLayout(dimension, blockBytes2),
|
|
1129
|
+
codeLayout: codeBits === null ? null : computeCodeBlockLayout(dimension, codeBits),
|
|
1130
|
+
layoutRevision: 0,
|
|
1131
|
+
header: fixedInt32(STORE_HEADER_WORDS),
|
|
1132
|
+
blocks: [],
|
|
1133
|
+
codeBlocks: [],
|
|
1134
|
+
vectorFiles: [],
|
|
1135
|
+
magnitudes: perOrdinal2(8),
|
|
1136
|
+
present: perOrdinal2(1),
|
|
1137
|
+
unplaced: perOrdinal2(1),
|
|
1138
|
+
unplacedChunks: createGrowableBuffer(4, unplacedChunkCount(MAX_VECTOR_ORDINALS) * 4),
|
|
1139
|
+
removed: perOrdinal2(1),
|
|
1140
|
+
partitions: perOrdinal2(4),
|
|
1141
|
+
docIdBytes: createGrowableBuffer(VECTOR_STORE_INITIAL_CAPACITY * 16, MAX_DOC_ID_TABLE_BYTES),
|
|
1142
|
+
docIdOffsets: perOrdinal2(4),
|
|
1143
|
+
codePresent: perOrdinal2(1),
|
|
1144
|
+
diskFile: inMemoryTable(),
|
|
1145
|
+
diskOffset: perOrdinal2(4),
|
|
1146
|
+
centroid: fixedFloat32(dimension)
|
|
1147
|
+
};
|
|
1243
1148
|
}
|
|
1244
|
-
function
|
|
1245
|
-
|
|
1246
|
-
|
|
1247
|
-
|
|
1248
|
-
const stride = layer === 0 ? adj.level0Stride : adj.upperStride;
|
|
1249
|
-
const limit = Math.min(count, stride - 1);
|
|
1250
|
-
for (let i = 0; i < limit; i++) {
|
|
1251
|
-
array[base + i + 1] = neighbors[i];
|
|
1149
|
+
function sharedVectorStoreBytes(handles) {
|
|
1150
|
+
let bytes = handles.header.byteLength + handles.centroid.byteLength;
|
|
1151
|
+
for (const block of handles.blocks) {
|
|
1152
|
+
if (block !== null) bytes += blockBuffer(block).byteLength;
|
|
1252
1153
|
}
|
|
1253
|
-
|
|
1154
|
+
for (const block of handles.codeBlocks) bytes += blockBuffer(block).byteLength;
|
|
1155
|
+
bytes += handles.magnitudes.byteLength;
|
|
1156
|
+
bytes += handles.present.byteLength;
|
|
1157
|
+
bytes += handles.unplaced.byteLength;
|
|
1158
|
+
bytes += handles.unplacedChunks.byteLength;
|
|
1159
|
+
bytes += handles.removed.byteLength;
|
|
1160
|
+
bytes += handles.partitions.byteLength;
|
|
1161
|
+
bytes += handles.docIdBytes.byteLength;
|
|
1162
|
+
bytes += handles.docIdOffsets.byteLength;
|
|
1163
|
+
bytes += handles.codePresent.byteLength;
|
|
1164
|
+
bytes += handles.diskFile.byteLength;
|
|
1165
|
+
bytes += handles.diskOffset.byteLength;
|
|
1166
|
+
return bytes;
|
|
1254
1167
|
}
|
|
1255
|
-
|
|
1256
|
-
|
|
1257
|
-
|
|
1168
|
+
|
|
1169
|
+
// src/vector/native/types.ts
|
|
1170
|
+
var NATIVE_OK = 0;
|
|
1171
|
+
var NATIVE_NEEDS_ROOM = 3;
|
|
1172
|
+
|
|
1173
|
+
// src/vector/native/store.ts
|
|
1174
|
+
var METRIC_CODES2 = { cosine: 0, dotProduct: 1, euclidean: 2 };
|
|
1175
|
+
var attachedStores = /* @__PURE__ */ new WeakMap();
|
|
1176
|
+
function nativeMetricCode(metric) {
|
|
1177
|
+
return METRIC_CODES2[metric];
|
|
1258
1178
|
}
|
|
1259
|
-
function
|
|
1260
|
-
|
|
1261
|
-
if (base === ABSENT) return;
|
|
1262
|
-
if (layer > 0) {
|
|
1263
|
-
writeNeighbors(adj, ord, layer, neighbors, count);
|
|
1264
|
-
return;
|
|
1265
|
-
}
|
|
1266
|
-
const array = adj.level0;
|
|
1267
|
-
const held = array.slice(base + 1, base + 1 + array[base]);
|
|
1268
|
-
const limit = Math.min(count, adj.level0Stride - 1);
|
|
1269
|
-
for (const former of held) if (!holds(neighbors, limit, former)) noteUnlinked(adj, former);
|
|
1270
|
-
for (let i = 0; i < limit; i++) if (!holds(held, held.length, neighbors[i])) noteLinked(adj, neighbors[i]);
|
|
1271
|
-
writeNeighbors(adj, ord, 0, neighbors, count);
|
|
1179
|
+
function isSharedMemory(buffer) {
|
|
1180
|
+
return typeof SharedArrayBuffer === "function" && buffer instanceof SharedArrayBuffer;
|
|
1272
1181
|
}
|
|
1273
|
-
|
|
1274
|
-
|
|
1275
|
-
|
|
1276
|
-
|
|
1277
|
-
|
|
1278
|
-
let sum = 0;
|
|
1279
|
-
for (let i = 0; i < v.length; i++) {
|
|
1280
|
-
sum += v[i] * v[i];
|
|
1182
|
+
function blockBytes(block) {
|
|
1183
|
+
const storage = block.storage;
|
|
1184
|
+
if (storage.kind === "shared-memory") return new Uint8Array(storage.memory.buffer, block.layout.slotsOffset);
|
|
1185
|
+
if (storage.kind === "bytes" && isSharedMemory(storage.buffer)) {
|
|
1186
|
+
return new Uint8Array(storage.buffer, block.layout.slotsOffset);
|
|
1281
1187
|
}
|
|
1282
|
-
return
|
|
1188
|
+
return null;
|
|
1283
1189
|
}
|
|
1284
|
-
function
|
|
1285
|
-
|
|
1286
|
-
|
|
1190
|
+
function storeMemory(store) {
|
|
1191
|
+
const regions = [
|
|
1192
|
+
store.header.buffer,
|
|
1193
|
+
store.codePresent,
|
|
1194
|
+
store.centroid.buffer,
|
|
1195
|
+
store.magnitudes,
|
|
1196
|
+
store.present,
|
|
1197
|
+
store.diskFile,
|
|
1198
|
+
store.diskOffset
|
|
1199
|
+
];
|
|
1200
|
+
if (!regions.every(isSharedMemory)) return null;
|
|
1201
|
+
const codeBlocks = [];
|
|
1202
|
+
for (const block of store.codeBlocks) {
|
|
1203
|
+
const bytes = blockBytes(block);
|
|
1204
|
+
if (bytes === null) return null;
|
|
1205
|
+
codeBlocks.push(bytes);
|
|
1206
|
+
}
|
|
1207
|
+
const vectorBlocks = [];
|
|
1208
|
+
for (const block of store.blocks) {
|
|
1209
|
+
const bytes = block === null ? null : blockBytes(block);
|
|
1210
|
+
if (block !== null && bytes === null) return null;
|
|
1211
|
+
vectorBlocks.push(bytes);
|
|
1212
|
+
}
|
|
1213
|
+
return {
|
|
1214
|
+
storeHeader: store.header,
|
|
1215
|
+
dimension: store.dimension,
|
|
1216
|
+
bits: store.codeBits ?? 0,
|
|
1217
|
+
recordsPerBlock: store.codeLayout?.capacity ?? 0,
|
|
1218
|
+
vectorsPerBlock: store.layout.capacity,
|
|
1219
|
+
vectorStrideBytes: store.layout.slotStride,
|
|
1220
|
+
codePresent: fixedView(store.codePresent, Uint8Array),
|
|
1221
|
+
centroid: store.centroid,
|
|
1222
|
+
magnitudes: fixedView(store.magnitudes, Float64Array),
|
|
1223
|
+
present: fixedView(store.present, Uint8Array),
|
|
1224
|
+
vectorFile: fixedView(store.diskFile, Int32Array),
|
|
1225
|
+
vectorOffset: fixedView(store.diskOffset, Uint32Array),
|
|
1226
|
+
vectorFiles: [...store.vectorFiles],
|
|
1227
|
+
codeBlocks,
|
|
1228
|
+
vectorBlocks
|
|
1229
|
+
};
|
|
1287
1230
|
}
|
|
1288
|
-
function
|
|
1289
|
-
const
|
|
1290
|
-
|
|
1291
|
-
|
|
1292
|
-
|
|
1293
|
-
|
|
1231
|
+
function attach(core, store) {
|
|
1232
|
+
const memory = storeMemory(store);
|
|
1233
|
+
let handle = null;
|
|
1234
|
+
if (memory !== null) {
|
|
1235
|
+
try {
|
|
1236
|
+
handle = core.attachStore(memory);
|
|
1237
|
+
} catch {
|
|
1238
|
+
handle = null;
|
|
1239
|
+
}
|
|
1294
1240
|
}
|
|
1295
|
-
return
|
|
1241
|
+
return {
|
|
1242
|
+
core,
|
|
1243
|
+
handle,
|
|
1244
|
+
layoutRevision: store.layoutRevision,
|
|
1245
|
+
vectorBlockCount: store.blocks.length,
|
|
1246
|
+
codeBlockCount: store.codeBlocks.length,
|
|
1247
|
+
retryAt: handle === null ? Date.now() + NATIVE_ATTACH_RETRY_MS : Number.POSITIVE_INFINITY,
|
|
1248
|
+
ordinals: new Int32Array(0),
|
|
1249
|
+
distances: new Float64Array(0)
|
|
1250
|
+
};
|
|
1296
1251
|
}
|
|
1297
|
-
function
|
|
1298
|
-
return
|
|
1252
|
+
function stillCurrent(attached, store) {
|
|
1253
|
+
return Date.now() < attached.retryAt && attached.layoutRevision === store.layoutRevision && attached.vectorBlockCount === store.blocks.length && attached.codeBlockCount === store.codeBlocks.length;
|
|
1299
1254
|
}
|
|
1300
|
-
function
|
|
1301
|
-
|
|
1302
|
-
|
|
1303
|
-
|
|
1304
|
-
|
|
1305
|
-
|
|
1306
|
-
|
|
1255
|
+
function isUsable(attached) {
|
|
1256
|
+
return attached.handle !== null;
|
|
1257
|
+
}
|
|
1258
|
+
function detachNativeStore(store) {
|
|
1259
|
+
const attached = attachedStores.get(store);
|
|
1260
|
+
if (attached === void 0) return;
|
|
1261
|
+
attachedStores.delete(store);
|
|
1262
|
+
if (attached.handle === null) return;
|
|
1263
|
+
try {
|
|
1264
|
+
attached.core.detachStore(attached.handle);
|
|
1265
|
+
} catch (error) {
|
|
1266
|
+
stopUsingTheNativeSearchCore(error);
|
|
1307
1267
|
}
|
|
1308
|
-
return sum;
|
|
1309
1268
|
}
|
|
1310
|
-
|
|
1311
|
-
|
|
1312
|
-
|
|
1313
|
-
return Atomics.load(state.header, GRAPH_ENTRY_POINT);
|
|
1269
|
+
function attachedNativeStore(store) {
|
|
1270
|
+
const attached = attachedStores.get(store);
|
|
1271
|
+
return attached !== void 0 && isUsable(attached) ? attached : null;
|
|
1314
1272
|
}
|
|
1315
|
-
function
|
|
1316
|
-
|
|
1273
|
+
function nativeStoreScratchBytes(store) {
|
|
1274
|
+
const attached = attachedNativeStore(store);
|
|
1275
|
+
return attached === null ? 0 : attached.ordinals.byteLength + attached.distances.byteLength;
|
|
1317
1276
|
}
|
|
1318
|
-
function
|
|
1319
|
-
|
|
1277
|
+
function nativeStoreFor(store) {
|
|
1278
|
+
if (!nativeSearchCoreIsEnabled()) return null;
|
|
1279
|
+
const core = loadNativeCore();
|
|
1280
|
+
if (core === null) return null;
|
|
1281
|
+
let attached = attachedStores.get(store);
|
|
1282
|
+
if (attached !== void 0 && !stillCurrent(attached, store)) {
|
|
1283
|
+
detachNativeStore(store);
|
|
1284
|
+
attached = void 0;
|
|
1285
|
+
}
|
|
1286
|
+
if (attached === void 0) {
|
|
1287
|
+
attached = attach(core, store);
|
|
1288
|
+
attachedStores.set(store, attached);
|
|
1289
|
+
}
|
|
1290
|
+
return isUsable(attached) ? attached : null;
|
|
1320
1291
|
}
|
|
1321
|
-
function
|
|
1322
|
-
|
|
1292
|
+
function reserveOrdinals(store, count) {
|
|
1293
|
+
if (store.ordinals.length >= count) return;
|
|
1294
|
+
store.ordinals = new Int32Array(count);
|
|
1295
|
+
store.distances = new Float64Array(count);
|
|
1323
1296
|
}
|
|
1324
|
-
function
|
|
1325
|
-
|
|
1326
|
-
|
|
1297
|
+
function nativeScores(store, query, metric, count) {
|
|
1298
|
+
if (count === 0) return store.distances;
|
|
1299
|
+
let status;
|
|
1300
|
+
try {
|
|
1301
|
+
status = store.core.score(store.handle, query, nativeMetricCode(metric), store.ordinals, count, store.distances);
|
|
1302
|
+
} catch (error) {
|
|
1303
|
+
stopUsingTheNativeSearchCore(error);
|
|
1304
|
+
return null;
|
|
1305
|
+
}
|
|
1306
|
+
return status === NATIVE_OK ? store.distances : null;
|
|
1327
1307
|
}
|
|
1328
|
-
function
|
|
1329
|
-
|
|
1330
|
-
|
|
1331
|
-
|
|
1332
|
-
|
|
1333
|
-
|
|
1334
|
-
state.visited = next;
|
|
1308
|
+
function nativeScoresOf(handles, query, metric, ordinals) {
|
|
1309
|
+
const store = nativeStoreFor(handles);
|
|
1310
|
+
if (store === null) return null;
|
|
1311
|
+
reserveOrdinals(store, ordinals.length);
|
|
1312
|
+
store.ordinals.set(ordinals);
|
|
1313
|
+
return nativeScores(store, query, metric, ordinals.length);
|
|
1335
1314
|
}
|
|
1336
|
-
function
|
|
1337
|
-
|
|
1338
|
-
|
|
1339
|
-
|
|
1340
|
-
|
|
1315
|
+
function workOnRecords(handles, metric, ordinals, work) {
|
|
1316
|
+
if (ordinals.length === 0) return true;
|
|
1317
|
+
for (let attempt = 0; attempt < 2; attempt++) {
|
|
1318
|
+
const store = nativeStoreFor(handles);
|
|
1319
|
+
if (store === null) return false;
|
|
1320
|
+
let status;
|
|
1321
|
+
try {
|
|
1322
|
+
status = store.core[work](store.handle, nativeMetricCode(metric), ordinals, ordinals.length);
|
|
1323
|
+
} catch (error) {
|
|
1324
|
+
stopUsingTheNativeSearchCore(error);
|
|
1325
|
+
return false;
|
|
1326
|
+
}
|
|
1327
|
+
if (status === NATIVE_OK) return true;
|
|
1328
|
+
if (status !== NATIVE_NEEDS_ROOM) return false;
|
|
1329
|
+
detachNativeStore(handles);
|
|
1341
1330
|
}
|
|
1342
|
-
return
|
|
1331
|
+
return false;
|
|
1343
1332
|
}
|
|
1344
|
-
function
|
|
1345
|
-
|
|
1346
|
-
if (ord >= state.adjacency.handles.tombstones.byteLength) return false;
|
|
1347
|
-
state.tombstones = fixedView(state.adjacency.handles.tombstones, Uint8Array);
|
|
1348
|
-
return ord < state.tombstones.length;
|
|
1333
|
+
function nativeCalibrate(handles, metric, ordinals) {
|
|
1334
|
+
return workOnRecords(handles, metric, ordinals, "calibrate");
|
|
1349
1335
|
}
|
|
1350
|
-
function
|
|
1351
|
-
|
|
1336
|
+
function nativeQuantise(handles, metric, ordinals) {
|
|
1337
|
+
if (Atomics.load(handles.header, STORE_CALIBRATED) !== 1) return false;
|
|
1338
|
+
return workOnRecords(handles, metric, ordinals, "quantise");
|
|
1352
1339
|
}
|
|
1353
|
-
|
|
1354
|
-
|
|
1340
|
+
|
|
1341
|
+
// src/vector/ordinal-filter.ts
|
|
1342
|
+
function createOrdinalFilter(slots) {
|
|
1343
|
+
return { bits: new Uint8Array(slots + 7 >>> 3), count: 0 };
|
|
1355
1344
|
}
|
|
1356
|
-
function
|
|
1357
|
-
|
|
1345
|
+
function addToOrdinalFilter(filter, ordinal) {
|
|
1346
|
+
const index = ordinal >>> 3;
|
|
1347
|
+
if (index >= filter.bits.length) return;
|
|
1348
|
+
const bit = 1 << (ordinal & 7);
|
|
1349
|
+
if ((filter.bits[index] & bit) !== 0) return;
|
|
1350
|
+
filter.bits[index] |= bit;
|
|
1351
|
+
filter.count += 1;
|
|
1358
1352
|
}
|
|
1359
|
-
function
|
|
1360
|
-
|
|
1361
|
-
|
|
1362
|
-
|
|
1363
|
-
|
|
1364
|
-
|
|
1365
|
-
|
|
1366
|
-
|
|
1353
|
+
function ordinalFilterHas(filter, ordinal) {
|
|
1354
|
+
const index = ordinal >>> 3;
|
|
1355
|
+
if (index >= filter.bits.length) return false;
|
|
1356
|
+
return (filter.bits[index] & 1 << (ordinal & 7)) !== 0;
|
|
1357
|
+
}
|
|
1358
|
+
function removeFromOrdinalFilter(filter, ordinal) {
|
|
1359
|
+
const index = ordinal >>> 3;
|
|
1360
|
+
if (index >= filter.bits.length) return;
|
|
1361
|
+
const bit = 1 << (ordinal & 7);
|
|
1362
|
+
if ((filter.bits[index] & bit) === 0) return;
|
|
1363
|
+
filter.bits[index] &= ~bit;
|
|
1364
|
+
filter.count -= 1;
|
|
1365
|
+
}
|
|
1366
|
+
function* ordinalFilterValues(filter) {
|
|
1367
|
+
const bits = filter.bits;
|
|
1368
|
+
for (let index = 0; index < bits.length; index++) {
|
|
1369
|
+
const byte = bits[index];
|
|
1370
|
+
if (byte === 0) continue;
|
|
1371
|
+
for (let offset = 0; offset < 8; offset++) {
|
|
1372
|
+
if ((byte & 1 << offset) !== 0) yield index << 3 | offset;
|
|
1373
|
+
}
|
|
1367
1374
|
}
|
|
1368
1375
|
}
|
|
1369
|
-
|
|
1370
|
-
|
|
1371
|
-
|
|
1372
|
-
|
|
1373
|
-
|
|
1374
|
-
|
|
1375
|
-
|
|
1376
|
-
|
|
1376
|
+
|
|
1377
|
+
// src/vector/native/field.ts
|
|
1378
|
+
var WAKE_COUNT_WORDS = 1;
|
|
1379
|
+
var WAKES_THE_CORE_KEEPS_PER_CALL = 256;
|
|
1380
|
+
var WAKE_LIST_WORDS = WAKE_COUNT_WORDS + WAKES_THE_CORE_KEEPS_PER_CALL;
|
|
1381
|
+
var WAKE_ENTRY_LOCK = -1;
|
|
1382
|
+
var attachedGraphs = /* @__PURE__ */ new WeakMap();
|
|
1383
|
+
function graphMemory(graph) {
|
|
1384
|
+
const regions = [
|
|
1385
|
+
graph.header.buffer,
|
|
1386
|
+
graph.nodeLevels,
|
|
1387
|
+
graph.level0,
|
|
1388
|
+
graph.upperBase,
|
|
1389
|
+
graph.upper,
|
|
1390
|
+
graph.locks,
|
|
1391
|
+
graph.tombstones,
|
|
1392
|
+
graph.incoming,
|
|
1393
|
+
graph.heldLocks.buffer
|
|
1394
|
+
];
|
|
1395
|
+
if (!regions.every(isSharedMemory)) return null;
|
|
1396
|
+
return {
|
|
1397
|
+
graphHeader: graph.header,
|
|
1398
|
+
nodeLevels: fixedView(graph.nodeLevels, Uint8Array),
|
|
1399
|
+
level0: fixedView(graph.level0, Int32Array),
|
|
1400
|
+
upperBase: fixedView(graph.upperBase, Int32Array),
|
|
1401
|
+
upper: fixedView(graph.upper, Int32Array),
|
|
1402
|
+
locks: fixedView(graph.locks, Int32Array),
|
|
1403
|
+
tombstones: fixedView(graph.tombstones, Uint8Array),
|
|
1404
|
+
incoming: fixedView(graph.incoming, Int32Array),
|
|
1405
|
+
heldLocks: graph.heldLocks
|
|
1406
|
+
};
|
|
1407
|
+
}
|
|
1408
|
+
function attach2(core, state) {
|
|
1409
|
+
const memory = graphMemory(state.adjacency.handles);
|
|
1410
|
+
let handle = null;
|
|
1411
|
+
if (memory !== null) {
|
|
1412
|
+
try {
|
|
1413
|
+
handle = core.attachGraph(memory);
|
|
1414
|
+
} catch {
|
|
1415
|
+
handle = null;
|
|
1416
|
+
}
|
|
1377
1417
|
}
|
|
1418
|
+
return { handle, field: null };
|
|
1378
1419
|
}
|
|
1379
|
-
|
|
1380
|
-
|
|
1381
|
-
|
|
1382
|
-
|
|
1420
|
+
var workspaceOwner = null;
|
|
1421
|
+
function nativeScratchBytes(state, field) {
|
|
1422
|
+
const perField = field.store.ordinals.byteLength + field.store.distances.byteLength + field.wakes.byteLength;
|
|
1423
|
+
const owner = workspaceOwner?.deref();
|
|
1424
|
+
if (owner !== void 0 && owner !== state) return perField;
|
|
1425
|
+
workspaceOwner = new WeakRef(state);
|
|
1426
|
+
return perField + field.core.workspaceBytes();
|
|
1383
1427
|
}
|
|
1384
|
-
function
|
|
1385
|
-
|
|
1428
|
+
function attachedNativeField(state) {
|
|
1429
|
+
if (!nativeSearchCoreIsEnabled()) return null;
|
|
1430
|
+
return attachedGraphs.get(state)?.field ?? null;
|
|
1386
1431
|
}
|
|
1387
|
-
function
|
|
1388
|
-
|
|
1432
|
+
function nativeFieldFor(state) {
|
|
1433
|
+
if (!nativeSearchCoreIsEnabled()) return null;
|
|
1434
|
+
const core = loadNativeCore();
|
|
1435
|
+
if (core === null) return null;
|
|
1436
|
+
const store = nativeStoreFor(state.store.handles);
|
|
1437
|
+
if (store === null) return null;
|
|
1438
|
+
let attached = attachedGraphs.get(state);
|
|
1439
|
+
if (attached === void 0) {
|
|
1440
|
+
attached = attach2(core, state);
|
|
1441
|
+
attachedGraphs.set(state, attached);
|
|
1442
|
+
}
|
|
1443
|
+
if (attached.handle === null) return null;
|
|
1444
|
+
if (attached.field === null) {
|
|
1445
|
+
attached.field = { core, graph: attached.handle, store, wakes: new Int32Array(WAKE_LIST_WORDS) };
|
|
1446
|
+
}
|
|
1447
|
+
attached.field.store = store;
|
|
1448
|
+
return attached.field;
|
|
1389
1449
|
}
|
|
1390
|
-
function
|
|
1391
|
-
const
|
|
1392
|
-
if (
|
|
1393
|
-
|
|
1450
|
+
function wakeSleepingThreads(state, field) {
|
|
1451
|
+
const count = field.wakes[0];
|
|
1452
|
+
if (count === 0) return;
|
|
1453
|
+
field.wakes[0] = 0;
|
|
1454
|
+
for (let i = 1; i <= count; i++) {
|
|
1455
|
+
const ordinal = field.wakes[i];
|
|
1456
|
+
if (ordinal === WAKE_ENTRY_LOCK) {
|
|
1457
|
+
Atomics.notify(state.header, GRAPH_ENTRY_LOCK);
|
|
1458
|
+
continue;
|
|
1459
|
+
}
|
|
1460
|
+
if (ordinal < 0 || ordinal >= Atomics.load(state.header, GRAPH_SLOTS)) continue;
|
|
1461
|
+
Atomics.notify(state.locks.words(ordinal), ordinal);
|
|
1462
|
+
}
|
|
1394
1463
|
}
|
|
1395
|
-
|
|
1396
|
-
|
|
1397
|
-
|
|
1398
|
-
|
|
1464
|
+
|
|
1465
|
+
// src/vector/native/writes.ts
|
|
1466
|
+
var CALL_RAISED = -1;
|
|
1467
|
+
function writeToTheGraph(state, field, write) {
|
|
1468
|
+
let status;
|
|
1469
|
+
try {
|
|
1470
|
+
status = write();
|
|
1471
|
+
} catch (error) {
|
|
1472
|
+
stopUsingTheNativeSearchCore(error);
|
|
1473
|
+
return CALL_RAISED;
|
|
1399
1474
|
}
|
|
1400
|
-
|
|
1475
|
+
wakeSleepingThreads(state, field);
|
|
1476
|
+
return status;
|
|
1401
1477
|
}
|
|
1402
|
-
function
|
|
1403
|
-
const
|
|
1404
|
-
|
|
1405
|
-
|
|
1406
|
-
|
|
1407
|
-
|
|
1408
|
-
|
|
1409
|
-
|
|
1410
|
-
|
|
1411
|
-
|
|
1412
|
-
|
|
1413
|
-
|
|
1478
|
+
function nativePlace(state, field, metric, ordinal, topLayer, graphHeldAlone) {
|
|
1479
|
+
const status = writeToTheGraph(
|
|
1480
|
+
state,
|
|
1481
|
+
field,
|
|
1482
|
+
() => field.core.place(
|
|
1483
|
+
field.graph,
|
|
1484
|
+
field.store.handle,
|
|
1485
|
+
nativeMetricCode(metric),
|
|
1486
|
+
ordinal,
|
|
1487
|
+
topLayer,
|
|
1488
|
+
graphHeldAlone ? 1 : 0,
|
|
1489
|
+
state.locks.threadSlot,
|
|
1490
|
+
field.wakes
|
|
1491
|
+
)
|
|
1492
|
+
);
|
|
1493
|
+
if (status === NATIVE_OK) return "placed";
|
|
1494
|
+
return status === NATIVE_NEEDS_ROOM ? "needsRoom" : "failed";
|
|
1414
1495
|
}
|
|
1415
|
-
function
|
|
1416
|
-
const
|
|
1417
|
-
|
|
1418
|
-
return toDistance(qVec, entry.vector, qMag, entry.magnitude, metric);
|
|
1496
|
+
function nativeRemove(state, field, ordinal) {
|
|
1497
|
+
const remove = () => field.core.remove(field.graph, ordinal, state.locks.threadSlot, field.wakes);
|
|
1498
|
+
return writeToTheGraph(state, field, remove) === NATIVE_OK;
|
|
1419
1499
|
}
|
|
1420
|
-
function
|
|
1421
|
-
|
|
1500
|
+
function nativeCompact(state, field, metric) {
|
|
1501
|
+
const compact = () => field.core.compact(field.graph, field.store.handle, nativeMetricCode(metric), state.locks.threadSlot, field.wakes);
|
|
1502
|
+
return writeToTheGraph(state, field, compact) === NATIVE_OK;
|
|
1422
1503
|
}
|
|
1423
|
-
function
|
|
1424
|
-
|
|
1425
|
-
|
|
1426
|
-
|
|
1427
|
-
|
|
1504
|
+
function nativeConnect(state, field, metric, nearby) {
|
|
1505
|
+
const connect = () => field.core.connectUnreached(
|
|
1506
|
+
field.graph,
|
|
1507
|
+
field.store.handle,
|
|
1508
|
+
nativeMetricCode(metric),
|
|
1509
|
+
nearby,
|
|
1510
|
+
state.locks.threadSlot,
|
|
1511
|
+
field.wakes
|
|
1512
|
+
);
|
|
1513
|
+
return writeToTheGraph(state, field, connect) === NATIVE_OK;
|
|
1428
1514
|
}
|
|
1429
1515
|
|
|
1430
1516
|
// src/vector/hnsw/workspace.ts
|
|
@@ -1664,170 +1750,12 @@ function writeKeepingLastLinks(state, ord, sorted, kept, held) {
|
|
|
1664
1750
|
appendToList(kept, candidate, dropped.distances[i]);
|
|
1665
1751
|
continue;
|
|
1666
1752
|
}
|
|
1667
|
-
if (replaceFarthestShared(state, kept, held, candidate, dropped.distances[i])) continue;
|
|
1668
|
-
noteUnlinked(adjacency, candidate);
|
|
1669
|
-
noteNodeLeftUnlinked(state);
|
|
1670
|
-
}
|
|
1671
|
-
for (let k = 0; k < kept.size; k++) if (!held(kept.ords[k])) noteLinked(adjacency, kept.ords[k]);
|
|
1672
|
-
writeNeighbors(adjacency, ord, 0, kept.ords, kept.size);
|
|
1673
|
-
}
|
|
1674
|
-
|
|
1675
|
-
// src/vector/hnsw/locks.ts
|
|
1676
|
-
var FREE = 0;
|
|
1677
|
-
var EXCLUSIVE = -1;
|
|
1678
|
-
function openGraphLocks(handles, threadSlot) {
|
|
1679
|
-
let words = fixedView(handles.locks, Int32Array);
|
|
1680
|
-
return {
|
|
1681
|
-
threadSlot,
|
|
1682
|
-
header: handles.header,
|
|
1683
|
-
held: handles.heldLocks,
|
|
1684
|
-
words(ord) {
|
|
1685
|
-
if (ord < words.length) return words;
|
|
1686
|
-
if (ord * 4 >= handles.locks.byteLength) growBufferTo(handles.locks, (ord + 1) * 4);
|
|
1687
|
-
words = fixedView(handles.locks, Int32Array);
|
|
1688
|
-
return words;
|
|
1689
|
-
}
|
|
1690
|
-
};
|
|
1691
|
-
}
|
|
1692
|
-
var blockingAllowed = typeof document === "undefined";
|
|
1693
|
-
function canWait(words) {
|
|
1694
|
-
return blockingAllowed && sharedMemoryAvailable() && words.buffer instanceof SharedArrayBuffer;
|
|
1695
|
-
}
|
|
1696
|
-
function waitOn(words, index, seen, sliceMs = LOCK_WAIT_SLICE_MS) {
|
|
1697
|
-
if (!canWait(words)) return;
|
|
1698
|
-
Atomics.wait(words, index, seen, sliceMs);
|
|
1699
|
-
}
|
|
1700
|
-
function heldIndex(locks, kind) {
|
|
1701
|
-
return locks.threadSlot * HELD_WORDS_PER_THREAD + kind;
|
|
1702
|
-
}
|
|
1703
|
-
function acquireExclusive(words, index) {
|
|
1704
|
-
let spins = 0;
|
|
1705
|
-
for (; ; ) {
|
|
1706
|
-
const seen = Atomics.compareExchange(words, index, FREE, EXCLUSIVE);
|
|
1707
|
-
if (seen === FREE) return;
|
|
1708
|
-
if (spins < LOCK_SPIN_ITERATIONS) {
|
|
1709
|
-
spins += 1;
|
|
1710
|
-
continue;
|
|
1711
|
-
}
|
|
1712
|
-
waitOn(words, index, seen, GRAPH_LOCK_WAIT_SLICE_MS);
|
|
1713
|
-
}
|
|
1714
|
-
}
|
|
1715
|
-
function releaseExclusive(words, index) {
|
|
1716
|
-
Atomics.store(words, index, FREE);
|
|
1717
|
-
if (canWait(words)) Atomics.notify(words, index);
|
|
1718
|
-
}
|
|
1719
|
-
var WRITE_HELD = 1;
|
|
1720
|
-
var WRITER_WAITING = 2;
|
|
1721
|
-
var VERSION_STEP = 4;
|
|
1722
|
-
function beginNodeRead(locks, ord) {
|
|
1723
|
-
const words = locks.words(ord);
|
|
1724
|
-
for (; ; ) {
|
|
1725
|
-
const seen = Atomics.load(words, ord);
|
|
1726
|
-
if ((seen & WRITE_HELD) === 0) return seen;
|
|
1727
|
-
}
|
|
1728
|
-
}
|
|
1729
|
-
function nodeReadHeld(locks, ord, version) {
|
|
1730
|
-
Atomics.add(locks.held, heldIndex(locks, HELD_FENCE), 0);
|
|
1731
|
-
return Atomics.load(locks.words(ord), ord) === version;
|
|
1732
|
-
}
|
|
1733
|
-
function lockNodeWrite(locks, ord) {
|
|
1734
|
-
const words = locks.words(ord);
|
|
1735
|
-
let spins = 0;
|
|
1736
|
-
for (; ; ) {
|
|
1737
|
-
const seen = Atomics.load(words, ord);
|
|
1738
|
-
if ((seen & WRITE_HELD) === 0) {
|
|
1739
|
-
const claimed = seen | WRITE_HELD;
|
|
1740
|
-
if (Atomics.compareExchange(words, ord, seen, claimed) === seen) {
|
|
1741
|
-
Atomics.store(locks.held, heldIndex(locks, HELD_WRITE_VERSION), claimed);
|
|
1742
|
-
Atomics.store(locks.held, heldIndex(locks, HELD_WRITE), ord + 1);
|
|
1743
|
-
return;
|
|
1744
|
-
}
|
|
1745
|
-
continue;
|
|
1746
|
-
}
|
|
1747
|
-
if (spins < LOCK_SPIN_ITERATIONS) {
|
|
1748
|
-
spins += 1;
|
|
1749
|
-
continue;
|
|
1750
|
-
}
|
|
1751
|
-
const waiting = seen | WRITER_WAITING;
|
|
1752
|
-
if (waiting === seen || Atomics.compareExchange(words, ord, seen, waiting) === seen) {
|
|
1753
|
-
waitOn(words, ord, waiting);
|
|
1754
|
-
}
|
|
1755
|
-
}
|
|
1756
|
-
}
|
|
1757
|
-
function releaseWrite(words, ord) {
|
|
1758
|
-
const seen = Atomics.load(words, ord);
|
|
1759
|
-
const previous = Atomics.exchange(words, ord, (seen & -4) + VERSION_STEP);
|
|
1760
|
-
if ((previous & WRITER_WAITING) !== 0 && canWait(words)) Atomics.notify(words, ord);
|
|
1761
|
-
}
|
|
1762
|
-
function unlockNodeWrite(locks, ord) {
|
|
1763
|
-
releaseWrite(locks.words(ord), ord);
|
|
1764
|
-
Atomics.store(locks.held, heldIndex(locks, HELD_WRITE), 0);
|
|
1765
|
-
}
|
|
1766
|
-
function lockGraphShared(locks) {
|
|
1767
|
-
const { header } = locks;
|
|
1768
|
-
let spins = 0;
|
|
1769
|
-
for (; ; ) {
|
|
1770
|
-
const seen = Atomics.load(header, GRAPH_LOCK);
|
|
1771
|
-
if (seen >= FREE && Atomics.load(header, GRAPH_WRITERS_WAITING) === 0) {
|
|
1772
|
-
if (Atomics.compareExchange(header, GRAPH_LOCK, seen, seen + 1) === seen) {
|
|
1773
|
-
Atomics.store(locks.held, heldIndex(locks, HELD_GRAPH), 1);
|
|
1774
|
-
return;
|
|
1775
|
-
}
|
|
1776
|
-
continue;
|
|
1777
|
-
}
|
|
1778
|
-
if (spins < LOCK_SPIN_ITERATIONS) {
|
|
1779
|
-
spins += 1;
|
|
1780
|
-
continue;
|
|
1781
|
-
}
|
|
1782
|
-
waitOn(header, GRAPH_LOCK, seen, GRAPH_LOCK_WAIT_SLICE_MS);
|
|
1783
|
-
}
|
|
1784
|
-
}
|
|
1785
|
-
function unlockGraphShared(locks) {
|
|
1786
|
-
const { header } = locks;
|
|
1787
|
-
Atomics.store(locks.held, heldIndex(locks, HELD_GRAPH), 0);
|
|
1788
|
-
if (Atomics.sub(header, GRAPH_LOCK, 1) === 1 && canWait(header)) Atomics.notify(header, GRAPH_LOCK);
|
|
1789
|
-
}
|
|
1790
|
-
function lockGraphExclusive(locks) {
|
|
1791
|
-
Atomics.store(locks.held, heldIndex(locks, HELD_GRAPH_WAITING), 1);
|
|
1792
|
-
Atomics.add(locks.header, GRAPH_WRITERS_WAITING, 1);
|
|
1793
|
-
try {
|
|
1794
|
-
acquireExclusive(locks.header, GRAPH_LOCK);
|
|
1795
|
-
} finally {
|
|
1796
|
-
Atomics.sub(locks.header, GRAPH_WRITERS_WAITING, 1);
|
|
1797
|
-
Atomics.store(locks.held, heldIndex(locks, HELD_GRAPH_WAITING), 0);
|
|
1798
|
-
}
|
|
1799
|
-
}
|
|
1800
|
-
function unlockGraphExclusive(locks) {
|
|
1801
|
-
releaseExclusive(locks.header, GRAPH_LOCK);
|
|
1802
|
-
}
|
|
1803
|
-
function lockEntry(locks) {
|
|
1804
|
-
acquireExclusive(locks.header, GRAPH_ENTRY_LOCK);
|
|
1805
|
-
}
|
|
1806
|
-
function unlockEntry(locks) {
|
|
1807
|
-
releaseExclusive(locks.header, GRAPH_ENTRY_LOCK);
|
|
1808
|
-
}
|
|
1809
|
-
function releaseLocksHeldBy(handles, threadSlot) {
|
|
1810
|
-
const held = handles.heldLocks;
|
|
1811
|
-
const words = new Int32Array(handles.locks);
|
|
1812
|
-
const base = threadSlot * HELD_WORDS_PER_THREAD;
|
|
1813
|
-
if (Atomics.exchange(held, base + HELD_GRAPH_WAITING, 0) === 1) {
|
|
1814
|
-
Atomics.sub(handles.header, GRAPH_WRITERS_WAITING, 1);
|
|
1815
|
-
}
|
|
1816
|
-
const writeOrd = Atomics.exchange(held, base + HELD_WRITE, 0) - 1;
|
|
1817
|
-
const writeVersion = Atomics.load(held, base + HELD_WRITE_VERSION);
|
|
1818
|
-
if (writeOrd >= 0 && writeOrd < words.length) {
|
|
1819
|
-
const seen = Atomics.load(words, writeOrd);
|
|
1820
|
-
if ((seen & ~WRITER_WAITING) === writeVersion) releaseWrite(words, writeOrd);
|
|
1821
|
-
}
|
|
1822
|
-
if (Atomics.exchange(held, base + HELD_GRAPH, 0) !== 1) return;
|
|
1823
|
-
for (; ; ) {
|
|
1824
|
-
const readers = Atomics.load(handles.header, GRAPH_LOCK);
|
|
1825
|
-
if (readers <= FREE) return;
|
|
1826
|
-
if (Atomics.compareExchange(handles.header, GRAPH_LOCK, readers, readers - 1) === readers) {
|
|
1827
|
-
if (canWait(handles.header)) Atomics.notify(handles.header, GRAPH_LOCK);
|
|
1828
|
-
return;
|
|
1829
|
-
}
|
|
1753
|
+
if (replaceFarthestShared(state, kept, held, candidate, dropped.distances[i])) continue;
|
|
1754
|
+
noteUnlinked(adjacency, candidate);
|
|
1755
|
+
noteNodeLeftUnlinked(state);
|
|
1830
1756
|
}
|
|
1757
|
+
for (let k = 0; k < kept.size; k++) if (!held(kept.ords[k])) noteLinked(adjacency, kept.ords[k]);
|
|
1758
|
+
writeNeighbors(adjacency, ord, 0, kept.ords, kept.size);
|
|
1831
1759
|
}
|
|
1832
1760
|
|
|
1833
1761
|
// src/vector/hnsw/connect-unreached.ts
|
|
@@ -2420,42 +2348,6 @@ function rebuild(state) {
|
|
|
2420
2348
|
}
|
|
2421
2349
|
}
|
|
2422
2350
|
|
|
2423
|
-
// src/vector/ordinal-filter.ts
|
|
2424
|
-
function createOrdinalFilter(slots) {
|
|
2425
|
-
return { bits: new Uint8Array(slots + 7 >>> 3), count: 0 };
|
|
2426
|
-
}
|
|
2427
|
-
function addToOrdinalFilter(filter, ordinal) {
|
|
2428
|
-
const index = ordinal >>> 3;
|
|
2429
|
-
if (index >= filter.bits.length) return;
|
|
2430
|
-
const bit = 1 << (ordinal & 7);
|
|
2431
|
-
if ((filter.bits[index] & bit) !== 0) return;
|
|
2432
|
-
filter.bits[index] |= bit;
|
|
2433
|
-
filter.count += 1;
|
|
2434
|
-
}
|
|
2435
|
-
function ordinalFilterHas(filter, ordinal) {
|
|
2436
|
-
const index = ordinal >>> 3;
|
|
2437
|
-
if (index >= filter.bits.length) return false;
|
|
2438
|
-
return (filter.bits[index] & 1 << (ordinal & 7)) !== 0;
|
|
2439
|
-
}
|
|
2440
|
-
function removeFromOrdinalFilter(filter, ordinal) {
|
|
2441
|
-
const index = ordinal >>> 3;
|
|
2442
|
-
if (index >= filter.bits.length) return;
|
|
2443
|
-
const bit = 1 << (ordinal & 7);
|
|
2444
|
-
if ((filter.bits[index] & bit) === 0) return;
|
|
2445
|
-
filter.bits[index] &= ~bit;
|
|
2446
|
-
filter.count -= 1;
|
|
2447
|
-
}
|
|
2448
|
-
function* ordinalFilterValues(filter) {
|
|
2449
|
-
const bits = filter.bits;
|
|
2450
|
-
for (let index = 0; index < bits.length; index++) {
|
|
2451
|
-
const byte = bits[index];
|
|
2452
|
-
if (byte === 0) continue;
|
|
2453
|
-
for (let offset = 0; offset < 8; offset++) {
|
|
2454
|
-
if ((byte & 1 << offset) !== 0) yield index << 3 | offset;
|
|
2455
|
-
}
|
|
2456
|
-
}
|
|
2457
|
-
}
|
|
2458
|
-
|
|
2459
2351
|
// src/vector/native/walk.ts
|
|
2460
2352
|
function copyCandidates(store, count, target) {
|
|
2461
2353
|
ensureListCapacity(target, count);
|
|
@@ -3135,475 +3027,6 @@ function openSharedQuantizer(store, layout, metric) {
|
|
|
3135
3027
|
}
|
|
3136
3028
|
};
|
|
3137
3029
|
}
|
|
3138
|
-
function createVectorFileReader() {
|
|
3139
|
-
const descriptors = /* @__PURE__ */ new Map();
|
|
3140
|
-
function descriptorOf(path) {
|
|
3141
|
-
const open = descriptors.get(path);
|
|
3142
|
-
if (open !== void 0) return open;
|
|
3143
|
-
try {
|
|
3144
|
-
const descriptor = openSync(path, "r");
|
|
3145
|
-
descriptors.set(path, descriptor);
|
|
3146
|
-
return descriptor;
|
|
3147
|
-
} catch {
|
|
3148
|
-
return null;
|
|
3149
|
-
}
|
|
3150
|
-
}
|
|
3151
|
-
function closeDescriptor(path, descriptor) {
|
|
3152
|
-
descriptors.delete(path);
|
|
3153
|
-
try {
|
|
3154
|
-
closeSync(descriptor);
|
|
3155
|
-
} catch {
|
|
3156
|
-
}
|
|
3157
|
-
}
|
|
3158
|
-
return {
|
|
3159
|
-
readInto(path, offset, target) {
|
|
3160
|
-
const descriptor = descriptorOf(path);
|
|
3161
|
-
if (descriptor === null) return false;
|
|
3162
|
-
let read = 0;
|
|
3163
|
-
while (read < target.byteLength) {
|
|
3164
|
-
let chunk;
|
|
3165
|
-
try {
|
|
3166
|
-
chunk = readSync(descriptor, target, read, target.byteLength - read, offset + read);
|
|
3167
|
-
} catch {
|
|
3168
|
-
closeDescriptor(path, descriptor);
|
|
3169
|
-
return false;
|
|
3170
|
-
}
|
|
3171
|
-
if (chunk <= 0) return false;
|
|
3172
|
-
read += chunk;
|
|
3173
|
-
}
|
|
3174
|
-
return true;
|
|
3175
|
-
},
|
|
3176
|
-
retainOnly(paths) {
|
|
3177
|
-
for (const [path, descriptor] of descriptors) {
|
|
3178
|
-
if (!paths.has(path)) closeDescriptor(path, descriptor);
|
|
3179
|
-
}
|
|
3180
|
-
},
|
|
3181
|
-
close() {
|
|
3182
|
-
for (const [path, descriptor] of descriptors) closeDescriptor(path, descriptor);
|
|
3183
|
-
}
|
|
3184
|
-
};
|
|
3185
|
-
}
|
|
3186
|
-
|
|
3187
|
-
// src/vector/vector-store/hot-block-distance.ts
|
|
3188
|
-
function jsDistance(a, b, magA, magB, metric) {
|
|
3189
|
-
switch (metric) {
|
|
3190
|
-
case "cosine":
|
|
3191
|
-
return 1 - cosineSimilarityWithMagnitudes(a, b, magA, magB);
|
|
3192
|
-
case "dotProduct":
|
|
3193
|
-
return -dotProduct(a, b);
|
|
3194
|
-
case "euclidean":
|
|
3195
|
-
return euclideanDistance(a, b);
|
|
3196
|
-
}
|
|
3197
|
-
}
|
|
3198
|
-
function inMemory(reads, ordinal) {
|
|
3199
|
-
return ordinal >= 0 && ordinal < reads.limit && reads.diskFile[ordinal] === IN_MEMORY;
|
|
3200
|
-
}
|
|
3201
|
-
function queryDistanceOf(source, prepared, metric) {
|
|
3202
|
-
const generic = (ordinal) => source.distanceFromArena(prepared, ordinal, metric);
|
|
3203
|
-
const reads = source.hotBlockReads();
|
|
3204
|
-
const simd = reads?.block.simd ?? null;
|
|
3205
|
-
if (reads === null || simd === null || !reads.block.hasScratch) return generic;
|
|
3206
|
-
const { block, present, magnitudes, slotsOffset, slotStride, dimension } = reads;
|
|
3207
|
-
const scratchOffset = block.scratchByteOffset;
|
|
3208
|
-
const queryMagnitude = prepared.magnitude;
|
|
3209
|
-
return (ordinal) => {
|
|
3210
|
-
if (!inMemory(reads, ordinal) || block.stagedOrdinal !== QUERY_STAGED) return generic(ordinal);
|
|
3211
|
-
if (present[ordinal] !== 1) return Number.POSITIVE_INFINITY;
|
|
3212
|
-
const slotOffset = slotsOffset + ordinal * slotStride;
|
|
3213
|
-
return arenaFloat32Distance(simd, scratchOffset, slotOffset, dimension, metric, queryMagnitude, magnitudes[ordinal]);
|
|
3214
|
-
};
|
|
3215
|
-
}
|
|
3216
|
-
function pairDistanceOf(source, metric) {
|
|
3217
|
-
const generic = (ordA, ordB) => source.distanceByOrdinal(ordA, ordB, metric);
|
|
3218
|
-
const reads = source.hotBlockReads();
|
|
3219
|
-
const simd = reads?.block.simd ?? null;
|
|
3220
|
-
if (reads === null || simd === null) return generic;
|
|
3221
|
-
const { present, magnitudes, slotsOffset, slotStride, dimension } = reads;
|
|
3222
|
-
return (ordA, ordB) => {
|
|
3223
|
-
if (!inMemory(reads, ordA) || !inMemory(reads, ordB) || present[ordA] !== 1) return generic(ordA, ordB);
|
|
3224
|
-
if (present[ordB] !== 1) return Number.POSITIVE_INFINITY;
|
|
3225
|
-
const offsetA = slotsOffset + ordA * slotStride;
|
|
3226
|
-
const offsetB = slotsOffset + ordB * slotStride;
|
|
3227
|
-
return arenaFloat32Distance(simd, offsetA, offsetB, dimension, metric, magnitudes[ordA], magnitudes[ordB]);
|
|
3228
|
-
};
|
|
3229
|
-
}
|
|
3230
|
-
function ordinalDistanceOf(source, from, metric) {
|
|
3231
|
-
const pair = pairDistanceOf(source, metric);
|
|
3232
|
-
return (ordinal) => pair(from, ordinal);
|
|
3233
|
-
}
|
|
3234
|
-
|
|
3235
|
-
// src/vector/vector-store/view.ts
|
|
3236
|
-
var decoder = new TextDecoder();
|
|
3237
|
-
var NOT_HELD = 0;
|
|
3238
|
-
var HELD_COLD = 1;
|
|
3239
|
-
var HELD_HOT = 2;
|
|
3240
|
-
function openSharedVectorStore(initial, threadSlot) {
|
|
3241
|
-
let handles = initial;
|
|
3242
|
-
const { dimension, layout } = initial;
|
|
3243
|
-
const capacity = layout.capacity;
|
|
3244
|
-
const codeCapacity = initial.codeLayout?.capacity ?? 1;
|
|
3245
|
-
const blocks = [];
|
|
3246
|
-
const codeBlocks = [];
|
|
3247
|
-
let present = fixedView(handles.present, Uint8Array);
|
|
3248
|
-
let magnitudes = fixedView(handles.magnitudes, Float64Array);
|
|
3249
|
-
let partitions = fixedView(handles.partitions, Int32Array);
|
|
3250
|
-
let docIdBytes = fixedView(handles.docIdBytes, Uint8Array);
|
|
3251
|
-
let docIdOffsets = fixedView(handles.docIdOffsets, Uint32Array);
|
|
3252
|
-
let diskFile = fixedView(handles.diskFile, Int32Array);
|
|
3253
|
-
let diskOffset = fixedView(handles.diskOffset, Uint32Array);
|
|
3254
|
-
let currentQuery = null;
|
|
3255
|
-
let reader = null;
|
|
3256
|
-
const coldScratchA = new Float32Array(dimension);
|
|
3257
|
-
const coldScratchB = new Float32Array(dimension);
|
|
3258
|
-
function rebind() {
|
|
3259
|
-
present = fixedView(handles.present, Uint8Array);
|
|
3260
|
-
magnitudes = fixedView(handles.magnitudes, Float64Array);
|
|
3261
|
-
partitions = fixedView(handles.partitions, Int32Array);
|
|
3262
|
-
docIdBytes = fixedView(handles.docIdBytes, Uint8Array);
|
|
3263
|
-
docIdOffsets = fixedView(handles.docIdOffsets, Uint32Array);
|
|
3264
|
-
diskFile = fixedView(handles.diskFile, Int32Array);
|
|
3265
|
-
diskOffset = fixedView(handles.diskOffset, Uint32Array);
|
|
3266
|
-
}
|
|
3267
|
-
function blockAt(index) {
|
|
3268
|
-
let block = blocks[index];
|
|
3269
|
-
if (block === void 0) {
|
|
3270
|
-
const handle = handles.blocks[index];
|
|
3271
|
-
if (handle === null || handle === void 0) {
|
|
3272
|
-
throw new Error(`Vector block ${index} holds no vectors on this thread`);
|
|
3273
|
-
}
|
|
3274
|
-
block = openVectorBlock(handle, threadSlot);
|
|
3275
|
-
blocks[index] = block;
|
|
3276
|
-
}
|
|
3277
|
-
return block;
|
|
3278
|
-
}
|
|
3279
|
-
function codeBlockAt(index) {
|
|
3280
|
-
let block = codeBlocks[index];
|
|
3281
|
-
if (block === void 0) {
|
|
3282
|
-
block = openVectorBlock(handles.codeBlocks[index], threadSlot);
|
|
3283
|
-
codeBlocks[index] = block;
|
|
3284
|
-
}
|
|
3285
|
-
return block;
|
|
3286
|
-
}
|
|
3287
|
-
function fileOf(ordinal) {
|
|
3288
|
-
if (ordinal >= diskFile.length) {
|
|
3289
|
-
if (ordinal * 4 >= handles.diskFile.byteLength) return IN_MEMORY;
|
|
3290
|
-
rebind();
|
|
3291
|
-
}
|
|
3292
|
-
return diskFile[ordinal];
|
|
3293
|
-
}
|
|
3294
|
-
function isCold(ordinal) {
|
|
3295
|
-
return fileOf(ordinal) !== IN_MEMORY;
|
|
3296
|
-
}
|
|
3297
|
-
function holdState(ordinal) {
|
|
3298
|
-
if (ordinal < 0) return NOT_HELD;
|
|
3299
|
-
if (ordinal >= present.length) {
|
|
3300
|
-
if (ordinal >= handles.present.byteLength) return NOT_HELD;
|
|
3301
|
-
rebind();
|
|
3302
|
-
}
|
|
3303
|
-
if (present[ordinal] !== 1) return NOT_HELD;
|
|
3304
|
-
if (isCold(ordinal)) return HELD_COLD;
|
|
3305
|
-
const index = Math.floor(ordinal / capacity);
|
|
3306
|
-
return index < handles.blocks.length && handles.blocks[index] !== null ? HELD_HOT : NOT_HELD;
|
|
3307
|
-
}
|
|
3308
|
-
function holds2(ordinal) {
|
|
3309
|
-
return holdState(ordinal) !== NOT_HELD;
|
|
3310
|
-
}
|
|
3311
|
-
function readFromFile(file, offset, target) {
|
|
3312
|
-
const path = handles.vectorFiles[file];
|
|
3313
|
-
if (path === void 0 || path.length === 0) return false;
|
|
3314
|
-
if (reader === null) reader = createVectorFileReader();
|
|
3315
|
-
const bytes = new Uint8Array(target.buffer, target.byteOffset, target.byteLength);
|
|
3316
|
-
return reader.readInto(path, offset, bytes);
|
|
3317
|
-
}
|
|
3318
|
-
function readColdInto(ordinal, target) {
|
|
3319
|
-
const file = fileOf(ordinal);
|
|
3320
|
-
if (file === IN_MEMORY) return false;
|
|
3321
|
-
if (ordinal >= diskOffset.length) rebind();
|
|
3322
|
-
return readFromFile(file, diskOffset[ordinal], target);
|
|
3323
|
-
}
|
|
3324
|
-
function vectorIn(block, local) {
|
|
3325
|
-
const base = slotByteOffset(layout, local) / 4;
|
|
3326
|
-
return block.float32(base + dimension).subarray(base, base + dimension);
|
|
3327
|
-
}
|
|
3328
|
-
function hotVector(ordinal) {
|
|
3329
|
-
return vectorIn(blockAt(ordinal / capacity | 0), ordinal % capacity);
|
|
3330
|
-
}
|
|
3331
|
-
function vectorFor(ordinal, scratch) {
|
|
3332
|
-
if (!isCold(ordinal)) return hotVector(ordinal);
|
|
3333
|
-
return readColdInto(ordinal, scratch) ? scratch : null;
|
|
3334
|
-
}
|
|
3335
|
-
function stageVector(block, ordinal) {
|
|
3336
|
-
if (block.stagedOrdinal === ordinal) return true;
|
|
3337
|
-
const source = vectorFor(ordinal, coldScratchA);
|
|
3338
|
-
if (source === null) return false;
|
|
3339
|
-
block.float32(block.scratchByteOffset / 4 + dimension).set(source, block.scratchByteOffset / 4);
|
|
3340
|
-
block.stagedOrdinal = ordinal;
|
|
3341
|
-
return true;
|
|
3342
|
-
}
|
|
3343
|
-
function hotBlockReads() {
|
|
3344
|
-
const handle = handles.blocks[0];
|
|
3345
|
-
if (handle === null || handle === void 0) return null;
|
|
3346
|
-
const { slotsOffset, slotStride } = layout;
|
|
3347
|
-
const limit = Math.min(present.length, diskFile.length, magnitudes.length, capacity);
|
|
3348
|
-
return { block: blockAt(0), present, diskFile, magnitudes, limit, slotsOffset, slotStride, dimension };
|
|
3349
|
-
}
|
|
3350
|
-
function stageQuery(block) {
|
|
3351
|
-
if (currentQuery === null) return false;
|
|
3352
|
-
if (block.stagedOrdinal !== QUERY_STAGED) {
|
|
3353
|
-
block.float32(block.scratchByteOffset / 4 + dimension).set(currentQuery, block.scratchByteOffset / 4);
|
|
3354
|
-
block.stagedOrdinal = QUERY_STAGED;
|
|
3355
|
-
}
|
|
3356
|
-
return true;
|
|
3357
|
-
}
|
|
3358
|
-
const view = {
|
|
3359
|
-
dimension,
|
|
3360
|
-
threadSlot,
|
|
3361
|
-
get handles() {
|
|
3362
|
-
return handles;
|
|
3363
|
-
},
|
|
3364
|
-
get slots() {
|
|
3365
|
-
return Atomics.load(handles.header, STORE_SLOTS);
|
|
3366
|
-
},
|
|
3367
|
-
get simdAvailable() {
|
|
3368
|
-
const first = handles.blocks.find((block2) => block2 !== null);
|
|
3369
|
-
if (first === void 0) return false;
|
|
3370
|
-
const block = blockAt(handles.blocks.indexOf(first));
|
|
3371
|
-
return block.simd !== null && block.hasScratch;
|
|
3372
|
-
},
|
|
3373
|
-
get holdsEveryBlock() {
|
|
3374
|
-
return Atomics.load(handles.header, STORE_BLOCK_COUNT) <= handles.blocks.length && Atomics.load(handles.header, STORE_CODE_BLOCK_COUNT) <= handles.codeBlocks.length;
|
|
3375
|
-
},
|
|
3376
|
-
adoptHandles(next) {
|
|
3377
|
-
detachNativeStore(handles);
|
|
3378
|
-
handles = next;
|
|
3379
|
-
rebind();
|
|
3380
|
-
for (let index = 0; index < next.blocks.length; index++) {
|
|
3381
|
-
if (next.blocks[index] === null) blocks[index] = void 0;
|
|
3382
|
-
else if (blocks[index] === void 0) blockAt(index);
|
|
3383
|
-
}
|
|
3384
|
-
for (let index = codeBlocks.length; index < next.codeBlocks.length; index++) codeBlockAt(index);
|
|
3385
|
-
reader?.retainOnly(new Set(next.vectorFiles.filter((path) => path.length > 0)));
|
|
3386
|
-
},
|
|
3387
|
-
rebind,
|
|
3388
|
-
holdsOrdinal: holds2,
|
|
3389
|
-
isCold,
|
|
3390
|
-
readColdInto,
|
|
3391
|
-
readFromFile,
|
|
3392
|
-
close() {
|
|
3393
|
-
detachNativeStore(handles);
|
|
3394
|
-
reader?.close();
|
|
3395
|
-
reader = null;
|
|
3396
|
-
},
|
|
3397
|
-
blockOf(ordinal) {
|
|
3398
|
-
return blockAt(ordinal / capacity | 0);
|
|
3399
|
-
},
|
|
3400
|
-
localOrdinal(ordinal) {
|
|
3401
|
-
return ordinal % capacity;
|
|
3402
|
-
},
|
|
3403
|
-
codeBlockOf(ordinal) {
|
|
3404
|
-
return codeBlockAt(ordinal / codeCapacity | 0);
|
|
3405
|
-
},
|
|
3406
|
-
codeLocalOrdinal(ordinal) {
|
|
3407
|
-
return ordinal % codeCapacity;
|
|
3408
|
-
},
|
|
3409
|
-
openCodeBlocks() {
|
|
3410
|
-
return codeBlocks;
|
|
3411
|
-
},
|
|
3412
|
-
vectorAt(ordinal) {
|
|
3413
|
-
if (!isCold(ordinal)) return hotVector(ordinal);
|
|
3414
|
-
const copy = new Float32Array(dimension);
|
|
3415
|
-
if (!readColdInto(ordinal, copy)) {
|
|
3416
|
-
throw new NarsilError(
|
|
3417
|
-
ErrorCodes.PERSISTENCE_LOAD_FAILED,
|
|
3418
|
-
`The vector at ordinal ${ordinal} is missing from its checkpoint file`,
|
|
3419
|
-
{ ordinal, path: handles.vectorFiles[fileOf(ordinal)] }
|
|
3420
|
-
);
|
|
3421
|
-
}
|
|
3422
|
-
return copy;
|
|
3423
|
-
},
|
|
3424
|
-
magnitudeAt(ordinal) {
|
|
3425
|
-
if (ordinal >= magnitudes.length) rebind();
|
|
3426
|
-
return magnitudes[ordinal];
|
|
3427
|
-
},
|
|
3428
|
-
entryForOrdinal(ordinal) {
|
|
3429
|
-
if (!holds2(ordinal)) return void 0;
|
|
3430
|
-
return { vector: view.vectorAt(ordinal), magnitude: magnitudes[ordinal] };
|
|
3431
|
-
},
|
|
3432
|
-
docIdAt(ordinal) {
|
|
3433
|
-
if (ordinal < 0 || ordinal >= view.slots) return void 0;
|
|
3434
|
-
if (ordinal + 1 >= docIdOffsets.length) rebind();
|
|
3435
|
-
const start = docIdOffsets[ordinal];
|
|
3436
|
-
const end = docIdOffsets[ordinal + 1];
|
|
3437
|
-
if (end <= start) return void 0;
|
|
3438
|
-
if (end > docIdBytes.length) rebind();
|
|
3439
|
-
return decoder.decode(docIdBytes.subarray(start, end));
|
|
3440
|
-
},
|
|
3441
|
-
partitionAt(ordinal) {
|
|
3442
|
-
if (ordinal < 0) return void 0;
|
|
3443
|
-
if (ordinal >= partitions.length) {
|
|
3444
|
-
if (ordinal * 4 >= handles.partitions.byteLength) return void 0;
|
|
3445
|
-
rebind();
|
|
3446
|
-
}
|
|
3447
|
-
const partition = partitions[ordinal];
|
|
3448
|
-
return partition < 0 ? void 0 : partition;
|
|
3449
|
-
},
|
|
3450
|
-
distanceByOrdinal(ordA, ordB, metric) {
|
|
3451
|
-
if (!holds2(ordA) || !holds2(ordB)) return Number.POSITIVE_INFINITY;
|
|
3452
|
-
if (!isCold(ordB)) {
|
|
3453
|
-
const indexA = ordA / capacity | 0;
|
|
3454
|
-
const indexB = ordB / capacity | 0;
|
|
3455
|
-
const blockB = blockAt(indexB);
|
|
3456
|
-
const localB = ordB % capacity;
|
|
3457
|
-
if (blockB.simd !== null) {
|
|
3458
|
-
if (indexA === indexB && !isCold(ordA)) {
|
|
3459
|
-
return arenaFloat32Distance(
|
|
3460
|
-
blockB.simd,
|
|
3461
|
-
slotByteOffset(layout, ordA % capacity),
|
|
3462
|
-
slotByteOffset(layout, localB),
|
|
3463
|
-
dimension,
|
|
3464
|
-
metric,
|
|
3465
|
-
magnitudes[ordA],
|
|
3466
|
-
magnitudes[ordB]
|
|
3467
|
-
);
|
|
3468
|
-
}
|
|
3469
|
-
if (blockB.hasScratch && stageVector(blockB, ordA)) {
|
|
3470
|
-
return arenaFloat32Distance(
|
|
3471
|
-
blockB.simd,
|
|
3472
|
-
blockB.scratchByteOffset,
|
|
3473
|
-
slotByteOffset(layout, localB),
|
|
3474
|
-
dimension,
|
|
3475
|
-
metric,
|
|
3476
|
-
magnitudes[ordA],
|
|
3477
|
-
magnitudes[ordB]
|
|
3478
|
-
);
|
|
3479
|
-
}
|
|
3480
|
-
}
|
|
3481
|
-
}
|
|
3482
|
-
const a = vectorFor(ordA, coldScratchA);
|
|
3483
|
-
const b = vectorFor(ordB, coldScratchB);
|
|
3484
|
-
if (a === null || b === null) return Number.POSITIVE_INFINITY;
|
|
3485
|
-
return jsDistance(a, b, magnitudes[ordA], magnitudes[ordB], metric);
|
|
3486
|
-
},
|
|
3487
|
-
prepareQueryArena(query) {
|
|
3488
|
-
if (query.length !== dimension || !view.simdAvailable) return null;
|
|
3489
|
-
currentQuery = query;
|
|
3490
|
-
for (const block of blocks) {
|
|
3491
|
-
if (block !== void 0) block.stagedOrdinal = NOTHING_STAGED;
|
|
3492
|
-
}
|
|
3493
|
-
return { magnitude: magnitude(query) };
|
|
3494
|
-
},
|
|
3495
|
-
distanceFromArena(prepared, ordinal, metric) {
|
|
3496
|
-
const state = holdState(ordinal);
|
|
3497
|
-
if (state === NOT_HELD) return Number.POSITIVE_INFINITY;
|
|
3498
|
-
if (currentQuery === null) return Number.POSITIVE_INFINITY;
|
|
3499
|
-
if (state === HELD_COLD) {
|
|
3500
|
-
if (!readColdInto(ordinal, coldScratchA)) return Number.POSITIVE_INFINITY;
|
|
3501
|
-
return jsDistance(currentQuery, coldScratchA, prepared.magnitude, magnitudes[ordinal], metric);
|
|
3502
|
-
}
|
|
3503
|
-
const block = blockAt(ordinal / capacity | 0);
|
|
3504
|
-
const local = ordinal % capacity;
|
|
3505
|
-
if (block.simd !== null && block.hasScratch && stageQuery(block)) {
|
|
3506
|
-
return arenaFloat32Distance(
|
|
3507
|
-
block.simd,
|
|
3508
|
-
block.scratchByteOffset,
|
|
3509
|
-
slotByteOffset(layout, local),
|
|
3510
|
-
dimension,
|
|
3511
|
-
metric,
|
|
3512
|
-
prepared.magnitude,
|
|
3513
|
-
magnitudes[ordinal]
|
|
3514
|
-
);
|
|
3515
|
-
}
|
|
3516
|
-
return jsDistance(currentQuery, vectorIn(block, local), prepared.magnitude, magnitudes[ordinal], metric);
|
|
3517
|
-
},
|
|
3518
|
-
hotBlockReads,
|
|
3519
|
-
queryDistance: (prepared, metric) => queryDistanceOf(view, prepared, metric),
|
|
3520
|
-
ordinalDistance: (from, metric) => ordinalDistanceOf(view, from, metric),
|
|
3521
|
-
pairDistance: (metric) => pairDistanceOf(view, metric)
|
|
3522
|
-
};
|
|
3523
|
-
for (let index = 0; index < handles.blocks.length; index++) {
|
|
3524
|
-
if (handles.blocks[index] !== null) blockAt(index);
|
|
3525
|
-
}
|
|
3526
|
-
for (let index = 0; index < handles.codeBlocks.length; index++) codeBlockAt(index);
|
|
3527
|
-
return view;
|
|
3528
|
-
}
|
|
3529
|
-
|
|
3530
|
-
// src/vector/shared-field/view.ts
|
|
3531
|
-
function openSharedVectorField(initial, threadSlot) {
|
|
3532
|
-
let handles = initial;
|
|
3533
|
-
const store = openSharedVectorStore(initial.store, threadSlot);
|
|
3534
|
-
const codeLayout = initial.store.codeLayout;
|
|
3535
|
-
const quantizer = initial.quantization !== "none" && codeLayout !== null ? openSharedQuantizer(store, codeLayout, initial.metric) : void 0;
|
|
3536
|
-
let graph = null;
|
|
3537
|
-
let ordinals = null;
|
|
3538
|
-
let scanned = 0;
|
|
3539
|
-
let placed = 0;
|
|
3540
|
-
function openGraph(next) {
|
|
3541
|
-
graph = next.graph === null ? null : openGraphState(next.graph, next.dimension, store, quantizer, threadSlot);
|
|
3542
|
-
}
|
|
3543
|
-
openGraph(initial);
|
|
3544
|
-
function docIdOf(ordinal) {
|
|
3545
|
-
if (!store.holdsOrdinal(ordinal)) return void 0;
|
|
3546
|
-
return store.docIdAt(ordinal);
|
|
3547
|
-
}
|
|
3548
|
-
function ordinalOf(docId) {
|
|
3549
|
-
const slots = store.slots;
|
|
3550
|
-
if (ordinals === null) ordinals = /* @__PURE__ */ new Map();
|
|
3551
|
-
for (; scanned < slots; scanned++) {
|
|
3552
|
-
const id = store.docIdAt(scanned);
|
|
3553
|
-
if (id !== void 0) ordinals.set(id, scanned);
|
|
3554
|
-
}
|
|
3555
|
-
const ordinal = ordinals.get(docId);
|
|
3556
|
-
return ordinal !== void 0 && store.holdsOrdinal(ordinal) ? ordinal : void 0;
|
|
3557
|
-
}
|
|
3558
|
-
return {
|
|
3559
|
-
get handles() {
|
|
3560
|
-
return handles;
|
|
3561
|
-
},
|
|
3562
|
-
store,
|
|
3563
|
-
quantizer,
|
|
3564
|
-
get graph() {
|
|
3565
|
-
return graph;
|
|
3566
|
-
},
|
|
3567
|
-
get liveSize() {
|
|
3568
|
-
return graph === null ? 0 : nodeCountOf(graph) - tombstoneCountOf(graph);
|
|
3569
|
-
},
|
|
3570
|
-
get readsEveryVector() {
|
|
3571
|
-
return store.holdsEveryBlock;
|
|
3572
|
-
},
|
|
3573
|
-
get graphRetired() {
|
|
3574
|
-
return graph !== null && Atomics.load(graph.header, GRAPH_RETIRED) === 1;
|
|
3575
|
-
},
|
|
3576
|
-
docIdOf,
|
|
3577
|
-
ordinalOf,
|
|
3578
|
-
vectorOf(docId) {
|
|
3579
|
-
const ordinal = ordinalOf(docId);
|
|
3580
|
-
return ordinal === void 0 ? void 0 : store.vectorAt(ordinal);
|
|
3581
|
-
},
|
|
3582
|
-
adopt(next) {
|
|
3583
|
-
store.adoptHandles(next.store);
|
|
3584
|
-
if (next.graph?.header !== handles.graph?.header) openGraph(next);
|
|
3585
|
-
handles = next;
|
|
3586
|
-
},
|
|
3587
|
-
close() {
|
|
3588
|
-
store.close();
|
|
3589
|
-
},
|
|
3590
|
-
insertOrdinal(ordinal) {
|
|
3591
|
-
if (graph === null) return false;
|
|
3592
|
-
const fresh = insertNode(graph, ordinal);
|
|
3593
|
-
if (fresh) placed += 1;
|
|
3594
|
-
return fresh;
|
|
3595
|
-
},
|
|
3596
|
-
takeOutcome() {
|
|
3597
|
-
const outcome = { placed };
|
|
3598
|
-
placed = 0;
|
|
3599
|
-
return outcome;
|
|
3600
|
-
},
|
|
3601
|
-
searchOrdinals(query, k, metric, minSimilarity, options) {
|
|
3602
|
-
if (graph === null) return [];
|
|
3603
|
-
return searchOrdinals(graph, docIdOf, query, k, metric, minSimilarity, options);
|
|
3604
|
-
}
|
|
3605
|
-
};
|
|
3606
|
-
}
|
|
3607
3030
|
|
|
3608
3031
|
// src/vector/osq/index.ts
|
|
3609
3032
|
function createOsqQuantizer(dimension, bits, metric, store) {
|
|
@@ -3712,527 +3135,6 @@ function createOsqQuantizer(dimension, bits, metric, store) {
|
|
|
3712
3135
|
};
|
|
3713
3136
|
}
|
|
3714
3137
|
|
|
3715
|
-
// src/vector/vector-store/doc-ids.ts
|
|
3716
|
-
var encoder = new TextEncoder();
|
|
3717
|
-
function appendDocId(handles, ordinal, docId) {
|
|
3718
|
-
const bytes = encoder.encode(docId);
|
|
3719
|
-
const start = Atomics.load(handles.header, STORE_DOC_ID_BYTES);
|
|
3720
|
-
const end = start + bytes.length;
|
|
3721
|
-
growBufferTo(handles.docIdBytes, end);
|
|
3722
|
-
growBufferTo(handles.docIdOffsets, (ordinal + 2) * 4);
|
|
3723
|
-
new Uint8Array(handles.docIdBytes).set(bytes, start);
|
|
3724
|
-
const offsets = new Uint32Array(handles.docIdOffsets);
|
|
3725
|
-
offsets[ordinal] = start;
|
|
3726
|
-
offsets[ordinal + 1] = end;
|
|
3727
|
-
Atomics.store(handles.header, STORE_DOC_ID_BYTES, end);
|
|
3728
|
-
}
|
|
3729
|
-
function resetDocIds(handles) {
|
|
3730
|
-
new Uint32Array(handles.docIdOffsets).fill(0);
|
|
3731
|
-
Atomics.store(handles.header, STORE_DOC_ID_BYTES, 0);
|
|
3732
|
-
}
|
|
3733
|
-
|
|
3734
|
-
// src/vector/vector-store/ordinal-reads.ts
|
|
3735
|
-
function entryAt(store, ordinal) {
|
|
3736
|
-
return { vector: store.view.vectorAt(ordinal), magnitude: store.magnitudes[ordinal] };
|
|
3737
|
-
}
|
|
3738
|
-
function createOrdinalReads(openStore, readable) {
|
|
3739
|
-
function pairDistance(metric) {
|
|
3740
|
-
const open = openStore();
|
|
3741
|
-
if (open === null) return () => Number.POSITIVE_INFINITY;
|
|
3742
|
-
const inner = open.view.pairDistance(metric);
|
|
3743
|
-
return (ordA, ordB) => readable(ordA) && readable(ordB) ? inner(ordA, ordB) : Number.POSITIVE_INFINITY;
|
|
3744
|
-
}
|
|
3745
|
-
return {
|
|
3746
|
-
entryForOrdinal(ordinal) {
|
|
3747
|
-
const open = openStore();
|
|
3748
|
-
if (open === null || !readable(ordinal)) return void 0;
|
|
3749
|
-
return entryAt(open, ordinal);
|
|
3750
|
-
},
|
|
3751
|
-
distanceByOrdinal(ordA, ordB, metric) {
|
|
3752
|
-
const open = openStore();
|
|
3753
|
-
if (open === null || !readable(ordA) || !readable(ordB)) return Number.POSITIVE_INFINITY;
|
|
3754
|
-
return open.view.distanceByOrdinal(ordA, ordB, metric);
|
|
3755
|
-
},
|
|
3756
|
-
distanceFromArena(prepared, ordinal, metric) {
|
|
3757
|
-
const open = openStore();
|
|
3758
|
-
if (open === null || !readable(ordinal)) return Number.POSITIVE_INFINITY;
|
|
3759
|
-
return open.view.distanceFromArena(prepared, ordinal, metric);
|
|
3760
|
-
},
|
|
3761
|
-
queryDistance(prepared, metric) {
|
|
3762
|
-
const open = openStore();
|
|
3763
|
-
if (open === null) return () => Number.POSITIVE_INFINITY;
|
|
3764
|
-
const inner = open.view.queryDistance(prepared, metric);
|
|
3765
|
-
return (ordinal) => readable(ordinal) ? inner(ordinal) : Number.POSITIVE_INFINITY;
|
|
3766
|
-
},
|
|
3767
|
-
ordinalDistance(from, metric) {
|
|
3768
|
-
const pair = pairDistance(metric);
|
|
3769
|
-
return (ordinal) => pair(from, ordinal);
|
|
3770
|
-
},
|
|
3771
|
-
pairDistance
|
|
3772
|
-
};
|
|
3773
|
-
}
|
|
3774
|
-
|
|
3775
|
-
// src/vector/vector-store/listing.ts
|
|
3776
|
-
function* entriesOf(open, documents) {
|
|
3777
|
-
if (open === null) return;
|
|
3778
|
-
for (let ordinal = 0; ordinal < documents.length; ordinal++) {
|
|
3779
|
-
const docId = documents[ordinal];
|
|
3780
|
-
if (docId === void 0) continue;
|
|
3781
|
-
yield [docId, entryAt(open, ordinal)];
|
|
3782
|
-
}
|
|
3783
|
-
}
|
|
3784
|
-
function* docIdsOf(open, documents) {
|
|
3785
|
-
if (open === null) return;
|
|
3786
|
-
for (let ordinal = 0; ordinal < documents.length; ordinal++) {
|
|
3787
|
-
const docId = documents[ordinal];
|
|
3788
|
-
if (docId !== void 0) yield docId;
|
|
3789
|
-
}
|
|
3790
|
-
}
|
|
3791
|
-
function snapshotOf(open, documents, replacedOrdinals) {
|
|
3792
|
-
const slots = documents.length;
|
|
3793
|
-
const dimension = open === null ? 0 : open.handles.dimension;
|
|
3794
|
-
const vectors = new Float32Array(slots * dimension);
|
|
3795
|
-
const magnitudes = new Float64Array(slots);
|
|
3796
|
-
const docIds = new Array(slots);
|
|
3797
|
-
for (let ordinal = 0; ordinal < slots; ordinal++) {
|
|
3798
|
-
docIds[ordinal] = documents[ordinal] ?? null;
|
|
3799
|
-
if (open === null || documents[ordinal] === void 0 && !replacedOrdinals.has(ordinal)) continue;
|
|
3800
|
-
vectors.set(open.view.vectorAt(ordinal), ordinal * dimension);
|
|
3801
|
-
magnitudes[ordinal] = open.magnitudes[ordinal];
|
|
3802
|
-
}
|
|
3803
|
-
return { dimension, slots, vectors, magnitudes, docIds, replacedOrdinals: [...replacedOrdinals] };
|
|
3804
|
-
}
|
|
3805
|
-
|
|
3806
|
-
// src/vector/vector-store/open-store.ts
|
|
3807
|
-
function openHandles(dimension, codeBits, blockBytes2) {
|
|
3808
|
-
const handles = createSharedVectorStoreHandles(dimension, codeBits, blockBytes2);
|
|
3809
|
-
return {
|
|
3810
|
-
handles,
|
|
3811
|
-
view: openSharedVectorStore(handles, 0),
|
|
3812
|
-
magnitudes: new Float64Array(handles.magnitudes),
|
|
3813
|
-
present: new Uint8Array(handles.present),
|
|
3814
|
-
partitions: new Int32Array(handles.partitions),
|
|
3815
|
-
diskFile: new Int32Array(handles.diskFile),
|
|
3816
|
-
diskOffset: new Uint32Array(handles.diskOffset)
|
|
3817
|
-
};
|
|
3818
|
-
}
|
|
3819
|
-
function relayout(store) {
|
|
3820
|
-
store.handles.layoutRevision += 1;
|
|
3821
|
-
store.view.adoptHandles(store.handles);
|
|
3822
|
-
}
|
|
3823
|
-
function ensureCodeSlot(store, ordinal) {
|
|
3824
|
-
const { handles } = store;
|
|
3825
|
-
if (handles.codeLayout === null) return;
|
|
3826
|
-
const blockIndex = Math.floor(ordinal / handles.codeLayout.capacity);
|
|
3827
|
-
while (handles.codeBlocks.length <= blockIndex) {
|
|
3828
|
-
handles.codeBlocks.push(createVectorBlock(handles.codeLayout));
|
|
3829
|
-
Atomics.store(handles.header, STORE_CODE_BLOCK_COUNT, handles.codeBlocks.length);
|
|
3830
|
-
relayout(store);
|
|
3831
|
-
}
|
|
3832
|
-
ensureBlockSlots(handles.codeBlocks[blockIndex], ordinal % handles.codeLayout.capacity + 1);
|
|
3833
|
-
}
|
|
3834
|
-
function ensureFloatSlot(store, ordinal) {
|
|
3835
|
-
const { handles } = store;
|
|
3836
|
-
const blockIndex = Math.floor(ordinal / handles.layout.capacity);
|
|
3837
|
-
let changed = false;
|
|
3838
|
-
while (handles.blocks.length <= blockIndex) {
|
|
3839
|
-
handles.blocks.push(null);
|
|
3840
|
-
changed = true;
|
|
3841
|
-
}
|
|
3842
|
-
if (handles.blocks[blockIndex] === null) {
|
|
3843
|
-
handles.blocks[blockIndex] = createVectorBlock(handles.layout);
|
|
3844
|
-
changed = true;
|
|
3845
|
-
}
|
|
3846
|
-
if (changed) {
|
|
3847
|
-
Atomics.store(handles.header, STORE_BLOCK_COUNT, handles.blocks.length);
|
|
3848
|
-
relayout(store);
|
|
3849
|
-
}
|
|
3850
|
-
const block = handles.blocks[blockIndex];
|
|
3851
|
-
if (block !== null) ensureBlockSlots(block, ordinal % handles.layout.capacity + 1);
|
|
3852
|
-
}
|
|
3853
|
-
function ensureOrdinal(store, ordinal, cold) {
|
|
3854
|
-
if (ordinal >= MAX_VECTOR_ORDINALS) {
|
|
3855
|
-
throw new NarsilError(
|
|
3856
|
-
ErrorCodes.PARTITION_CAPACITY_EXCEEDED,
|
|
3857
|
-
`A vector field holds at most ${MAX_VECTOR_ORDINALS} vectors, deleted ones included, until it is rebuilt`,
|
|
3858
|
-
{ ordinal, maxOrdinals: MAX_VECTOR_ORDINALS }
|
|
3859
|
-
);
|
|
3860
|
-
}
|
|
3861
|
-
const { handles } = store;
|
|
3862
|
-
growBufferTo(handles.magnitudes, (ordinal + 1) * 8);
|
|
3863
|
-
growBufferTo(handles.present, ordinal + 1);
|
|
3864
|
-
growBufferTo(handles.unplaced, ordinal + 1);
|
|
3865
|
-
growBufferTo(handles.unplacedChunks, unplacedChunkCount(ordinal) * 4);
|
|
3866
|
-
growBufferTo(handles.removed, ordinal + 1);
|
|
3867
|
-
growBufferTo(handles.partitions, (ordinal + 1) * 4);
|
|
3868
|
-
growBufferTo(handles.codePresent, ordinal + 1);
|
|
3869
|
-
const diskFileBytes = handles.diskFile.byteLength;
|
|
3870
|
-
growBufferTo(handles.diskFile, (ordinal + 1) * 4);
|
|
3871
|
-
if (handles.diskFile.byteLength > diskFileBytes) {
|
|
3872
|
-
new Int32Array(handles.diskFile).fill(IN_MEMORY, diskFileBytes / 4);
|
|
3873
|
-
}
|
|
3874
|
-
growBufferTo(handles.diskOffset, (ordinal + 1) * 4);
|
|
3875
|
-
if (!cold) ensureFloatSlot(store, ordinal);
|
|
3876
|
-
ensureCodeSlot(store, ordinal);
|
|
3877
|
-
}
|
|
3878
|
-
function writeVector(store, ordinal, vector) {
|
|
3879
|
-
const block = store.view.blockOf(ordinal);
|
|
3880
|
-
const base = slotByteOffset(store.handles.layout, store.view.localOrdinal(ordinal)) / 4;
|
|
3881
|
-
block.float32(base + vector.length).set(vector, base);
|
|
3882
|
-
store.magnitudes[ordinal] = magnitude(vector);
|
|
3883
|
-
}
|
|
3884
|
-
function blockFullyCold(store, blockIndex, documents, replacedOrdinals) {
|
|
3885
|
-
const capacity = store.handles.layout.capacity;
|
|
3886
|
-
const slots = Atomics.load(store.handles.header, STORE_SLOTS);
|
|
3887
|
-
const end = Math.min(slots, (blockIndex + 1) * capacity);
|
|
3888
|
-
if (end < (blockIndex + 1) * capacity) return false;
|
|
3889
|
-
for (let ordinal = blockIndex * capacity; ordinal < end; ordinal++) {
|
|
3890
|
-
const held = documents[ordinal] !== void 0 || replacedOrdinals.has(ordinal);
|
|
3891
|
-
if (held && store.diskFile[ordinal] === IN_MEMORY) return false;
|
|
3892
|
-
}
|
|
3893
|
-
return true;
|
|
3894
|
-
}
|
|
3895
|
-
function fileHoldsSameBytes(store, ordinal, location) {
|
|
3896
|
-
const fromFile = new Float32Array(store.handles.dimension);
|
|
3897
|
-
if (!store.view.readFromFile(location.fileIndex, location.offset, fromFile)) return false;
|
|
3898
|
-
const held = store.view.vectorAt(ordinal);
|
|
3899
|
-
const a = new Uint8Array(fromFile.buffer);
|
|
3900
|
-
const b = new Uint8Array(held.buffer, held.byteOffset, held.byteLength);
|
|
3901
|
-
for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
|
|
3902
|
-
return true;
|
|
3903
|
-
}
|
|
3904
|
-
function forgetUnreferencedFiles(store, documents, replacedOrdinals) {
|
|
3905
|
-
const referenced = /* @__PURE__ */ new Set();
|
|
3906
|
-
for (let ordinal = 0; ordinal < documents.length; ordinal++) {
|
|
3907
|
-
const held = documents[ordinal] !== void 0 || replacedOrdinals.has(ordinal);
|
|
3908
|
-
if (held && store.diskFile[ordinal] !== IN_MEMORY) {
|
|
3909
|
-
referenced.add(store.diskFile[ordinal]);
|
|
3910
|
-
}
|
|
3911
|
-
}
|
|
3912
|
-
let forgotten = 0;
|
|
3913
|
-
for (let file = 0; file < store.handles.vectorFiles.length; file++) {
|
|
3914
|
-
if (referenced.has(file) || store.handles.vectorFiles[file] === "") continue;
|
|
3915
|
-
store.handles.vectorFiles[file] = "";
|
|
3916
|
-
forgotten += 1;
|
|
3917
|
-
}
|
|
3918
|
-
return forgotten;
|
|
3919
|
-
}
|
|
3920
|
-
function partitionFilterOf(store, documents, partitionIds) {
|
|
3921
|
-
const filter = createOrdinalFilter(documents.length);
|
|
3922
|
-
if (store === null) return filter;
|
|
3923
|
-
let highest = -1;
|
|
3924
|
-
for (const partitionId of partitionIds) {
|
|
3925
|
-
if (partitionId > highest) highest = partitionId;
|
|
3926
|
-
}
|
|
3927
|
-
if (highest < 0) return filter;
|
|
3928
|
-
const wanted = new Uint8Array(highest + 1);
|
|
3929
|
-
for (const partitionId of partitionIds) {
|
|
3930
|
-
if (partitionId >= 0) wanted[partitionId] = 1;
|
|
3931
|
-
}
|
|
3932
|
-
for (let ordinal = 0; ordinal < documents.length; ordinal++) {
|
|
3933
|
-
if (documents[ordinal] === void 0) continue;
|
|
3934
|
-
const partitionId = store.partitions[ordinal];
|
|
3935
|
-
if (partitionId < 0 || partitionId > highest || wanted[partitionId] === 0) continue;
|
|
3936
|
-
addToOrdinalFilter(filter, ordinal);
|
|
3937
|
-
}
|
|
3938
|
-
return filter;
|
|
3939
|
-
}
|
|
3940
|
-
|
|
3941
|
-
// src/vector/vector-store/index.ts
|
|
3942
|
-
var UNKNOWN_PARTITION = -1;
|
|
3943
|
-
var NO_PARTITION = -2;
|
|
3944
|
-
function createVectorStore(options) {
|
|
3945
|
-
const codeBits = options?.codeBits ?? null;
|
|
3946
|
-
const blockBytes2 = options?.blockBytes ?? BLOCK_MAX_BYTES;
|
|
3947
|
-
const docToOrd = /* @__PURE__ */ new Map();
|
|
3948
|
-
const ordToDoc = [];
|
|
3949
|
-
const replacedOrdinals = /* @__PURE__ */ new Set();
|
|
3950
|
-
let unknownPartitions = 0;
|
|
3951
|
-
let liveCount = 0;
|
|
3952
|
-
let open = options?.dimension === void 0 ? null : openHandles(options.dimension, codeBits, blockBytes2);
|
|
3953
|
-
function forgetDocuments() {
|
|
3954
|
-
docToOrd.clear();
|
|
3955
|
-
ordToDoc.length = 0;
|
|
3956
|
-
replacedOrdinals.clear();
|
|
3957
|
-
unknownPartitions = 0;
|
|
3958
|
-
liveCount = 0;
|
|
3959
|
-
}
|
|
3960
|
-
function readable(ordinal) {
|
|
3961
|
-
return ordToDoc[ordinal] !== void 0 || replacedOrdinals.has(ordinal);
|
|
3962
|
-
}
|
|
3963
|
-
function requireOpen() {
|
|
3964
|
-
if (open === null) {
|
|
3965
|
-
throw new NarsilError(ErrorCodes.VECTOR_DIMENSION_MISMATCH, "The vector store holds no vector yet");
|
|
3966
|
-
}
|
|
3967
|
-
return open;
|
|
3968
|
-
}
|
|
3969
|
-
function recordPartition(store, ordinal, partitionId) {
|
|
3970
|
-
const given = partitionId !== void 0 && partitionId >= 0 ? partitionId : UNKNOWN_PARTITION;
|
|
3971
|
-
store.partitions[ordinal] = given;
|
|
3972
|
-
if (given === UNKNOWN_PARTITION) unknownPartitions += 1;
|
|
3973
|
-
}
|
|
3974
|
-
function retireOrdinal(store, ordinal) {
|
|
3975
|
-
ordToDoc[ordinal] = void 0;
|
|
3976
|
-
Atomics.store(store.present, ordinal, 0);
|
|
3977
|
-
if (store.partitions[ordinal] === UNKNOWN_PARTITION) unknownPartitions -= 1;
|
|
3978
|
-
}
|
|
3979
|
-
function keepReplacedOrdinal(store, ordinal) {
|
|
3980
|
-
ordToDoc[ordinal] = void 0;
|
|
3981
|
-
if (store.partitions[ordinal] === UNKNOWN_PARTITION) unknownPartitions -= 1;
|
|
3982
|
-
store.partitions[ordinal] = NO_PARTITION;
|
|
3983
|
-
replacedOrdinals.add(ordinal);
|
|
3984
|
-
}
|
|
3985
|
-
function restoreReplacedVector(store, ordinal, vector) {
|
|
3986
|
-
store.diskFile[ordinal] = IN_MEMORY;
|
|
3987
|
-
writeVector(store, ordinal, vector);
|
|
3988
|
-
Atomics.store(store.present, ordinal, 1);
|
|
3989
|
-
replacedOrdinals.add(ordinal);
|
|
3990
|
-
}
|
|
3991
|
-
function claimSlot(store, docId, cold) {
|
|
3992
|
-
const ordinal = Atomics.load(store.handles.header, STORE_SLOTS);
|
|
3993
|
-
ensureOrdinal(store, ordinal, cold);
|
|
3994
|
-
store.diskFile[ordinal] = IN_MEMORY;
|
|
3995
|
-
appendDocId(store.handles, ordinal, docId);
|
|
3996
|
-
return ordinal;
|
|
3997
|
-
}
|
|
3998
|
-
function claimOrdinal(store, docId, cold, partitionId) {
|
|
3999
|
-
const ordinal = claimSlot(store, docId, cold);
|
|
4000
|
-
recordPartition(store, ordinal, partitionId);
|
|
4001
|
-
ordToDoc[ordinal] = docId;
|
|
4002
|
-
docToOrd.set(docId, ordinal);
|
|
4003
|
-
return ordinal;
|
|
4004
|
-
}
|
|
4005
|
-
function publishOrdinal(store, ordinal) {
|
|
4006
|
-
Atomics.store(store.handles.header, STORE_SLOTS, ordinal + 1);
|
|
4007
|
-
Atomics.store(store.present, ordinal, 1);
|
|
4008
|
-
}
|
|
4009
|
-
function publishOnDisk(store, ordinal, vectorMagnitude, location) {
|
|
4010
|
-
store.magnitudes[ordinal] = vectorMagnitude;
|
|
4011
|
-
store.diskOffset[ordinal] = location.offset;
|
|
4012
|
-
store.diskFile[ordinal] = location.fileIndex;
|
|
4013
|
-
publishOrdinal(store, ordinal);
|
|
4014
|
-
}
|
|
4015
|
-
function appendOrdinal(store, docId, vector, partitionId) {
|
|
4016
|
-
const ordinal = claimOrdinal(store, docId, false, partitionId);
|
|
4017
|
-
writeVector(store, ordinal, vector);
|
|
4018
|
-
publishOrdinal(store, ordinal);
|
|
4019
|
-
return ordinal;
|
|
4020
|
-
}
|
|
4021
|
-
function settleReplacement(store, ordinal, previous, keepsReplacedVector) {
|
|
4022
|
-
if (previous !== void 0) {
|
|
4023
|
-
if (keepsReplacedVector) keepReplacedOrdinal(store, previous);
|
|
4024
|
-
else retireOrdinal(store, previous);
|
|
4025
|
-
return ordinal;
|
|
4026
|
-
}
|
|
4027
|
-
liveCount++;
|
|
4028
|
-
Atomics.add(store.handles.header, STORE_LIVE_COUNT, 1);
|
|
4029
|
-
return ordinal;
|
|
4030
|
-
}
|
|
4031
|
-
return {
|
|
4032
|
-
...createOrdinalReads(() => open, readable),
|
|
4033
|
-
get size() {
|
|
4034
|
-
return liveCount;
|
|
4035
|
-
},
|
|
4036
|
-
get slots() {
|
|
4037
|
-
return ordToDoc.length;
|
|
4038
|
-
},
|
|
4039
|
-
get dimension() {
|
|
4040
|
-
return open === null ? 0 : open.handles.dimension;
|
|
4041
|
-
},
|
|
4042
|
-
get codeBits() {
|
|
4043
|
-
return codeBits;
|
|
4044
|
-
},
|
|
4045
|
-
get handles() {
|
|
4046
|
-
return requireOpen().handles;
|
|
4047
|
-
},
|
|
4048
|
-
get view() {
|
|
4049
|
-
return requireOpen().view;
|
|
4050
|
-
},
|
|
4051
|
-
get replacedVectorCount() {
|
|
4052
|
-
return replacedOrdinals.size;
|
|
4053
|
-
},
|
|
4054
|
-
insert(docId, vector, partitionId, keepsReplacedVector = false) {
|
|
4055
|
-
if (open === null) open = openHandles(vector.length, codeBits, blockBytes2);
|
|
4056
|
-
const store = open;
|
|
4057
|
-
if (vector.length !== store.handles.dimension) {
|
|
4058
|
-
throw new NarsilError(
|
|
4059
|
-
ErrorCodes.VECTOR_DIMENSION_MISMATCH,
|
|
4060
|
-
`Vector dimension mismatch: expected ${store.handles.dimension}, got ${vector.length}`,
|
|
4061
|
-
{ expected: store.handles.dimension, received: vector.length }
|
|
4062
|
-
);
|
|
4063
|
-
}
|
|
4064
|
-
const previous = docToOrd.get(docId);
|
|
4065
|
-
const ordinal = appendOrdinal(store, docId, vector, partitionId);
|
|
4066
|
-
return settleReplacement(store, ordinal, previous, keepsReplacedVector);
|
|
4067
|
-
},
|
|
4068
|
-
releaseReplacedVectors() {
|
|
4069
|
-
const released = [...replacedOrdinals];
|
|
4070
|
-
replacedOrdinals.clear();
|
|
4071
|
-
if (open !== null) for (const ordinal of released) Atomics.store(open.present, ordinal, 0);
|
|
4072
|
-
return released;
|
|
4073
|
-
},
|
|
4074
|
-
insertCold(docId, vectorMagnitude, location, partitionId) {
|
|
4075
|
-
const store = requireOpen();
|
|
4076
|
-
const previous = docToOrd.get(docId);
|
|
4077
|
-
Atomics.store(store.handles.header, STORE_RELEASED_VECTORS_TO_DISK, 1);
|
|
4078
|
-
const ordinal = claimOrdinal(store, docId, true, partitionId);
|
|
4079
|
-
publishOnDisk(store, ordinal, vectorMagnitude, location);
|
|
4080
|
-
return settleReplacement(store, ordinal, previous, false);
|
|
4081
|
-
},
|
|
4082
|
-
insertReplaced(docId, vector, location) {
|
|
4083
|
-
if (open === null) open = openHandles(vector.length, codeBits, blockBytes2);
|
|
4084
|
-
const store = open;
|
|
4085
|
-
if (location !== void 0) Atomics.store(store.handles.header, STORE_RELEASED_VECTORS_TO_DISK, 1);
|
|
4086
|
-
const ordinal = claimSlot(store, docId, location !== void 0);
|
|
4087
|
-
store.partitions[ordinal] = NO_PARTITION;
|
|
4088
|
-
ordToDoc[ordinal] = void 0;
|
|
4089
|
-
replacedOrdinals.add(ordinal);
|
|
4090
|
-
if (location !== void 0) {
|
|
4091
|
-
publishOnDisk(store, ordinal, magnitude(vector), location);
|
|
4092
|
-
return ordinal;
|
|
4093
|
-
}
|
|
4094
|
-
writeVector(store, ordinal, vector);
|
|
4095
|
-
publishOrdinal(store, ordinal);
|
|
4096
|
-
return ordinal;
|
|
4097
|
-
},
|
|
4098
|
-
addVectorFile(path) {
|
|
4099
|
-
const store = requireOpen();
|
|
4100
|
-
const existing = store.handles.vectorFiles.indexOf(path);
|
|
4101
|
-
if (existing !== -1) return existing;
|
|
4102
|
-
store.handles.vectorFiles.push(path);
|
|
4103
|
-
relayout(store);
|
|
4104
|
-
return store.handles.vectorFiles.length - 1;
|
|
4105
|
-
},
|
|
4106
|
-
isCold(ordinal) {
|
|
4107
|
-
if (open === null) return false;
|
|
4108
|
-
return open.view.isCold(ordinal);
|
|
4109
|
-
},
|
|
4110
|
-
releaseToFile(ordinal, location) {
|
|
4111
|
-
const store = requireOpen();
|
|
4112
|
-
if (ordToDoc[ordinal] === void 0) return false;
|
|
4113
|
-
if (store.diskFile[ordinal] === IN_MEMORY && !fileHoldsSameBytes(store, ordinal, location)) return false;
|
|
4114
|
-
Atomics.store(store.handles.header, STORE_RELEASED_VECTORS_TO_DISK, 1);
|
|
4115
|
-
store.diskOffset[ordinal] = location.offset;
|
|
4116
|
-
store.diskFile[ordinal] = location.fileIndex;
|
|
4117
|
-
return true;
|
|
4118
|
-
},
|
|
4119
|
-
releaseColdBlocks() {
|
|
4120
|
-
const store = requireOpen();
|
|
4121
|
-
let released = 0;
|
|
4122
|
-
for (let index = 0; index < store.handles.blocks.length; index++) {
|
|
4123
|
-
if (store.handles.blocks[index] === null || !blockFullyCold(store, index, ordToDoc, replacedOrdinals)) continue;
|
|
4124
|
-
store.handles.blocks[index] = null;
|
|
4125
|
-
released += 1;
|
|
4126
|
-
}
|
|
4127
|
-
if (released + forgetUnreferencedFiles(store, ordToDoc, replacedOrdinals) > 0) relayout(store);
|
|
4128
|
-
return released;
|
|
4129
|
-
},
|
|
4130
|
-
setPartition(docId, partitionId) {
|
|
4131
|
-
const ordinal = docToOrd.get(docId);
|
|
4132
|
-
if (ordinal === void 0 || open === null || partitionId < 0) return;
|
|
4133
|
-
if (open.partitions[ordinal] === UNKNOWN_PARTITION) unknownPartitions -= 1;
|
|
4134
|
-
open.partitions[ordinal] = partitionId;
|
|
4135
|
-
},
|
|
4136
|
-
forgetPartition(docId) {
|
|
4137
|
-
const ordinal = docToOrd.get(docId);
|
|
4138
|
-
if (ordinal === void 0 || open === null) return;
|
|
4139
|
-
if (open.partitions[ordinal] === UNKNOWN_PARTITION) unknownPartitions -= 1;
|
|
4140
|
-
open.partitions[ordinal] = NO_PARTITION;
|
|
4141
|
-
},
|
|
4142
|
-
partitionOfOrdinal(ordinal) {
|
|
4143
|
-
if (open === null || ordinal < 0 || ordinal >= ordToDoc.length) return void 0;
|
|
4144
|
-
const partitionId = open.partitions[ordinal];
|
|
4145
|
-
return partitionId < 0 ? void 0 : partitionId;
|
|
4146
|
-
},
|
|
4147
|
-
get partitionsKnown() {
|
|
4148
|
-
return unknownPartitions === 0;
|
|
4149
|
-
},
|
|
4150
|
-
partitionFilter(partitionIds) {
|
|
4151
|
-
return partitionFilterOf(open, ordToDoc, partitionIds);
|
|
4152
|
-
},
|
|
4153
|
-
remove(docId) {
|
|
4154
|
-
const ordinal = docToOrd.get(docId);
|
|
4155
|
-
if (ordinal === void 0 || open === null) return;
|
|
4156
|
-
docToOrd.delete(docId);
|
|
4157
|
-
retireOrdinal(open, ordinal);
|
|
4158
|
-
liveCount--;
|
|
4159
|
-
Atomics.sub(open.handles.header, STORE_LIVE_COUNT, 1);
|
|
4160
|
-
},
|
|
4161
|
-
get(docId) {
|
|
4162
|
-
const ordinal = docToOrd.get(docId);
|
|
4163
|
-
return ordinal === void 0 || open === null ? void 0 : entryAt(open, ordinal);
|
|
4164
|
-
},
|
|
4165
|
-
has(docId) {
|
|
4166
|
-
return docToOrd.has(docId);
|
|
4167
|
-
},
|
|
4168
|
-
holdsOrdinal(ordinal) {
|
|
4169
|
-
return ordinal >= 0 && ordinal < ordToDoc.length && ordToDoc[ordinal] !== void 0;
|
|
4170
|
-
},
|
|
4171
|
-
entries: () => entriesOf(open, ordToDoc),
|
|
4172
|
-
docIds: () => docIdsOf(open, ordToDoc),
|
|
4173
|
-
clear() {
|
|
4174
|
-
forgetDocuments();
|
|
4175
|
-
if (open === null) return;
|
|
4176
|
-
open.present.fill(0);
|
|
4177
|
-
new Uint8Array(open.handles.codePresent).fill(0);
|
|
4178
|
-
new Int32Array(open.handles.diskFile).fill(IN_MEMORY);
|
|
4179
|
-
open.handles.centroid.fill(0);
|
|
4180
|
-
if (open.handles.vectorFiles.length > 0) {
|
|
4181
|
-
open.handles.vectorFiles.length = 0;
|
|
4182
|
-
relayout(open);
|
|
4183
|
-
}
|
|
4184
|
-
resetDocIds(open.handles);
|
|
4185
|
-
Atomics.store(open.handles.header, STORE_SLOTS, 0);
|
|
4186
|
-
Atomics.store(open.handles.header, STORE_RELEASED_VECTORS_TO_DISK, 0);
|
|
4187
|
-
Atomics.store(open.handles.header, STORE_LIVE_COUNT, 0);
|
|
4188
|
-
Atomics.store(open.handles.header, STORE_CODE_COUNT, 0);
|
|
4189
|
-
Atomics.store(open.handles.header, STORE_CALIBRATED, 0);
|
|
4190
|
-
Atomics.add(open.handles.header, STORE_CALIBRATION_GENERATION, 1);
|
|
4191
|
-
},
|
|
4192
|
-
release() {
|
|
4193
|
-
forgetDocuments();
|
|
4194
|
-
open?.view.close();
|
|
4195
|
-
open = null;
|
|
4196
|
-
},
|
|
4197
|
-
closeFiles: () => open?.view.close(),
|
|
4198
|
-
getOrdinal(docId) {
|
|
4199
|
-
return docToOrd.get(docId);
|
|
4200
|
-
},
|
|
4201
|
-
docIdForOrdinal(ordinal) {
|
|
4202
|
-
return ordToDoc[ordinal];
|
|
4203
|
-
},
|
|
4204
|
-
prepareQueryArena(query) {
|
|
4205
|
-
return open === null ? null : open.view.prepareQueryArena(query);
|
|
4206
|
-
},
|
|
4207
|
-
exportSnapshot: () => snapshotOf(open, ordToDoc, replacedOrdinals),
|
|
4208
|
-
restoreSnapshot(snapshot) {
|
|
4209
|
-
this.clear();
|
|
4210
|
-
if (snapshot.dimension === 0 || snapshot.slots === 0) return;
|
|
4211
|
-
if (open === null) open = openHandles(snapshot.dimension, codeBits, blockBytes2);
|
|
4212
|
-
const store = open;
|
|
4213
|
-
const replaced = new Set(snapshot.replacedOrdinals);
|
|
4214
|
-
for (let ordinal = 0; ordinal < snapshot.slots; ordinal++) {
|
|
4215
|
-
const docId = snapshot.docIds[ordinal];
|
|
4216
|
-
const vector = snapshot.vectors.subarray(ordinal * snapshot.dimension, (ordinal + 1) * snapshot.dimension);
|
|
4217
|
-
if (docId === null || docId === void 0) {
|
|
4218
|
-
ensureOrdinal(store, ordinal, false);
|
|
4219
|
-
ordToDoc[ordinal] = void 0;
|
|
4220
|
-
store.partitions[ordinal] = NO_PARTITION;
|
|
4221
|
-
if (replaced.has(ordinal)) restoreReplacedVector(store, ordinal, vector);
|
|
4222
|
-
Atomics.store(store.handles.header, STORE_SLOTS, ordinal + 1);
|
|
4223
|
-
continue;
|
|
4224
|
-
}
|
|
4225
|
-
appendOrdinal(store, docId, vector);
|
|
4226
|
-
liveCount++;
|
|
4227
|
-
}
|
|
4228
|
-
Atomics.store(store.handles.header, STORE_LIVE_COUNT, liveCount);
|
|
4229
|
-
},
|
|
4230
|
-
memoryBytes() {
|
|
4231
|
-
return open === null ? 0 : sharedVectorStoreBytes(open.handles);
|
|
4232
|
-
}
|
|
4233
|
-
};
|
|
4234
|
-
}
|
|
4235
|
-
|
|
4236
3138
|
// src/vector/hnsw/numbered-graph.ts
|
|
4237
3139
|
var NO_NUMBER = -1;
|
|
4238
3140
|
var NO_ORDINAL = -1;
|
|
@@ -4688,4 +3590,4 @@ function createHNSWIndex(dimension, store, config, quantizer, handles) {
|
|
|
4688
3590
|
};
|
|
4689
3591
|
}
|
|
4690
3592
|
|
|
4691
|
-
export {
|
|
3593
|
+
export { BLOCK_MAX_BYTES, GRAPH_RETIRED, IN_MEMORY, NOTHING_STAGED, QUERY_STAGED, STORE_BLOCK_COUNT, STORE_CALIBRATED, STORE_CALIBRATION_GENERATION, STORE_CODE_BLOCK_COUNT, STORE_CODE_COUNT, STORE_DOC_ID_BYTES, STORE_LIVE_COUNT, STORE_RELEASED_VECTORS_TO_DISK, STORE_REMOVED_COUNT, STORE_SLOTS, STORE_UNPLACED_COUNT, addToOrdinalFilter, arenaFloat32Distance, cosineSimilarityWithMagnitudes, createHNSWIndex, createOrdinalFilter, createOsqQuantizer, createSharedVectorStoreHandles, createVectorBlock, detachNativeStore, dotProduct, ensureBlockSlots, euclideanDistance, fixedView, graphWithoutNodes, growBufferTo, insertNode, magnitude, nativeScoresOf, nativeStoreScratchBytes, nodeCountOf, openGraphState, openSharedQuantizer, openVectorBlock, ordinalFilterHas, ordinalFilterValues, osqBitsOf, releaseLocksHeldBy, removeFromOrdinalFilter, requireWholeNeighbourLists, searchOrdinals, sharedMemoryAvailable, sharedVectorStoreBytes, slotByteOffset, toDistance, toScore, tombstoneCountOf, topLayerInParts, unplacedChunkCount };
|