@delali/narsil-react-native 0.0.0-stage → 0.3.1-next.151

package/cpp/ThreadPriority.cpp

@@ -0,0 +1,77 @@
+#include "ThreadPriority.hpp"
+
+#include <cmath>
+
+#if defined(__APPLE__)
+#include <pthread.h>
+#include <pthread/qos.h>
+#elif defined(__ANDROID__)
+#include <sys/resource.h>
+#include <unistd.h>
+#endif
+
+namespace margelo::nitro::narsil {
+
+namespace {
+
+bool isWholeNumber(double value) { return std::isfinite(value) && std::trunc(value) == value; }
+
+}
+
+#if defined(__APPLE__)
+
+namespace {
+
+constexpr int HIGHEST_ENGINE_SERVICE_CLASS = static_cast<int>(QOS_CLASS_USER_INITIATED);
+
+bool isServiceClass(int value) {
+  switch (value) {
+  case QOS_CLASS_USER_INTERACTIVE:
+  case QOS_CLASS_USER_INITIATED:
+  case QOS_CLASS_DEFAULT:
+  case QOS_CLASS_UTILITY:
+  case QOS_CLASS_BACKGROUND:
+    return true;
+  default:
+    return false;
+  }
+}
+
+}
+
+double priorityOfThisThread() { return static_cast<double>(qos_class_self()); }
+
+bool adoptAppThreadPriority(double appThreadPriority) {
+  if (!isWholeNumber(appThreadPriority)) return false;
+  int serviceClass = static_cast<int>(appThreadPriority);
+  if (!isServiceClass(serviceClass)) return false;
+  if (serviceClass > HIGHEST_ENGINE_SERVICE_CLASS) serviceClass = HIGHEST_ENGINE_SERVICE_CLASS;
+  return pthread_set_qos_class_self_np(static_cast<qos_class_t>(serviceClass), 0) == 0;
+}
+
+#elif defined(__ANDROID__)
+
+namespace {
+
+constexpr int HIGHEST_NICE = -20;
+constexpr int LOWEST_NICE = 19;
+
+}
+
+double priorityOfThisThread() { return static_cast<double>(getpriority(PRIO_PROCESS, static_cast<id_t>(gettid()))); }
+
+bool adoptAppThreadPriority(double appThreadPriority) {
+  if (!isWholeNumber(appThreadPriority)) return false;
+  if (appThreadPriority < HIGHEST_NICE || appThreadPriority > LOWEST_NICE) return false;
+  return setpriority(PRIO_PROCESS, static_cast<id_t>(gettid()), static_cast<int>(appThreadPriority)) == 0;
+}
+
+#else
+
+double priorityOfThisThread() { return NAN; }
+
+bool adoptAppThreadPriority(double) { return false; }
+
+#endif
+
+}

package/cpp/ThreadPriority.hpp

@@ -0,0 +1,8 @@
+#pragma once
+
+namespace margelo::nitro::narsil {
+
+double priorityOfThisThread();
+bool adoptAppThreadPriority(double appThreadPriority);
+
+}

package/cpp/WorkletRuntimeDispatcher.cpp

