static_embeddings 1.5.6 → 1.5.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 550531f7573a8d05e8d5a3a1ae0fa301c01d77b238573ae11834797e8ac44a0f
-  data.tar.gz: 57f487c729296e3a858604dc64aa146aa6dd6e372a45961d90a61564e3c1b117
+  metadata.gz: cbb2b16d03e01ba91c8c856890e98537ff81c4b4961a4d4172dc2e8a27fb46e3
+  data.tar.gz: d182451276da091e5410fa5dcbf93ec08e773bfa51cc6226f0c244db132e3656
 SHA512:
-  metadata.gz: 52162c96d458dffaaec8498cd712678b4727b29ddaa66eadf7834893113a6bd05f636cc47a2f84d969f76eb4651fe57664212fdb4ac2925449827b9d3a69a9bf
-  data.tar.gz: 115a0b0f3ff9d82cea099fc0ee24385034d8bcc66ca4ff9337f2213608ee4d611215b6d3400fe39aecf562cf201f5f5044eab7f9863fbdc813362c0af0eb7739
+  metadata.gz: 54d96917d4a2fd738787ee12bd57a63f3793893a4abe3e59a9b860efe8508a895cb4d1cbd865f4f5692af1b2aa46eea21b17b55ed090b98a9af8df59946feadc
+  data.tar.gz: da73a4ead8792691b1e8433ecb7487f121e1dda88c61054e56f0f05b56c43f922a49643f1668da4c34be1258f654f134975cae5db875075f2a99e9bd2ea5256a

data/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## 1.5.8
+
+### Fixed
+
+- Cancellation flags shared by Ruby's unblock callback and native worker threads now use
+  atomic loads and stores, removing a C data race during interrupted embedding, tokenization,
+  and top-k operations.
+
+## 1.5.7
+
+### Fixed
+
+- Model mappings are no longer closed while embedding, warmup, or token-ID
+  operations are using them without the GVL. `Model#close` raises
+  `StaticEmbeddings::Error` while such an operation is active.
+- Tokenizer code-point writes now verify the capacity invariant after growth.
+- Resolved Clang conversion warnings and formatting issues in the native code.
+
 ## 1.5.6
 
 Multi-source WordPiece release. The native `.semb` v3 runtime is unchanged; new

data/ext/static_embeddings/se_alloc_stats.c

