lqft-python-engine 1.0.5__tar.gz → 1.0.6__tar.gz

{lqft_python_engine-1.0.5 → lqft_python_engine-1.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lqft-python-engine
-Version: 1.0.5
+Version: 1.0.6
 Summary: LQFT Engine: 14.3M Ops/sec O(1) Time | O(Σ) Space Data Structure
 Home-page: https://github.com/ParjadM/Log-Quantum-Fractal-Tree-LQFT-
 Author: Parjad Minooei

{lqft_python_engine-1.0.5 → lqft_python_engine-1.0.6}/lqft_engine.c

@@ -134,7 +134,7 @@ static inline void fast_unlock(volatile long* lk) {
 // GLOBAL METRIC SHARDING (F-02)
 // ===================================================================
 
-#define MAX_TRACKED_THREADS 256
+#define MAX_TRACKED_THREADS 4096
 
 typedef struct {
     int64_t phys_added;
@@ -146,6 +146,8 @@ typedef struct {
 static ALIGN_64 ThreadMetrics global_metrics_array[MAX_TRACKED_THREADS];
 static volatile long registered_threads_count = 0;
 static THREAD_LOCAL ThreadMetrics* my_metrics = NULL;
+static volatile long global_arena_epoch = 1;
+static THREAD_LOCAL long local_arena_epoch = 0;
 
 static inline ThreadMetrics* get_my_metrics() {
     if (my_metrics == NULL) {
@@ -157,7 +159,8 @@ static inline ThreadMetrics* get_my_metrics() {
         if (idx < MAX_TRACKED_THREADS) {
             my_metrics = &global_metrics_array[idx];
         } else {
-            my_metrics = &global_metrics_array[0]; 
+            // Overflow bucket to avoid distorting thread-0 metrics.
+            my_metrics = &global_metrics_array[MAX_TRACKED_THREADS - 1];
         }
     }
     return my_metrics;
@@ -278,6 +281,66 @@ static THREAD_LOCAL LQFTNode*** local_ret_arr_head = NULL;
 static THREAD_LOCAL LQFTNode*** local_ret_arr_tail = NULL;
 static THREAD_LOCAL int local_ret_arr_count = 0;
 
+static inline void reset_tls_state_if_needed(void) {
+    long ge = global_arena_epoch;
+    if (local_arena_epoch == ge) return;
+
+    // A global purge/free_all occurred. Drop stale per-thread pointers.
+    local_arena.current_node_chunk = NULL;
+    local_arena.node_chunk_idx = ARENA_CHUNK_SIZE;
+    local_arena.node_free_list = NULL;
+    local_arena.current_child_chunk = NULL;
+    local_arena.child_chunk_idx = ARENA_CHUNK_SIZE;
+    local_arena.array_free_list = NULL;
+
+    local_ret_node_head = NULL;
+    local_ret_node_tail = NULL;
+    local_ret_node_count = 0;
+    local_ret_arr_head = NULL;
+    local_ret_arr_tail = NULL;
+    local_ret_arr_count = 0;
+
+    local_arena_epoch = ge;
+}
+
+static inline NodeChunk* pop_pre_zeroed_node_chunk(void) {
+    NodeChunk* head;
+    for (;;) {
+        head = pre_zeroed_node_chunks;
+        if (!head) return NULL;
+#ifdef _MSC_VER
+        if (_InterlockedCompareExchangePointer((void* volatile*)&pre_zeroed_node_chunks, (void*)head->next_global, (void*)head) == (void*)head) {
+            _InterlockedDecrement(&pre_node_count);
+            return head;
+        }
+#else
+        if (__sync_bool_compare_and_swap(&pre_zeroed_node_chunks, head, head->next_global)) {
+            __sync_fetch_and_sub(&pre_node_count, 1);
+            return head;
+        }
+#endif
+    }
+}
+
+static inline ChildChunk* pop_pre_zeroed_child_chunk(void) {
+    ChildChunk* head;
+    for (;;) {
+        head = pre_zeroed_child_chunks;
+        if (!head) return NULL;
+#ifdef _MSC_VER
+        if (_InterlockedCompareExchangePointer((void* volatile*)&pre_zeroed_child_chunks, (void*)head->next_global, (void*)head) == (void*)head) {
+            _InterlockedDecrement(&pre_child_count);
+            return head;
+        }
+#else
+        if (__sync_bool_compare_and_swap(&pre_zeroed_child_chunks, head, head->next_global)) {
+            __sync_fetch_and_sub(&pre_child_count, 1);
+            return head;
+        }
+#endif
+    }
+}
+
 static LQFTNode** registry = NULL;
 
 typedef struct {
@@ -382,6 +445,8 @@ void* background_alloc_thread(void* arg) {
 }
 
 LQFTNode* create_node(void* value, uint64_t key_hash, LQFTNode** children_src, uint64_t full_hash) {
+    reset_tls_state_if_needed();
+
     LQFTNode* node = NULL;
     if (!local_arena.node_free_list) {
 #ifdef _MSC_VER
@@ -405,20 +470,7 @@ LQFTNode* create_node(void* value, uint64_t key_hash, LQFTNode** children_src, u
         local_arena.node_free_list = (LQFTNode*)node->children;
     } else {
         if (local_arena.node_chunk_idx >= ARENA_CHUNK_SIZE) {
-            NodeChunk* new_chunk = NULL;
-#ifdef _MSC_VER
-            do {
-                new_chunk = pre_zeroed_node_chunks;
-                if (!new_chunk) break;
-            } while (_InterlockedCompareExchangePointer((void* volatile*)&pre_zeroed_node_chunks, (void*)new_chunk->next_global, (void*)new_chunk) != (void*)new_chunk);
-            if (new_chunk) _InterlockedDecrement(&pre_node_count);
-#else
-            do {
-                new_chunk = pre_zeroed_node_chunks;
-                if (!new_chunk) break;
-            } while (!__sync_bool_compare_and_swap(&pre_zeroed_node_chunks, new_chunk, new_chunk->next_global));
-            if (new_chunk) __sync_fetch_and_sub(&pre_node_count, 1);
-#endif
+            NodeChunk* new_chunk = pop_pre_zeroed_node_chunk();
             if (!new_chunk) {
                 new_chunk = alloc_node_chunk();
             }
@@ -461,20 +513,7 @@ LQFTNode* create_node(void* value, uint64_t key_hash, LQFTNode** children_src, u
             local_arena.array_free_list = (LQFTNode***)arr[0];
         } else {
             if (local_arena.child_chunk_idx >= ARENA_CHUNK_SIZE) {
-                ChildChunk* new_chunk = NULL;
-#ifdef _MSC_VER
-                do {
-                    new_chunk = pre_zeroed_child_chunks;
-                    if (!new_chunk) break;
-                } while (_InterlockedCompareExchangePointer((void* volatile*)&pre_zeroed_child_chunks, (void*)new_chunk->next_global, (void*)new_chunk) != (void*)new_chunk);
-                if (new_chunk) _InterlockedDecrement(&pre_child_count);
-#else
-                do {
-                    new_chunk = pre_zeroed_child_chunks;
-                    if (!new_chunk) break;
-                } while (!__sync_bool_compare_and_swap(&pre_zeroed_child_chunks, new_chunk, new_chunk->next_global));
-                if (new_chunk) __sync_fetch_and_sub(&pre_child_count, 1);
-#endif
+                ChildChunk* new_chunk = pop_pre_zeroed_child_chunk();
                 if (!new_chunk) {
                     new_chunk = alloc_child_chunk();
                 }
@@ -498,8 +537,10 @@ LQFTNode* create_node(void* value, uint64_t key_hash, LQFTNode** children_src, u
 
 void decref(LQFTNode* start_node) {
     if (!start_node || start_node == TOMBSTONE) return;
-    LQFTNode* cleanup_stack[512]; 
+    int cap = 1024;
     int top = 0;
+    LQFTNode** cleanup_stack = (LQFTNode**)malloc((size_t)cap * sizeof(LQFTNode*));
+    if (!cleanup_stack) return;
     cleanup_stack[top++] = start_node;
     while (top > 0) {
         LQFTNode* node = cleanup_stack[--top];
@@ -512,7 +553,19 @@ void decref(LQFTNode* start_node) {
             fast_unlock(&stripe_locks[stripe].flag);
             if (node->children) {
                 for (int i = 0; i < 32; i++) {
-                    if (node->children[i]) cleanup_stack[top++] = node->children[i];
+                    if (node->children[i]) {
+                        if (top >= cap) {
+                            int next_cap = cap * 2;
+                            LQFTNode** grown = (LQFTNode**)realloc(cleanup_stack, (size_t)next_cap * sizeof(LQFTNode*));
+                            if (!grown) {
+                                free(cleanup_stack);
+                                return;
+                            }
+                            cleanup_stack = grown;
+                            cap = next_cap;
+                        }
+                        cleanup_stack[top++] = node->children[i];
+                    }
                 }
                 LQFTNode*** arr = (LQFTNode***)node->children;
                 arr[0] = (LQFTNode**)local_ret_arr_head;
@@ -564,6 +617,23 @@ void decref(LQFTNode* start_node) {
             get_my_metrics()->phys_freed++;
         }
     }
+    free(cleanup_stack);
+}
+
+static inline int node_matches_signature(const LQFTNode* node, const char* value_ptr, uint64_t key_hash, LQFTNode** children) {
+    if (!node) return 0;
+    if (node->key_hash != key_hash) return 0;
+
+    if ((node->value == NULL) != (value_ptr == NULL)) return 0;
+    if (node->value && value_ptr && strcmp((const char*)node->value, value_ptr) != 0) return 0;
+
+    if ((node->children == NULL) != (children == NULL)) return 0;
+    if (node->children && children) {
+        for (int i = 0; i < 32; i++) {
+            if (node->children[i] != children[i]) return 0;
+        }
+    }
+    return 1;
 }
 
 LQFTNode* get_canonical_v2(const char* value_ptr, uint64_t key_hash, LQFTNode** children, uint64_t full_hash) {
@@ -571,20 +641,28 @@ LQFTNode* get_canonical_v2(const char* value_ptr, uint64_t key_hash, LQFTNode**
     uint32_t local_idx = (uint32_t)((full_hash ^ (full_hash >> 32)) & STRIPE_MASK);
     uint32_t global_idx = (stripe * STRIPE_SIZE) + local_idx;
     uint32_t start_idx = local_idx;
+
+    // Minimal stability hardening: protect canonical-registry probing with stripe lock
+    // to avoid racing against concurrent tombstoning/reclamation.
+    fast_lock_backoff(&stripe_locks[stripe].flag);
     for (;;) {
         LQFTNode* slot = registry[global_idx];
         if (slot == NULL) break;
-        if (slot != TOMBSTONE && slot->full_hash_val == full_hash) {
-            ATOMIC_INC(&slot->ref_count); 
+        if (slot != TOMBSTONE && slot->full_hash_val == full_hash && node_matches_signature(slot, value_ptr, key_hash, children)) {
+            ATOMIC_INC(&slot->ref_count);
+            fast_unlock(&stripe_locks[stripe].flag);
             return slot;
         }
         local_idx = (local_idx + 1) & STRIPE_MASK;
         global_idx = (stripe * STRIPE_SIZE) + local_idx;
-        if (local_idx == start_idx) break; 
+        if (local_idx == start_idx) break;
     }
+    fast_unlock(&stripe_locks[stripe].flag);
+
     LQFTNode* new_node = create_node(value_ptr ? (void*)portable_strdup(value_ptr) : NULL, key_hash, children, full_hash);
     if (!new_node) return NULL;
-    new_node->ref_count = 1; 
+    new_node->ref_count = 1;
+
     fast_lock_backoff(&stripe_locks[stripe].flag);
     local_idx = (uint32_t)((full_hash ^ (full_hash >> 32)) & STRIPE_MASK);
     global_idx = (stripe * STRIPE_SIZE) + local_idx;
@@ -594,7 +672,7 @@ LQFTNode* get_canonical_v2(const char* value_ptr, uint64_t key_hash, LQFTNode**
         LQFTNode* slot = registry[global_idx];
         if (slot == NULL) break;
         if (slot == TOMBSTONE) { if (first_tombstone == -1) first_tombstone = (int)local_idx; }
-        else if (slot->full_hash_val == full_hash) {
+        else if (slot->full_hash_val == full_hash && node_matches_signature(slot, value_ptr, key_hash, children)) {
             ATOMIC_INC(&slot->ref_count);
             fast_unlock(&stripe_locks[stripe].flag);
             if (new_node->value) free(new_node->value);
@@ -745,8 +823,18 @@ char* core_search(uint64_t h, LQFTNode* root) {
 }
 
 static void c_internal_insert_rw(uint64_t h, const char* val_str) {
-    uint64_t pre = fnv1a_update(FNV_OFFSET_BASIS, "leaf:", 5);
-    pre = fnv1a_update(pre, val_str, strlen(val_str));
+    // Small TLS cache avoids repeated value hashing for hot constants (e.g. "x", "active").
+    static THREAD_LOCAL const char* last_val_ptr = NULL;
+    static THREAD_LOCAL uint64_t last_pre = 0;
+    uint64_t pre;
+    if (val_str == last_val_ptr) {
+        pre = last_pre;
+    } else {
+        pre = fnv1a_update(FNV_OFFSET_BASIS, "leaf:", 5);
+        pre = fnv1a_update(pre, val_str, strlen(val_str));
+        last_val_ptr = val_str;
+        last_pre = pre;
+    }
     uint32_t shard = (uint32_t)((h >> 48) & ROOT_MASK);
     get_my_metrics()->logical_inserts++;
     int spin = 0;
@@ -976,6 +1064,13 @@ static PyObject* method_free_all(PyObject* self, PyObject* args) {
     for (int i = 0; i < MAX_TRACKED_THREADS; i++) {
         global_metrics_array[i].phys_added = 0; global_metrics_array[i].phys_freed = 0; global_metrics_array[i].logical_inserts = 0;
     }
+#ifdef _MSC_VER
+    _InterlockedExchange(&registered_threads_count, 0);
+    _InterlockedIncrement(&global_arena_epoch);
+#else
+    __sync_lock_test_and_set(&registered_threads_count, 0);
+    __sync_add_and_fetch(&global_arena_epoch, 1);
+#endif
     for(int i = NUM_STRIPES - 1; i >= 0; i--) fast_unlock(&stripe_locks[i].flag);
     for(int i = NUM_ROOTS - 1; i >= 0; i--) { 
         global_roots[i].root = NULL; 

{lqft_python_engine-1.0.5 → lqft_python_engine-1.0.6}/lqft_engine.py

@@ -1,7 +1,12 @@
-import hashlib
-import psutil
 import os
 import sys
+import hashlib
+import threading
+
+try:
+    import psutil
+except Exception:
+    psutil = None
 
 # ---------------------------------------------------------
 # STRICT NATIVE ENTERPRISE WRAPPER (v1.0.5)
@@ -18,14 +23,21 @@ except ImportError:
     sys.exit(1)
 
 class LQFT:
+    _instance_lock = threading.Lock()
+    _live_instances = 0
+
     # F-03 & F-04: Restored migration_threshold to sync API signatures across the suite
     def __init__(self, migration_threshold=50000):
         self.is_native = True
-        self.auto_purge_enabled = True
-        self.max_memory_mb = 1000.0 
+        # Keep destructive purge opt-in; global C-engine state can be shared by multiple wrappers.
+        self.auto_purge_enabled = False
+        self.max_memory_mb = 1000.0
         self.total_ops = 0
-        self.migration_threshold = migration_threshold 
-        self._process = psutil.Process(os.getpid())
+        self.migration_threshold = migration_threshold
+        self._process = psutil.Process(os.getpid()) if psutil else None
+        self._closed = False
+        with LQFT._instance_lock:
+            LQFT._live_instances += 1
 
     def _validate_type(self, key, value=None):
         if not isinstance(key, str):
@@ -34,13 +46,30 @@ class LQFT:
             raise TypeError(f"LQFT values must be strings. Received: {type(value).__name__}")
 
     def _get_64bit_hash(self, key):
-        return int(hashlib.md5(str(key).encode()).hexdigest()[:16], 16)
+        # Deterministic 64-bit hash keeps key mapping stable across processes/runs.
+        return int.from_bytes(hashlib.blake2b(key.encode(), digest_size=8).digest(), "little")
+
+    def _current_memory_mb(self):
+        if self._process is None:
+            return 0.0
+        try:
+            return self._process.memory_info().rss / (1024 * 1024)
+        except Exception:
+            return 0.0
 
     def set_auto_purge_threshold(self, threshold: float):
         self.max_memory_mb = threshold
 
     def purge(self):
-        current_mb = self._process.memory_info().rss / (1024 * 1024)
+        current_mb = self._current_memory_mb()
+        with LQFT._instance_lock:
+            live = LQFT._live_instances
+        if live > 1:
+            print(
+                f"\n[⚠️ CIRCUIT Breaker] Memory {current_mb:.1f} MB but purge skipped "
+                f"because {live} LQFT instances are active (shared global engine state)."
+            )
+            return
         print(f"\n[⚠️ CIRCUIT Breaker] Engine exceeded limit (Currently {current_mb:.1f} MB). Auto-Purging!")
         self.clear()
 
@@ -55,6 +84,7 @@ class LQFT:
         return stats.get('logical_inserts', 0)
 
     def clear(self):
+        # Global clear (shared native state). Keep explicit to avoid accidental data loss.
         return lqft_c_engine.free_all()
 
     def insert(self, key, value):
@@ -63,7 +93,7 @@ class LQFT:
         
         # Heuristic Circuit Breaker check
         if self.auto_purge_enabled and self.total_ops % 5000 == 0:
-            current_mb = self._process.memory_info().rss / (1024 * 1024)
+            current_mb = self._current_memory_mb()
             if current_mb >= self.max_memory_mb:
                 self.purge()
 
@@ -97,8 +127,13 @@ class LQFT:
         self.delete(key)
 
     def __del__(self):
-        try: self.clear()
-        except: pass
+        try:
+            if not self._closed:
+                with LQFT._instance_lock:
+                    LQFT._live_instances = max(0, LQFT._live_instances - 1)
+                self._closed = True
+        except Exception:
+            pass
 
     def status(self):
         return {

{lqft_python_engine-1.0.5 → lqft_python_engine-1.0.6}/lqft_python_engine.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lqft-python-engine
-Version: 1.0.5
+Version: 1.0.6
 Summary: LQFT Engine: 14.3M Ops/sec O(1) Time | O(Σ) Space Data Structure
 Home-page: https://github.com/ParjadM/Log-Quantum-Fractal-Tree-LQFT-
 Author: Parjad Minooei

{lqft_python_engine-1.0.5 → lqft_python_engine-1.0.6}/setup.py

@@ -3,7 +3,7 @@ import os
 import sys
 
 # ---------------------------------------------------------
-# LQFT BUILD SYSTEM - V1.0.5 (Apple Silicon M3 Hotfix)
+# LQFT BUILD SYSTEM - V1.0.6 (Apple Silicon M3 Hotfix)
 # Architect: Parjad Minooei
 # ---------------------------------------------------------
 
@@ -40,7 +40,7 @@ lqft_extension = Extension(
 
 setup(
     name="lqft-python-engine",
-    version="1.0.5", 
+    version="1.0.6", 
     description="LQFT Engine: 14.3M Ops/sec O(1) Time | O(Σ) Space Data Structure",
     long_description=long_description,
     long_description_content_type="text/markdown",