@@ -0,0 +1,61 @@
+#include "WorkletRuntimeDispatcher.hpp"
+
+#if NARSIL_LINKS_WORKLETS
+
+#include <NitroModules/Dispatcher.hpp>
+#include <worklets/WorkletRuntime/WorkletRuntime.h>
+
+#include <functional>
+#include <memory>
+#include <stdexcept>
+#include <utility>
+
+namespace margelo::nitro::narsil {
+
+namespace {
+
+class WorkletRuntimeDispatcher final : public Dispatcher {
+public:
+  explicit WorkletRuntimeDispatcher(std::weak_ptr<worklets::WorkletRuntime> runtime) : _runtime(std::move(runtime)) {}
+
+  void runAsync(std::function<void()>&& function) override {
+    std::shared_ptr<worklets::WorkletRuntime> runtime = _runtime.lock();
+    if (runtime == nullptr) return;
+    runtime->schedule([function = std::move(function)](facebook::jsi::Runtime&) { function(); });
+  }
+
+  void runSync(std::function<void()>&& function) override {
+    std::shared_ptr<worklets::WorkletRuntime> runtime = _runtime.lock();
+    if (runtime == nullptr) return;
+    runtime->runSync([&function](facebook::jsi::Runtime&) { function(); });
+  }
+
+private:
+  std::weak_ptr<worklets::WorkletRuntime> _runtime;
+};
+
+}
+
+bool installWorkletRuntimeDispatcher(facebook::jsi::Runtime& runtime) {
+  std::weak_ptr<worklets::WorkletRuntime> workletRuntime;
+  try {
+    workletRuntime = worklets::WorkletRuntime::getWeakRuntimeFromJSIRuntime(runtime);
+  } catch (const std::runtime_error&) {
+    return false;
+  }
+  if (workletRuntime.expired()) return false;
+  Dispatcher::installRuntimeGlobalDispatcher(runtime, std::make_shared<WorkletRuntimeDispatcher>(workletRuntime));
+  return true;
+}
+
+}
+
+#else
+
+namespace margelo::nitro::narsil {
+
+bool installWorkletRuntimeDispatcher(facebook::jsi::Runtime&) { return false; }
+
+}
+
+#endif

package/cpp/WorkletRuntimeDispatcher.hpp

@@ -0,0 +1,9 @@
+#pragma once
+
+#include <jsi/jsi.h>
+
+namespace margelo::nitro::narsil {
+
+bool installWorkletRuntimeDispatcher(facebook::jsi::Runtime& runtime);
+
+}

package/cpp/core/include/narsil_core.h