@@ -5,9 +5,8 @@
 #include <string.h>
 
 static const char *const se_alloc_category_names[SE_ALLOC_CATEGORY_COUNT] = {
-    "unknown",    "scratch",     "batch_input",      "batch_output",
-    "batch_stats", "batch_index", "token_ids",       "topk_query",
-    "topk_best",  "topk_matrix_copy", "format_validate", "model_file"};
+    "unknown",   "scratch",    "batch_input", "batch_output",     "batch_stats",     "batch_index",
+    "token_ids", "topk_query", "topk_best",   "topk_matrix_copy", "format_validate", "model_file"};
 
 const char *se_alloc_category_name(se_alloc_category_t category) {
     if ((unsigned)category >= SE_ALLOC_CATEGORY_COUNT)
@@ -176,7 +175,8 @@ void *se_alloc_stats_realloc(se_alloc_category_t category, void *ptr, size_t byt
     if (old_header->h.magic != SE_ALLOC_STATS_MAGIC)
         abort();
 
-    se_alloc_category_t old_category = normalize_category((se_alloc_category_t)old_header->h.category);
+    se_alloc_category_t old_category =
+        normalize_category((se_alloc_category_t)old_header->h.category);
     size_t old_bytes = old_header->h.size;
     se_alloc_header_t *new_header = (se_alloc_header_t *)realloc(old_header, total);
     if (!new_header)
@@ -223,8 +223,7 @@ void se_alloc_stats_snapshot(se_alloc_stats_t out[SE_ALLOC_CATEGORY_COUNT]) {
     for (size_t i = 0; i < SE_ALLOC_CATEGORY_COUNT; i++) {
         out[i].current_bytes = atomic_load_size(&se_alloc_stats[i].current_bytes);
         out[i].peak_bytes = atomic_load_size(&se_alloc_stats[i].peak_bytes);
-        out[i].total_allocated_bytes =
-            atomic_load_size(&se_alloc_stats[i].total_allocated_bytes);
+        out[i].total_allocated_bytes = atomic_load_size(&se_alloc_stats[i].total_allocated_bytes);
         out[i].total_freed_bytes = atomic_load_size(&se_alloc_stats[i].total_freed_bytes);
         out[i].alloc_count = atomic_load_size(&se_alloc_stats[i].alloc_count);
         out[i].realloc_count = atomic_load_size(&se_alloc_stats[i].realloc_count);

data/ext/static_embeddings/se_embed.c

@@ -119,7 +119,7 @@ void se_l2_normalize(float *vec, uint32_t dim) {
 
 static se_status_t embed_ids_core(const se_model_t *model, se_scratch_t *sc, const uint32_t *ids,
                                   size_t n, float *out, se_error_t *err,
-                                  volatile sig_atomic_t *cancelled) {
+                                  se_cancel_flag_t *cancelled) {
     const uint32_t dim = model->meta.dim;
     float *acc = sc->acc;
     memset(acc, 0, (size_t)dim * sizeof(float));
@@ -129,7 +129,7 @@ static se_status_t embed_ids_core(const se_model_t *model, se_scratch_t *sc, con
 
     size_t used = 0;
     for (size_t i = 0; i < n; i++) {
-        if (((i & 255u) == 0) && cancelled && *cancelled) {
+        if (((i & 255u) == 0) && se_cancel_requested(cancelled)) {
             se_error_set(err, SE_ERR_INTERNAL, "operation cancelled");
             return SE_ERR_INTERNAL;
         }
@@ -179,7 +179,7 @@ static se_status_t embed_ids_core(const se_model_t *model, se_scratch_t *sc, con
 
 se_status_t se_embed_ids(const se_model_t *model, se_scratch_t *sc, const uint32_t *ids,
                          size_t n_ids, float *out, se_token_stats_t *stats, se_error_t *err,
-                         volatile sig_atomic_t *cancelled) {
+                         se_cancel_flag_t *cancelled) {
     if (n_ids > UINT32_MAX) {
         se_error_set(err, SE_ERR_OOM, "too many token ids");
         return SE_ERR_OOM;
@@ -196,7 +196,7 @@ se_status_t se_embed_ids(const se_model_t *model, se_scratch_t *sc, const uint32
 
 se_status_t se_embed_one(const se_model_t *model, se_scratch_t *sc, const uint8_t *input,
                          size_t input_len, uint32_t max_tokens, float *out, se_token_stats_t *stats,
-                         se_error_t *err, volatile sig_atomic_t *cancelled) {
+                         se_error_t *err, se_cancel_flag_t *cancelled) {
     se_status_t rc = se_tokenize(model, sc, input, input_len, max_tokens, SE_TOKEN_LIMIT_USABLE,
                                  stats, err, cancelled);
     if (rc != SE_OK)

data/ext/static_embeddings/se_f16.c

@@ -35,7 +35,7 @@ static void write_u16le(uint8_t *dst, uint16_t v) {
 }
 
 static uint16_t read_u16le(const uint8_t *src) {
-    return (uint16_t)src[0] | ((uint16_t)src[1] << 8);
+    return (uint16_t)((uint16_t)src[0] | ((uint16_t)src[1] << 8));
 }
 
 uint16_t se_float_to_f16_bits(float value) {

data/ext/static_embeddings/se_internal.h

@@ -3,9 +3,18 @@
 
 #include <stddef.h>
 #include <stdint.h>
-#include <signal.h>
 #include <limits.h>
 
+typedef int se_cancel_flag_t;
+
+static inline int se_cancel_requested(const se_cancel_flag_t *flag) {
+    return flag && __atomic_load_n(flag, __ATOMIC_RELAXED);
+}
+
+static inline void se_cancel_request(se_cancel_flag_t *flag) {
+    __atomic_store_n(flag, 1, __ATOMIC_RELAXED);
+}
+
 #define SE_MAGIC          "SEMBv1\0\0"
 #define SE_MAGIC_LEN      8
 #define SE_FORMAT_VERSION 3u
@@ -277,7 +286,7 @@ typedef struct {
     float *best_score;
     int cosine;
     float inv_query_norm;
-    volatile sig_atomic_t cancelled;
+    se_cancel_flag_t cancelled;
 } se_topk_job_t;
 
 SE_STATIC_ASSERT(sizeof(se_vocab_slot_t) == 16, vocab_slot_size);
@@ -415,14 +424,14 @@ typedef enum { SE_TOKEN_LIMIT_RAW = 0, SE_TOKEN_LIMIT_USABLE = 1 } se_token_limi
 
 se_status_t se_tokenize(const se_model_t *model, se_scratch_t *scratch, const uint8_t *input,
                         size_t input_len, uint32_t max_tokens, se_token_limit_t limit_mode,
-                        se_token_stats_t *stats, se_error_t *err, volatile sig_atomic_t *cancelled);
+                        se_token_stats_t *stats, se_error_t *err, se_cancel_flag_t *cancelled);
 
 se_status_t se_embed_one(const se_model_t *model, se_scratch_t *scratch, const uint8_t *input,
                          size_t input_len, uint32_t max_tokens, float *out, se_token_stats_t *stats,
-                         se_error_t *err, volatile sig_atomic_t *cancelled);
+                         se_error_t *err, se_cancel_flag_t *cancelled);
 se_status_t se_embed_ids(const se_model_t *model, se_scratch_t *scratch, const uint32_t *ids,
                          size_t n_ids, float *out, se_token_stats_t *stats, se_error_t *err,
-                         volatile sig_atomic_t *cancelled);
+                         se_cancel_flag_t *cancelled);
 
 void se_l2_normalize(float *vec, uint32_t dim);
 size_t se_model_warmup(const se_model_t *model);

data/ext/static_embeddings/se_tokenizer.c

@@ -495,11 +495,11 @@ typedef struct {
     int segment_ascii;
     se_token_stats_t *stats;
     se_error_t *err;
-    volatile sig_atomic_t *cancelled;
+    se_cancel_flag_t *cancelled;
 } token_state_t;
 
 static int token_cancelled(const token_state_t *st) {
-    return st->cancelled && *st->cancelled;
+    return se_cancel_requested(st->cancelled);
 }
 
 static se_status_t oom(token_state_t *st, const char *where) {
@@ -512,6 +512,8 @@ static int append_segment_cp(token_state_t *st, uint32_t cp) {
         st->segment_ascii = 0;
     if (!grow_u32(&st->scratch->cps, &st->scratch->cps_cap, st->segment_len + 1))
         return 0;
+    if (st->segment_len >= st->scratch->cps_cap)
+        return 0;
     st->scratch->cps[st->segment_len++] = cp;
     return 1;
 }
@@ -906,6 +908,10 @@ static se_status_t tokenize_ascii_run(token_state_t *st, const uint8_t *input, s
                     return oom(st, "building token segment");
                 }
             }
+            if (st->segment_len >= sc->cps_cap) {
+                *ip = i;
+                return oom(st, "building token segment");
+            }
             sc->cps[st->segment_len++] =
                 (lc && b >= 'A' && b <= 'Z') ? (uint32_t)(b + 32u) : (uint32_t)b;
             i++;
@@ -948,7 +954,7 @@ static se_status_t tokenize_ascii_run(token_state_t *st, const uint8_t *input, s
 se_status_t se_tokenize(const se_model_t *model, se_scratch_t *sc, const uint8_t *input,
                         size_t input_len, uint32_t max_tokens, se_token_limit_t limit_mode,
                         se_token_stats_t *stats, se_error_t *err,
-                        volatile sig_atomic_t *cancelled) {
+                        se_cancel_flag_t *cancelled) {
     memset(stats, 0, sizeof(*stats));
 
     token_state_t st;

data/ext/static_embeddings/se_topk.c

@@ -73,8 +73,7 @@ float se_dot_product_f32(const float *q, const float *row, size_t dim) {
     return dot;
 }
 
-float se_dot_and_row_sq_f32(const float *q, const float *row, size_t dim,
-                            float *row_sq_out) {
+float se_dot_and_row_sq_f32(const float *q, const float *row, size_t dim, float *row_sq_out) {
     size_t j = 0;
 #if defined(SE_HAVE_NEON)
     float32x4_t d0 = vdupq_n_f32(0.0f);
@@ -196,7 +195,7 @@ static float cosine_score(float dot, float row_sq, float inv_query_norm) {
 void *se_topk_execute(void *arg) {
     se_topk_job_t *job = (se_topk_job_t *)arg;
     for (size_t r = 0; r < job->rows; r++) {
-        if ((r & 1023u) == 0 && job->cancelled)
+        if ((r & 1023u) == 0 && se_cancel_requested(&job->cancelled))
             return NULL;
         float score;
 

data/ext/static_embeddings/static_embeddings.c

@@ -9,7 +9,6 @@
 #include <float.h>
 #include <limits.h>
 #include <math.h>
-#include <signal.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -93,6 +92,7 @@ RUBY_FUNC_EXPORTED void Init_static_embeddings(void);
 typedef struct {
     se_model_t model;
     int open;
+    unsigned int active_ops;
 } model_wrapper_t;
 
 static void model_free(void *ptr) {
@@ -177,7 +177,7 @@ static void check_text_encoding_mode(VALUE str, long index, se_encoding_validati
                  rb_enc_name(enc));
     }
 
-    int cr = ENC_CODERANGE(str);
+    int cr = (int)ENC_CODERANGE(str);
     if (cr == ENC_CODERANGE_UNKNOWN) {
         if (mode == SE_VALIDATE_ENCODING_PREFIX)
             return;
@@ -216,6 +216,7 @@ typedef struct {
 
 typedef struct {
     const se_model_t *model;
+    model_wrapper_t *owner;
     batch_input_t input;
     uint32_t max_tokens;
     float *out;
@@ -224,10 +225,12 @@ typedef struct {
     size_t next_index;
     int failed;
     size_t failed_index;
-    volatile sig_atomic_t cancelled;
+    se_cancel_flag_t cancelled;
     se_error_t error;
 } batch_job_t;
 
+static void run_job(batch_job_t *job, size_t total_bytes);
+
 static void job_fail(batch_job_t *job, se_error_t err, size_t index) {
     if (job->failed)
         return;
@@ -240,7 +243,7 @@ static void batch_worker_run(batch_job_t *job, se_scratch_t *scratch) {
     const uint32_t dim = job->model->meta.dim;
 
     for (;;) {
-        if (job->cancelled) {
+        if (se_cancel_requested(&job->cancelled)) {
             se_error_set(&job->error, SE_ERR_INTERNAL, "operation cancelled");
             job->failed = 1;
             return;
@@ -289,7 +292,7 @@ static void *batch_execute(void *arg) {
 static void unblock_cancel(void *arg) {
     batch_job_t *job = (batch_job_t *)arg;
     if (job)
-        job->cancelled = 1;
+        se_cancel_request(&job->cancelled);
 }
 
 static VALUE current_fiber_scheduler(void) {
@@ -354,13 +357,28 @@ static VALUE fiber_worker_ensure(VALUE wrapper) {
     fiber_worker_t *w;
     TypedData_Get_Struct(wrapper, fiber_worker_t, &fiber_worker_type, w);
     if (!NIL_P(w->thread)) {
-        w->job->cancelled = 1;
+        se_cancel_request(&w->job->cancelled);
         rb_funcall(w->thread, id_kill, 0);
         rb_funcall(w->thread, id_join, 0);
     }
     return Qnil;
 }
 
+static VALUE run_job_body(VALUE arg) {
+    batch_job_t *job = (batch_job_t *)(uintptr_t)arg;
+    size_t total_bytes = 0;
+    for (size_t i = 0; i < job->input.count; i++)
+        total_bytes += job->input.lengths[i];
+    run_job(job, total_bytes);
+    return Qnil;
+}
+
+static VALUE run_job_ensure(VALUE arg) {
+    batch_job_t *job = (batch_job_t *)(uintptr_t)arg;
+    job->owner->active_ops--;
+    return Qnil;
+}
+
 static void run_job(batch_job_t *job, size_t total_bytes) {
     VALUE scheduler = current_fiber_scheduler();
 
@@ -386,11 +404,8 @@ static void run_job(batch_job_t *job, size_t total_bytes) {
 
 static VALUE protected_run_job(VALUE arg) {
     batch_job_t *job = (batch_job_t *)(uintptr_t)arg;
-    size_t total_bytes = 0;
-    for (size_t i = 0; i < job->input.count; i++)
-        total_bytes += job->input.lengths[i];
-    run_job(job, total_bytes);
-    return Qnil;
+    job->owner->active_ops++;
+    return rb_ensure(run_job_body, arg, run_job_ensure, arg);
 }
 
 static VALUE model_alloc(VALUE klass) {
@@ -422,6 +437,8 @@ static VALUE model_close(VALUE self) {
     model_wrapper_t *w;
     TypedData_Get_Struct(self, model_wrapper_t, &model_type, w);
     if (w->open) {
+        if (w->active_ops != 0)
+            rb_raise(eError, "model is busy with an active operation");
         se_model_close(&w->model);
         w->open = 0;
     }
@@ -474,18 +491,40 @@ typedef struct {
     size_t pages;
 } warmup_job_t;
 
+typedef struct {
+    VALUE self;
+    model_wrapper_t *owner;
+    warmup_job_t job;
+} warmup_run_t;
+
 static void *warmup_execute(void *arg) {
     warmup_job_t *job = (warmup_job_t *)arg;
     job->pages = se_model_warmup(job->model);
     return NULL;
 }
 
+static VALUE warmup_body(VALUE arg) {
+    warmup_run_t *run = (warmup_run_t *)(uintptr_t)arg;
+    rb_thread_call_without_gvl(warmup_execute, &run->job, NULL, NULL);
+    RB_GC_GUARD(run->self);
+    return Qnil;
+}
+
+static VALUE warmup_ensure(VALUE arg) {
+    warmup_run_t *run = (warmup_run_t *)(uintptr_t)arg;
+    run->owner->active_ops--;
+    return Qnil;
+}
+
 static VALUE model_warmup(VALUE self) {
     model_wrapper_t *w = get_model(self);
-    warmup_job_t job;
-    job.model = &w->model;
-    job.pages = 0;
-    rb_thread_call_without_gvl(warmup_execute, &job, NULL, NULL);
+    warmup_run_t run;
+    run.self = self;
+    run.owner = w;
+    run.job.model = &w->model;
+    run.job.pages = 0;
+    w->active_ops++;
+    rb_ensure(warmup_body, (VALUE)(uintptr_t)&run, warmup_ensure, (VALUE)(uintptr_t)&run);
     RB_GC_GUARD(self);
     return self;
 }
@@ -829,6 +868,7 @@ static VALUE embed_texts_internal(VALUE self, VALUE texts, int is_array, size_t
         batch_job_t job;
         memset(&job, 0, sizeof(job));
         job.model = model;
+        job.owner = w;
         job.max_tokens = max_tokens;
         job.out = run.out;
         job.stats = run.stats;
@@ -844,7 +884,7 @@ static VALUE embed_texts_internal(VALUE self, VALUE texts, int is_array, size_t
         int state = 0;
         rb_protect(protected_run_job, (VALUE)(uintptr_t)&job, &state);
         if (state) {
-            job.cancelled = 1;
+            se_cancel_request(&job.cancelled);
             free_input(&job.input);
             embed_run_free(&run);
             rb_jump_tag(state);
@@ -1110,12 +1150,13 @@ typedef struct {
     size_t n_ids;
     float *out;
     se_token_stats_t stats;
-    volatile sig_atomic_t cancelled;
+    se_cancel_flag_t cancelled;
     se_error_t error;
 } ids_job_t;
 
 typedef struct {
     VALUE ids_value;
+    model_wrapper_t *owner;
     const se_model_t *model;
     uint32_t max_tokens;
     uint32_t *ids;
@@ -1126,6 +1167,7 @@ typedef struct {
     se_token_stats_t *stats_out;
     se_token_stats_t stats;
     int truncated;
+    int active;
 } ids_run_t;
 
 typedef struct {
@@ -1157,7 +1199,7 @@ static void *ids_execute(void *arg) {
 static void ids_unblock_cancel(void *arg) {
     ids_job_t *job = (ids_job_t *)arg;
     if (job)
-        job->cancelled = 1;
+        se_cancel_request(&job->cancelled);
 }
 
 static VALUE embed_token_ids_body(VALUE arg) {
@@ -1197,9 +1239,13 @@ static VALUE embed_token_ids_body(VALUE arg) {
     se_error_clear(&job.error);
 
     if (run->n >= SE_IDS_GVL_UNLOCK_THRESHOLD) {
+        run->owner->active_ops++;
+        run->active = 1;
         rb_thread_call_without_gvl(ids_execute, &job, ids_unblock_cancel, &job);
+        run->owner->active_ops--;
+        run->active = 0;
         rb_thread_check_ints();
-        if (job.cancelled)
+        if (se_cancel_requested(&job.cancelled))
             rb_raise(rb_eInterrupt, "operation cancelled");
     } else {
         ids_execute(&job);
@@ -1225,6 +1271,8 @@ static VALUE embed_token_ids_body(VALUE arg) {
 
 static VALUE embed_token_ids_ensure(VALUE arg) {
     ids_run_t *run = (ids_run_t *)(uintptr_t)arg;
+    if (run->active)
+        run->owner->active_ops--;
     se_free(run->ids);
     se_free(run->out);
     run->ids = NULL;
@@ -1280,6 +1328,7 @@ static VALUE embed_token_ids_value(VALUE self, VALUE ids_value, VALUE max_tokens
     ids_run_t run;
     memset(&run, 0, sizeof(run));
     run.ids_value = ids_value;
+    run.owner = w;
     run.model = &w->model;
     run.max_tokens = max_tokens;
     run.n = n;
@@ -1346,7 +1395,7 @@ static int ptr_is_float_aligned(const void *ptr) {
 static void topk_unblock_cancel(void *arg) {
     se_topk_job_t *job = (se_topk_job_t *)arg;
     if (job)
-        job->cancelled = 1;
+        se_cancel_request(&job->cancelled);
 }
 
 static VALUE topk_body(VALUE arg) {
@@ -1375,7 +1424,7 @@ static VALUE topk_body(VALUE arg) {
         rb_thread_check_ints();
     }
 
-    if (run->job.cancelled)
+    if (se_cancel_requested(&run->job.cancelled))
         rb_raise(rb_eInterrupt, "operation cancelled");
 
     VALUE result = rb_ary_new_capa(run->job.k);

data/lib/static_embeddings/version.rb

@@ -1,3 +1,3 @@
 module StaticEmbeddings
-  VERSION = "1.5.6"
+  VERSION = "1.5.8"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: static_embeddings
 version: !ruby/object:Gem::Version
-  version: 1.5.6
+  version: 1.5.8
 platform: ruby
 authors:
 - Roman Haydarov