static_embeddings 1.5.6 → 1.5.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 550531f7573a8d05e8d5a3a1ae0fa301c01d77b238573ae11834797e8ac44a0f
-  data.tar.gz: 57f487c729296e3a858604dc64aa146aa6dd6e372a45961d90a61564e3c1b117
+  metadata.gz: a8e174dd93ba3b3e9ee25047fd28ea5ba980d096a4922c0b8325c366208bff65
+  data.tar.gz: 741e0cc35791d9a335c82a05aed18e3388232828824168ff59ed1751c281e8a8
 SHA512:
-  metadata.gz: 52162c96d458dffaaec8498cd712678b4727b29ddaa66eadf7834893113a6bd05f636cc47a2f84d969f76eb4651fe57664212fdb4ac2925449827b9d3a69a9bf
-  data.tar.gz: 115a0b0f3ff9d82cea099fc0ee24385034d8bcc66ca4ff9337f2213608ee4d611215b6d3400fe39aecf562cf201f5f5044eab7f9863fbdc813362c0af0eb7739
+  metadata.gz: 58462ed4c203fb657630d092e1a4aa85857e5d44106bb97feae26f12579fc4b6d88d20632e462624ad0cb93e1d0d0e735f91ee12aaec80b637d29b313e6dc53d
+  data.tar.gz: 80e9897969dfe6aace3d851f1a11ffb6610b628cddc35239301a676b2ce32d97d1a8a614ae6dca0526703e61d6d813af89965d0906c593392e66cdd25f7e16da

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 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_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_tokenizer.c

@@ -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++;

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);

data/ext/static_embeddings/static_embeddings.c

@@ -93,6 +93,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 +178,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 +217,7 @@ typedef struct {
 
 typedef struct {
     const se_model_t *model;
+    model_wrapper_t *owner;
     batch_input_t input;
     uint32_t max_tokens;
     float *out;
@@ -228,6 +230,8 @@ typedef struct {
     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;
@@ -361,6 +365,21 @@ static VALUE fiber_worker_ensure(VALUE wrapper) {
     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 +405,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 +438,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 +492,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 +869,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;
@@ -1116,6 +1157,7 @@ typedef struct {
 
 typedef struct {
     VALUE ids_value;
+    model_wrapper_t *owner;
     const se_model_t *model;
     uint32_t max_tokens;
     uint32_t *ids;
@@ -1126,6 +1168,7 @@ typedef struct {
     se_token_stats_t *stats_out;
     se_token_stats_t stats;
     int truncated;
+    int active;
 } ids_run_t;
 
 typedef struct {
@@ -1197,7 +1240,11 @@ 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)
             rb_raise(rb_eInterrupt, "operation cancelled");
@@ -1225,6 +1272,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 +1329,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;

data/lib/static_embeddings/version.rb

@@ -1,3 +1,3 @@
 module StaticEmbeddings
-  VERSION = "1.5.6"
+  VERSION = "1.5.7"
 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.7
 platform: ruby
 authors:
 - Roman Haydarov