@@ -0,0 +1,208 @@
+#ifndef NARSIL_CORE_H
+#define NARSIL_CORE_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define NARSIL_CORE_ABI_VERSION 6
+
+#define NARSIL_GRAPH_HEADER_WORDS 160
+#define NARSIL_STORE_HEADER_WORDS 16
+#define NARSIL_HELD_WORDS_PER_THREAD 32
+#define NARSIL_OSQ_TRAILER_BYTES 16
+#define NARSIL_MAX_PLACEMENT_LAYERS 64
+#define NARSIL_LIST_WORDS_OVER_NEIGHBOURS 2
+
+#define NARSIL_GRAPH_WORD_ENTRY_POINT 0
+#define NARSIL_GRAPH_WORD_TOP_LAYER 1
+#define NARSIL_GRAPH_WORD_M 2
+#define NARSIL_GRAPH_WORD_MMAX0 3
+#define NARSIL_GRAPH_WORD_EF_CONSTRUCTION 4
+#define NARSIL_GRAPH_WORD_NODE_COUNT 32
+#define NARSIL_GRAPH_WORD_TOMBSTONE_COUNT 33
+#define NARSIL_GRAPH_WORD_UNLINKED_NODES 34
+#define NARSIL_GRAPH_WORD_UPPER_USED 64
+#define NARSIL_GRAPH_WORD_SLOTS 65
+#define NARSIL_GRAPH_WORD_UPPER_CAPACITY 66
+#define NARSIL_GRAPH_WORD_SLOT_CAPACITY 67
+#define NARSIL_GRAPH_WORD_LOCK 96
+#define NARSIL_GRAPH_WORD_WRITERS_WAITING 97
+#define NARSIL_GRAPH_WORD_ENTRY_LOCK 128
+
+#define NARSIL_STORE_WORD_SLOTS 0
+#define NARSIL_STORE_WORD_LIVE_COUNT 1
+#define NARSIL_STORE_WORD_CALIBRATED 3
+#define NARSIL_STORE_WORD_CODE_COUNT 4
+#define NARSIL_STORE_WORD_CALIBRATION_GENERATION 7
+
+#define NARSIL_HELD_WORD_NODE 0
+#define NARSIL_HELD_WORD_NODE_VALUE 1
+#define NARSIL_HELD_WORD_GRAPH 2
+#define NARSIL_HELD_WORD_ENTRY 5
+
+#define NARSIL_VECTOR_IN_A_BLOCK (-1)
+#define NARSIL_GRAPH_HELD_ALONE (-1)
+#define NARSIL_WAKE_ENTRY_LOCK (-1)
+
+typedef enum {
+  NARSIL_METRIC_COSINE = 0,
+  NARSIL_METRIC_DOT_PRODUCT = 1,
+  NARSIL_METRIC_EUCLIDEAN = 2,
+} narsil_metric;
+
+typedef enum {
+  NARSIL_OK = 0,
+  NARSIL_INVALID_ARGUMENT = 1,
+  NARSIL_OUT_OF_MEMORY = 2,
+  NARSIL_NEEDS_ROOM = 3,
+  NARSIL_GRAPH_NOT_HELD_ALONE = 4,
+  NARSIL_FILE_UNREADABLE = 5,
+} narsil_status;
+
+typedef void (*narsil_wake)(void *context, int32_t ordinal);
+
+typedef struct {
+  int32_t *header;
+  uint8_t *node_levels;
+  int32_t *level0;
+  int32_t *upper_base;
+  int32_t *upper;
+  int32_t *locks;
+  uint8_t *tombstones;
+  int32_t *incoming;
+  uint8_t *nearest_link_due;
+  int32_t *held_locks;
+  uint32_t thread_slots;
+  narsil_wake wake;
+  void *wake_context;
+} narsil_graph;
+
+typedef struct {
+  const uint8_t *bytes;
+  uint64_t length;
+  void *mapping;
+} narsil_vector_file;
+
+typedef struct {
+  int32_t *header;
+  uint32_t dimension;
+  uint32_t bits;
+  uint8_t *const *code_blocks;
+  uint32_t code_block_count;
+  uint32_t records_per_block;
+  uint8_t *code_present;
+  float *centroid;
+  const float *const *vector_blocks;
+  uint32_t vector_block_count;
+  uint32_t vectors_per_block;
+  uint32_t vector_stride_floats;
+  const double *magnitudes;
+  const uint8_t *present;
+  const int32_t *vector_file;
+  const uint32_t *vector_offset;
+  const narsil_vector_file *files;
+  uint32_t file_count;
+} narsil_store;
+
+typedef struct narsil_workspace narsil_workspace;
+
+typedef struct {
+  int32_t *ordinals;
+  double *distances;
+  uint32_t capacity;
+  uint32_t count;
+} narsil_candidates;
+
+typedef struct {
+  const uint8_t *bits;
+  uint32_t bytes;
+} narsil_ordinal_set;
+
+typedef struct {
+  const float *query;
+  uint32_t metric;
+  uint32_t candidate_count;
+  uint32_t thread_slot;
+  narsil_ordinal_set accepted;
+} narsil_search_request;
+
+typedef struct {
+  const float *query;
+  uint32_t metric;
+  const int32_t *ordinals;
+  uint32_t count;
+} narsil_score_request;
+
+typedef struct {
+  uint32_t metric;
+  int32_t ordinal;
+  int32_t top_layer;
+  uint32_t thread_slot;
+  uint32_t graph_held_alone;
+} narsil_place_request;
+
+typedef struct {
+  int32_t ordinal;
+  uint32_t thread_slot;
+} narsil_remove_request;
+
+typedef struct {
+  uint32_t metric;
+  uint32_t thread_slot;
+} narsil_compact_request;
+
+typedef struct {
+  uint32_t metric;
+  uint32_t thread_slot;
+  const int32_t *nearby;
+  uint32_t nearby_count;
+} narsil_connect_request;
+
+typedef struct {
+  uint32_t metric;
+  const int32_t *ordinals;
+  uint32_t count;
+} narsil_ordinals_request;
+
+int32_t narsil_core_abi_version(void);
+uint32_t narsil_record_bytes(uint32_t dimension, uint32_t bits);
+
+narsil_status narsil_workspace_create(narsil_workspace **workspace);
+void narsil_workspace_destroy(narsil_workspace *workspace);
+size_t narsil_workspace_bytes(const narsil_workspace *workspace);
+
+narsil_status narsil_vector_file_map(const char *path, narsil_vector_file *file);
+void narsil_vector_file_unmap(narsil_vector_file *file);
+
+narsil_status narsil_search(narsil_workspace *workspace, const narsil_graph *graph, const narsil_store *store,
+                            const narsil_search_request *request, narsil_candidates *nearest);
+
+narsil_status narsil_score(narsil_workspace *workspace, const narsil_store *store, const narsil_score_request *request,
+                           double *distances);
+
+narsil_status narsil_place(narsil_workspace *workspace, const narsil_graph *graph, const narsil_store *store,
+                           const narsil_place_request *request);
+
+narsil_status narsil_remove(const narsil_graph *graph, const narsil_remove_request *request);
+
+narsil_status narsil_compact(narsil_workspace *workspace, const narsil_graph *graph, const narsil_store *store,
+                             const narsil_compact_request *request);
+
+narsil_status narsil_connect_unreached(narsil_workspace *workspace, const narsil_graph *graph,
+                                       const narsil_store *store, const narsil_connect_request *request);
+
+narsil_status narsil_quantise(narsil_workspace *workspace, const narsil_store *store,
+                              const narsil_ordinals_request *request);
+
+narsil_status narsil_measure(narsil_workspace *workspace, const narsil_store *store,
+                             const narsil_ordinals_request *request, double *totals);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

package/cpp/core/src/connect.c

@@ -0,0 +1,213 @@
+#include "internal.h"
+
+#include "../include/narsil_core.h"
+
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef struct {
+  uint8_t *reached;
+  int32_t *first_reached_through;
+  int32_t *queue;
+  uint32_t head;
+  uint32_t tail;
+} layer_walk;
+
+typedef struct {
+  int32_t from;
+  int32_t to;
+} base_link;
+
+typedef struct {
+  int32_t *list;
+  uint32_t count;
+  uint8_t *holds;
+} nearby_nodes;
+
+typedef int (*host_test)(const walk_context *context, const layer_walk *walk, int32_t host);
+
+static int32_t *base_list(const walk_context *context, int32_t ordinal, uint32_t *count) {
+  uint32_t capacity = 0;
+  node_layer base = {ordinal, 0};
+  int32_t *list = list_at(context, base, &capacity);
+  *count = list == NULL ? 0 : stored_count(list, capacity);
+  return list;
+}
+
+static void reach(layer_walk *walk, base_link arrival) {
+  walk->reached[arrival.to] = 1;
+  walk->first_reached_through[arrival.to] = arrival.from;
+  walk->queue[walk->tail++] = arrival.to;
+}
+
+static void walk_from(const walk_context *context, layer_walk *walk, base_link arrival) {
+  if (walk->reached[arrival.to] == 1) { return; }
+  reach(walk, arrival);
+  while (walk->head < walk->tail) {
+    int32_t ordinal = walk->queue[walk->head++];
+    uint32_t count = 0;
+    const int32_t *list = base_list(context, ordinal, &count);
+    for (uint32_t i = 1; i <= count; i++) {
+      int32_t next = list[i];
+      if (node_top_layer(context, next) < 0 || walk->reached[next] == 1) { continue; }
+      base_link onward = {ordinal, next};
+      reach(walk, onward);
+    }
+  }
+}
+
+static int has_room(const walk_context *context, const layer_walk *walk, int32_t host) {
+  (void)walk;
+  uint32_t count = 0;
+  const int32_t *list = base_list(context, host, &count);
+  return list != NULL && count < list_limit(context->graph, 0);
+}
+
+static int reached_through_another_node(const walk_context *context, const layer_walk *walk, base_link link) {
+  if (link.to < 0 || (uint32_t)link.to >= context->slots || walk->reached[link.to] != 1) { return 0; }
+  int32_t through = walk->first_reached_through[link.to];
+  return through != NO_NODE && through != link.from;
+}
+
+static int holds_link_outside_the_walk(const walk_context *context, const layer_walk *walk, int32_t host) {
+  uint32_t count = 0;
+  const int32_t *list = base_list(context, host, &count);
+  for (uint32_t i = 1; i <= count; i++) {
+    base_link link = {host, list[i]};
+    if (reached_through_another_node(context, walk, link)) { return 1; }
+  }
+  return 0;
+}
+
+typedef struct {
+  int32_t ordinal;
+  double distance;
+} host_choice;
+
+static void consider(const walk_context *context, const layer_walk *walk, int32_t orphan, int32_t host, host_test test,
+                     host_choice *best) {
+  if (host == orphan || walk->reached[host] != 1 || !is_live(context, host) || !test(context, walk, host)) { return; }
+  double away = pair_distance(context, orphan, host);
+  if (best->ordinal == NO_NODE || away < best->distance) {
+    best->ordinal = host;
+    best->distance = away;
+  }
+}
+
+static int32_t nearest_host(const walk_context *context, const layer_walk *walk, int32_t orphan,
+                            const nearby_nodes *nearby, host_test test) {
+  host_choice best = {NO_NODE, 0};
+  for (uint32_t i = 0; i < nearby->count; i++) { consider(context, walk, orphan, nearby->list[i], test, &best); }
+  uint32_t count = 0;
+  const int32_t *list = base_list(context, orphan, &count);
+  for (uint32_t i = 1; i <= count; i++) {
+    int32_t host = list[i];
+    if (host < 0 || (uint32_t)host >= context->slots || nearby->holds[host] == 1) { continue; }
+    consider(context, walk, orphan, host, test, &best);
+  }
+  if (best.ordinal != NO_NODE) { return best.ordinal; }
+  for (uint32_t host = 0; host < context->slots; host++) {
+    consider(context, walk, orphan, (int32_t)host, test, &best);
+  }
+  return best.ordinal;
+}
+
+static void take_out_farthest_link_outside_the_walk(const walk_context *context, const layer_walk *walk, int32_t host) {
+  node_lock(context, host);
+  uint32_t count = 0;
+  int32_t *list = base_list(context, host, &count);
+  uint32_t farthest = 0;
+  double farthest_distance = 0;
+  for (uint32_t i = 1; i <= count; i++) {
+    base_link link = {host, list[i]};
+    if (!reached_through_another_node(context, walk, link)) { continue; }
+    double away = pair_distance(context, host, list[i]);
+    if (farthest == 0 || away > farthest_distance) {
+      farthest = i;
+      farthest_distance = away;
+    }
+  }
+  if (farthest != 0) {
+    int32_t taken = list[farthest];
+    for (uint32_t i = farthest; i < count; i++) { list[i] = list[i + 1]; }
+    list[0] = (int32_t)(count - 1);
+    note_unlinked(context, taken);
+  }
+  node_unlock(context, host);
+}
+
+static void append_to(const walk_context *context, node_layer host, int32_t orphan) {
+  node_lock(context, host.ordinal);
+  list_add(context, host, orphan);
+  node_unlock(context, host.ordinal);
+}
+
+static void gather_nearby(const walk_context *context, const narsil_connect_request *request, nearby_nodes *nearby) {
+  for (uint32_t i = 0; i < request->nearby_count; i++) {
+    int32_t ordinal = request->nearby[i];
+    if (ordinal < 0 || (uint32_t)ordinal >= context->slots || nearby->holds[ordinal] == 1) { continue; }
+    nearby->holds[ordinal] = 1;
+    nearby->list[nearby->count++] = ordinal;
+  }
+}
+
+static void connect_every_unreached(const walk_context *context, layer_walk *walk, const nearby_nodes *nearby) {
+  for (uint32_t ordinal = 0; ordinal < context->slots; ordinal++) {
+    int32_t orphan = (int32_t)ordinal;
+    if (walk->reached[orphan] == 1 || !is_live(context, orphan)) { continue; }
+    int32_t host = nearest_host(context, walk, orphan, nearby, has_room);
+    if (host == NO_NODE) {
+      host = nearest_host(context, walk, orphan, nearby, holds_link_outside_the_walk);
+      if (host == NO_NODE) { continue; }
+      take_out_farthest_link_outside_the_walk(context, walk, host);
+    }
+    node_layer host_base = {host, 0};
+    append_to(context, host_base, orphan);
+    base_link arrival = {host, orphan};
+    walk_from(context, walk, arrival);
+  }
+}
+
+static narsil_status begin_connect(walk_context *context, narsil_workspace *workspace, const narsil_graph *graph,
+                                   const narsil_store *store, const narsil_connect_request *request) {
+  if (request == NULL || (request->nearby == NULL && request->nearby_count > 0)) { return NARSIL_INVALID_ARGUMENT; }
+  narsil_status status = begin_walk(context, workspace, graph, store, request->metric);
+  if (status != NARSIL_OK) { return status; }
+  if (request->thread_slot >= graph->thread_slots) { return NARSIL_INVALID_ARGUMENT; }
+  if (load_word(graph->header, NARSIL_GRAPH_WORD_LOCK) != NARSIL_GRAPH_HELD_ALONE) {
+    return NARSIL_GRAPH_NOT_HELD_ALONE;
+  }
+  context->thread_slot = request->thread_slot;
+  return read_graph_extent(context);
+}
+
+narsil_status narsil_connect_unreached(narsil_workspace *workspace, const narsil_graph *graph,
+                                       const narsil_store *store, const narsil_connect_request *request) {
+  walk_context context;
+  narsil_status status = begin_connect(&context, workspace, graph, store, request);
+  if (status != NARSIL_OK) { return status; }
+  status = link_from_nearest(&context);
+  if (status != NARSIL_OK) { return status; }
+  int32_t entry = load_word(graph->header, NARSIL_GRAPH_WORD_ENTRY_POINT);
+  if (node_top_layer(&context, entry) < 0) { return NARSIL_OK; }
+  size_t slots = context.slots;
+  layer_walk walk = {calloc(slots, sizeof *walk.reached), calloc(slots, sizeof *walk.first_reached_through),
+                     calloc(slots, sizeof *walk.queue), 0, 0};
+  nearby_nodes nearby = {calloc((size_t)request->nearby_count + 1, sizeof *nearby.list), 0, calloc(slots, 1)};
+  if (walk.reached != NULL && walk.first_reached_through != NULL && walk.queue != NULL && nearby.list != NULL &&
+      nearby.holds != NULL) {
+    base_link arrival = {NO_NODE, entry};
+    walk_from(&context, &walk, arrival);
+    gather_nearby(&context, request, &nearby);
+    connect_every_unreached(&context, &walk, &nearby);
+  } else {
+    status = NARSIL_OUT_OF_MEMORY;
+  }
+  free(walk.reached);
+  free(walk.first_reached_through);
+  free(walk.queue);
+  free(nearby.list);
+  free(nearby.holds);
+  return status;
+}

package/cpp/core/src/distance.c

@@ -0,0 +1,103 @@
+#include "internal.h"
+
+#include "../include/narsil_core.h"
+
+#include <math.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+typedef struct {
+  double lower;
+  double upper;
+  double correction;
+  double sum;
+  uint32_t bits;
+} code_summary;
+
+static uint32_t level_products(const walk_context *context, const uint8_t *record) {
+  const narsil_store *store = context->store;
+  const prepared_code *query = &context->code;
+  if (store->bits == BITS_PER_BYTE) { return kernel_products_8x8(record, query->levels, store->dimension); }
+  if (store->bits == 4) {
+    return kernel_products_4x4(record, query->low_levels, query->high_levels, context->code_bytes);
+  }
+  packed_code document = {record, context->code_bytes, store->bits};
+  return kernel_products_bits(document, query->planes);
+}
+
+static float trailer_float(const uint8_t *trailer, size_t offset) {
+  float value = 0;
+  memcpy(&value, trailer + offset, sizeof value);
+  return value;
+}
+
+static code_summary summary_of_record(const walk_context *context, const uint8_t *record) {
+  const uint8_t *trailer = record + context->code_bytes;
+  uint32_t sum_of_levels = 0;
+  memcpy(&sum_of_levels, trailer + TRAILER_SUM, sizeof sum_of_levels);
+  code_summary summary = {(double)trailer_float(trailer, TRAILER_LOWER), (double)trailer_float(trailer, TRAILER_UPPER),
+                          (double)trailer_float(trailer, TRAILER_CORRECTION), (double)sum_of_levels,
+                          context->store->bits};
+  return summary;
+}
+
+static double distance_from_products(const walk_context *context, uint32_t products, code_summary document,
+                                     code_summary query) {
+  double document_step = (document.upper - document.lower) / (double)((1U << document.bits) - 1);
+  double query_step = (query.upper - query.lower) / (double)((1U << query.bits) - 1);
+  double centred = (document.lower * query.lower * context->store->dimension) +
+                   (query.lower * document_step * document.sum) + (document.lower * query_step * query.sum) +
+                   (document_step * query_step * (double)products);
+  if (context->metric == NARSIL_METRIC_EUCLIDEAN) {
+    double squared = document.correction + query.correction - (2 * centred);
+    return sqrt(squared > 0 ? squared : 0);
+  }
+  double similarity = centred + document.correction + query.correction - context->centroid_dot;
+  if (context->metric == NARSIL_METRIC_DOT_PRODUCT) { return -similarity; }
+  if (similarity < -1) { similarity = -1; }
+  if (similarity > 1) { similarity = 1; }
+  return 1 - similarity;
+}
+
+double estimate_distance(const walk_context *context, const uint8_t *record) {
+  const prepared_code *code = &context->code;
+  code_summary query = {code->range.lower, code->range.upper, code->correction, code->sum, code->bits};
+  return distance_from_products(context, level_products(context, record), summary_of_record(context, record), query);
+}
+
+double estimate_pair_distance(const walk_context *context, const uint8_t *first, const uint8_t *second) {
+  packed_code document = {first, context->code_bytes, context->store->bits};
+  uint32_t products = kernel_pair_products(document, second, context->store->dimension);
+  return distance_from_products(context, products, summary_of_record(context, first),
+                                summary_of_record(context, second));
+}
+
+double walk_distance(const walk_context *context, int32_t ordinal) {
+  if (!context->uses_codes) { return float_distance(context, context->query, ordinal); }
+  if (ordinal < 0 || (uint32_t)ordinal >= context->store_slots) { return HUGE_VAL; }
+  if (context->store->code_present[ordinal] != 1) { return HUGE_VAL; }
+  const uint8_t *record = stored_record(context->store, ordinal);
+  return record == NULL ? HUGE_VAL : estimate_distance(context, record);
+}
+
+narsil_status narsil_score(narsil_workspace *workspace, const narsil_store *store, const narsil_score_request *request,
+                           double *distances) {
+  if (workspace == NULL || store == NULL || request == NULL || distances == NULL) { return NARSIL_INVALID_ARGUMENT; }
+  if (request->query == NULL || (request->count > 0 && request->ordinals == NULL)) { return NARSIL_INVALID_ARGUMENT; }
+  if (!store_is_complete(store) || !is_metric(request->metric) || store->dimension == 0) {
+    return NARSIL_INVALID_ARGUMENT;
+  }
+  narsil_status status = workspace_reserve_dimension(workspace, store->dimension);
+  if (status != NARSIL_OK) { return status; }
+  walk_context context;
+  memset(&context, 0, sizeof context);
+  context.store = store;
+  context.workspace = workspace;
+  context.metric = (narsil_metric)request->metric;
+  float_query measured = {request->query, (double)kernel_magnitude(request->query, store->dimension)};
+  for (uint32_t i = 0; i < request->count; i++) {
+    distances[i] = float_distance(&context, measured, request->ordinals[i]);
+  }
+  return NARSIL_OK;
+}