lqft-python-engine 0.9.0__tar.gz → 0.9.1__tar.gz

{lqft_python_engine-0.9.0 → lqft_python_engine-0.9.1}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: lqft-python-engine
-Version: 0.9.0
-Summary: LQFT Engine: Custom Memory Arena & O(1) Cryptographic Fast-Path (v0.9.0 Stable)
+Version: 0.9.1
+Summary: LQFT Engine: Custom Arena Allocator & O(1) Fast-Path (v0.9.1 Stable)
 Home-page: https://github.com/ParjadM/Log-Quantum-Fractal-Tree-LQFT-
 Author: Parjad Minooei
 License: MIT

{lqft_python_engine-0.9.0 → lqft_python_engine-0.9.1}/lqft_engine.c

@@ -11,15 +11,15 @@
 #include <stdint.h>
 
 /**
- * LQFT C-Engine - V1.0.6 (The Systems Allocator Build)
+ * LQFT C-Engine - V0.9.0 (High Density Memory Arena)
  * Architect: Parjad Minooei
  * * SYSTEMS ARCHITECTURE MILESTONES:
- * 1. SLAB ALLOCATOR (ARENA): Bypasses OS `malloc` overhead, saving ~16 bytes of hidden 
+ * 1. DYNAMIC DECOUPLING: Removed hardcoded children[32] from the struct. Leaves 
+ * now consume ~40 bytes instead of 288 bytes (an 86% memory reduction per item).
+ * 2. SLAB ALLOCATOR (ARENA): Bypasses OS `malloc` overhead, saving ~16 bytes of hidden 
  * metadata per node. Grabs memory in 16K chunks for O(1) bump-allocation.
- * 2. INTRINSIC FREE-LIST: Dead nodes repurpose their internal pointers to form an 
- * infinite, dynamically linked recycle bin without hitting OS `free()`.
  * 3. O(1) CRYPTOGRAPHIC FAST-PATH: Eliminated 32-way loops in branch hashing by using 
- * mathematical XOR inverses: (Hash ^ (Old * P) ^ (New * P)).
+ * mathematical XOR inverses.
  */
 
 #ifdef _MSC_VER
@@ -58,13 +58,14 @@
 
 typedef struct {
     lqft_rwlock_t lock;
-    char padding[128]; 
+    char padding[128]; // Cache-line isolation for macOS/Linux
 } PaddedLock;
 
+// v0.9.0 Memory Density Update: Decoupled pointer array
 typedef struct LQFTNode {
     void* value;
     uint64_t key_hash;
-    struct LQFTNode** children; 
+    struct LQFTNode** children; // NULL for leaves. 32-array allocated ONLY for branches.
     uint64_t full_hash_val;
     uint32_t registry_idx; 
     int ref_count;
@@ -88,7 +89,7 @@ typedef struct ChildChunk {
 
 static NodeChunk* current_node_chunk = NULL;
 static int node_chunk_idx = ARENA_CHUNK_SIZE;
-static LQFTNode* node_free_list = NULL; // Intrinsic linked list
+static LQFTNode* node_free_list = NULL;
 
 static ChildChunk* current_child_chunk = NULL;
 static int child_chunk_idx = ARENA_CHUNK_SIZE;
@@ -129,12 +130,10 @@ LQFTNode* create_node(void* value, uint64_t key_hash, LQFTNode** children_src) {
     LQFTNode* node = NULL;
     LQFT_RWLOCK_WRLOCK(&alloc_lock);
     
-    // 1. Check Intrinsic Free-List (O(1) Pop)
     if (node_free_list) {
         node = node_free_list;
         node_free_list = (LQFTNode*)node->children;
     } else {
-        // 2. Bump Allocation from Arena Chunk (O(1) Bump)
         if (node_chunk_idx >= ARENA_CHUNK_SIZE) {
             NodeChunk* new_chunk = (NodeChunk*)malloc(sizeof(NodeChunk));
             new_chunk->next = current_node_chunk;
@@ -166,7 +165,7 @@ LQFTNode* create_node(void* value, uint64_t key_hash, LQFTNode** children_src) {
         LQFT_RWLOCK_UNLOCK_WR(&alloc_lock);
         memcpy(node->children, children_src, sizeof(LQFTNode*) * 32);
     } else {
-        node->children = NULL; 
+        node->children = NULL; // 40-byte strict leaf
         LQFT_RWLOCK_UNLOCK_WR(&alloc_lock);
     }
     return node;
@@ -192,7 +191,6 @@ void decref(LQFTNode* start_node) {
                 for (int i = 0; i < 32; i++) {
                     if (node->children[i]) cleanup_stack[top++] = node->children[i];
                 }
-                // Send array to the free-list
                 LQFT_RWLOCK_WRLOCK(&alloc_lock);
                 node->children[0] = (LQFTNode*)array_free_list;
                 array_free_list = (LQFTNode***)node->children;
@@ -201,7 +199,6 @@ void decref(LQFTNode* start_node) {
 
             if (node->value) free(node->value);
             
-            // Send node to the intrinsic free-list
             LQFT_RWLOCK_WRLOCK(&alloc_lock);
             node->children = (LQFTNode**)node_free_list;
             node_free_list = node;
@@ -293,7 +290,7 @@ LQFTNode* core_insert_internal(uint64_t h, const char* val_ptr, LQFTNode* root,
         path_nodes[path_len] = curr;
         path_segs[path_len] = segment;
         path_len++;
-        if (curr->children[segment] == NULL) { curr = NULL; break; }
+        if (curr->children == NULL || curr->children[segment] == NULL) { curr = NULL; break; }
         curr = curr->children[segment];
         bit_depth += BIT_PARTITION;
     }
@@ -341,12 +338,12 @@ LQFTNode* core_insert_internal(uint64_t h, const char* val_ptr, LQFTNode* root,
             next_parent = get_canonical_v2(NULL, 0, new_children, new_sub_node->full_hash_val * FNV_PRIME);
         } else {
             LQFTNode* p = path_nodes[i];
-            LQFTNode* n_children[32]; 
-            memcpy(n_children, p->children, sizeof(LQFTNode*) * 32);
+            LQFTNode* n_children[32] = {NULL}; 
+            if (p->children) memcpy(n_children, p->children, sizeof(LQFTNode*) * 32);
             n_children[path_segs[i]] = new_sub_node;
             
             // O(1) XOR MATH OVERRIDE: Eliminates 32-way loop
-            uint64_t old_ch = p->children[path_segs[i]] ? p->children[path_segs[i]]->full_hash_val : 0;
+            uint64_t old_ch = (p->children && p->children[path_segs[i]]) ? p->children[path_segs[i]]->full_hash_val : 0;
             uint64_t new_ch = new_sub_node ? new_sub_node->full_hash_val : 0;
             uint64_t b_h = p->full_hash_val ^ (old_ch * FNV_PRIME) ^ (new_ch * FNV_PRIME);
             
@@ -366,7 +363,7 @@ LQFTNode* core_delete_internal(uint64_t h, LQFTNode* root) {
     while (curr != NULL && curr->value == NULL) {
         uint32_t segment = (h >> bit_depth) & MASK;
         path_nodes[path_len] = curr; path_segs[path_len] = segment; path_len++;
-        if (curr->children[segment] == NULL) return root; 
+        if (curr->children == NULL || curr->children[segment] == NULL) return root; 
         curr = curr->children[segment]; bit_depth += BIT_PARTITION;
     }
     
@@ -375,15 +372,16 @@ LQFTNode* core_delete_internal(uint64_t h, LQFTNode* root) {
     LQFTNode* new_sub_node = NULL; 
     for (int i = path_len - 1; i >= 0; i--) {
         LQFTNode* p = path_nodes[i];
-        LQFTNode* n_children[32]; memcpy(n_children, p->children, sizeof(LQFTNode*) * 32);
+        LQFTNode* n_children[32] = {NULL}; 
+        if (p->children) memcpy(n_children, p->children, sizeof(LQFTNode*) * 32);
         n_children[path_segs[i]] = new_sub_node;
         
         int has_c = 0; for(int j=0; j<32; j++) { if(n_children[j]) { has_c = 1; break; } }
         
         if (!has_c && p->value == NULL) { new_sub_node = NULL; } 
         else {
-            // O(1) XOR MATH OVERRIDE: Eliminates 32-way loop
-            uint64_t old_ch = p->children[path_segs[i]] ? p->children[path_segs[i]]->full_hash_val : 0;
+            // O(1) XOR MATH OVERRIDE
+            uint64_t old_ch = (p->children && p->children[path_segs[i]]) ? p->children[path_segs[i]]->full_hash_val : 0;
             uint64_t new_ch = new_sub_node ? new_sub_node->full_hash_val : 0;
             uint64_t b_h = p->full_hash_val ^ (old_ch * FNV_PRIME) ^ (new_ch * FNV_PRIME);
             
@@ -397,6 +395,7 @@ char* core_search(uint64_t h) {
     LQFTNode* curr = global_root; 
     int bit_depth = 0;
     while (curr != NULL && curr->value == NULL) {
+        if (curr->children == NULL) return NULL;
         curr = curr->children[(h >> bit_depth) & MASK];
         bit_depth += BIT_PARTITION;
     }
@@ -405,7 +404,7 @@ char* core_search(uint64_t h) {
 }
 
 // ===================================================================
-// OPTIMISTIC CONCURRENCY FFI ENDPOINTS
+// PYTHON FFI ENDPOINTS
 // ===================================================================
 
 static PyObject* method_insert(PyObject* self, PyObject* args) {
@@ -413,23 +412,10 @@ static PyObject* method_insert(PyObject* self, PyObject* args) {
     uint64_t pre = fnv1a_update(FNV_OFFSET_BASIS, "leaf:", 5);
     pre = fnv1a_update(pre, val_str, strlen(val_str));
     Py_BEGIN_ALLOW_THREADS
-    LQFTNode* old_root; LQFTNode* next;
-    while (1) {
-        LQFT_RWLOCK_RDLOCK(&root_lock);
-        old_root = global_root;
-        next = core_insert_internal(h, val_str, old_root, pre);
-        LQFT_RWLOCK_UNLOCK_RD(&root_lock);
-        
-        LQFT_RWLOCK_WRLOCK(&root_lock);
-        if (global_root == old_root) {
-            global_root = next; LQFT_RWLOCK_UNLOCK_WR(&root_lock);
-            if (old_root) decref(old_root);
-            break;
-        } else {
-            LQFT_RWLOCK_UNLOCK_WR(&root_lock);
-            if (next) decref(next);
-        }
-    }
+    LQFT_RWLOCK_WRLOCK(&root_lock);
+    LQFTNode* next = core_insert_internal(h, val_str, global_root, pre);
+    LQFTNode* old = global_root; global_root = next; if (old) decref(old);
+    LQFT_RWLOCK_UNLOCK_WR(&root_lock);
     Py_END_ALLOW_THREADS
     Py_RETURN_NONE;
 }
@@ -437,23 +423,10 @@ static PyObject* method_insert(PyObject* self, PyObject* args) {
 static PyObject* method_delete(PyObject* self, PyObject* args) {
     unsigned long long h; if (!PyArg_ParseTuple(args, "K", &h)) return NULL;
     Py_BEGIN_ALLOW_THREADS
-    LQFTNode* old_root; LQFTNode* next;
-    while(1) {
-        LQFT_RWLOCK_RDLOCK(&root_lock);
-        old_root = global_root;
-        next = core_delete_internal(h, old_root);
-        LQFT_RWLOCK_UNLOCK_RD(&root_lock);
-        
-        LQFT_RWLOCK_WRLOCK(&root_lock);
-        if (global_root == old_root) {
-            global_root = next; LQFT_RWLOCK_UNLOCK_WR(&root_lock);
-            if (old_root) decref(old_root);
-            break;
-        } else {
-            LQFT_RWLOCK_UNLOCK_WR(&root_lock);
-            if (next) decref(next);
-        }
-    }
+    LQFT_RWLOCK_WRLOCK(&root_lock);
+    LQFTNode* next = core_delete_internal(h, global_root);
+    LQFTNode* old = global_root; global_root = next; if (old) decref(old);
+    LQFT_RWLOCK_UNLOCK_WR(&root_lock);
     Py_END_ALLOW_THREADS
     Py_RETURN_NONE;
 }
@@ -467,7 +440,6 @@ static PyObject* method_search(PyObject* self, PyObject* args) {
     if (result) safe_copy = portable_strdup(result); 
     LQFT_RWLOCK_UNLOCK_RD(&root_lock);
     Py_END_ALLOW_THREADS
-    
     if (safe_copy) {
         PyObject* py_res = PyUnicode_FromString(safe_copy);
         free(safe_copy); return py_res;
@@ -546,7 +518,6 @@ static PyObject* method_free_all(PyObject* self, PyObject* args) {
     LQFT_RWLOCK_WRLOCK(&root_lock); 
     for(int i = 0; i < NUM_STRIPES; i++) LQFT_RWLOCK_WRLOCK(&stripe_locks[i].lock);
     
-    // Clear String Payloads
     if (registry) { 
         for (int i = 0; i < REGISTRY_SIZE; i++) { 
             if (registry[i] && registry[i] != TOMBSTONE) { 
@@ -556,7 +527,6 @@ static PyObject* method_free_all(PyObject* self, PyObject* args) {
         } 
     }
     
-    // Drop massive memory chunks instantly instead of looping
     NodeChunk* nc = current_node_chunk;
     while(nc) { NodeChunk* next = nc->next; free(nc); nc = next; }
     current_node_chunk = NULL; node_chunk_idx = ARENA_CHUNK_SIZE; node_free_list = NULL;

{lqft_python_engine-0.9.0 → lqft_python_engine-0.9.1}/lqft_engine.py

@@ -4,10 +4,11 @@ import os
 import sys
 
 # ---------------------------------------------------------
-# STRICT NATIVE ENTERPRISE ENGINE (v0.7.0)
+# STRICT NATIVE ENTERPRISE ENGINE (v0.9.0)
 # ---------------------------------------------------------
 # Architect: Parjad Minooei
 # Status: Pure Python fallback removed. Strict C-Core interface.
+# Features: Arena Allocator, Circuit Breaker, Disk Persistence, Batch FFI.
 
 try:
     import lqft_c_engine
@@ -34,6 +35,7 @@ class LQFT:
     def _get_64bit_hash(self, key):
         return int(hashlib.md5(key.encode()).hexdigest()[:16], 16)
 
+    # --- Systems Memory Management ---
     def set_auto_purge_threshold(self, threshold: float):
         self.max_memory_mb = threshold
 
@@ -42,6 +44,12 @@ class LQFT:
         print(f"\n[⚠️ CIRCUIT Breaker] Engine exceeded limit (Currently {current_mb:.1f} MB). Auto-Purging!")
         self.clear()
 
+    def get_stats(self):
+        return lqft_c_engine.get_metrics()
+
+    def clear(self):
+        return lqft_c_engine.free_all()
+
     # --- Native Disk Persistence ---
     def save_to_disk(self, filepath: str):
         lqft_c_engine.save_to_disk(filepath)
@@ -51,7 +59,7 @@ class LQFT:
             raise FileNotFoundError(f"Missing LQFT database file: {filepath}")
         lqft_c_engine.load_from_disk(filepath)
 
-    # --- Core Operations ---
+    # --- Core CRUD Operations ---
     def insert(self, key, value):
         self._validate_type(key, value)
         self.total_ops += 1
@@ -65,6 +73,11 @@ class LQFT:
         h = self._get_64bit_hash(key)
         lqft_c_engine.insert(h, value)
 
+    def search(self, key):
+        self._validate_type(key)
+        h = self._get_64bit_hash(key)
+        return lqft_c_engine.search(h)
+
     def remove(self, key):
         self._validate_type(key)
         h = self._get_64bit_hash(key)
@@ -73,10 +86,17 @@ class LQFT:
     def delete(self, key):
         self.remove(key)
 
-    def search(self, key):
-        self._validate_type(key)
-        h = self._get_64bit_hash(key)
-        return lqft_c_engine.search(h)
+    # --- High-Speed Batching (v0.9.0 Benchmark Optimization) ---
+    def insert_batch(self, keys, value_payload="batch_data"):
+        """Bypasses FFI loop tax by hashing in Python and sending one massive array to C."""
+        hashes = [self._get_64bit_hash(k) for k in keys]
+        self.total_ops += len(hashes)
+        lqft_c_engine.insert_batch(hashes, str(value_payload))
+
+    def search_batch(self, keys):
+        """High-speed bulk lookup for dashboards."""
+        hashes = [self._get_64bit_hash(k) for k in keys]
+        return lqft_c_engine.search_batch(hashes)
 
     # --- Pythonic Syntactic Sugar ---
     def __setitem__(self, key, value):
@@ -88,11 +108,8 @@ class LQFT:
             raise KeyError(key)
         return res
 
-    def clear(self):
-        return lqft_c_engine.free_all()
-
-    def get_stats(self):
-        return lqft_c_engine.get_metrics()
+    def __delitem__(self, key):
+        self.delete(key)
 
     def __del__(self):
         try: self.clear()
@@ -100,9 +117,9 @@ class LQFT:
 
     def status(self):
         return {
-            "mode": "Strict Native C-Engine",
+            "mode": "Strict Native C-Engine (Arena Allocator)",
             "items": lqft_c_engine.get_metrics().get('physical_nodes', 0),
-            "threshold": "DISABLED (Pure Hardware Mode)"
+            "threshold": f"{self.max_memory_mb} MB Circuit Breaker"
         }
 
 # Alias mapping so older benchmark scripts don't crash

{lqft_python_engine-0.9.0 → lqft_python_engine-0.9.1}/lqft_python_engine.egg-info/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: lqft-python-engine
-Version: 0.9.0
-Summary: LQFT Engine: Custom Memory Arena & O(1) Cryptographic Fast-Path (v0.9.0 Stable)
+Version: 0.9.1
+Summary: LQFT Engine: Custom Arena Allocator & O(1) Fast-Path (v0.9.1 Stable)
 Home-page: https://github.com/ParjadM/Log-Quantum-Fractal-Tree-LQFT-
 Author: Parjad Minooei
 License: MIT

{lqft_python_engine-0.9.0 → lqft_python_engine-0.9.1}/setup.py

@@ -3,10 +3,10 @@ import os
 import sys
 
 # ---------------------------------------------------------
-# LQFT BUILD SYSTEM - V0.9.0 (Multi-Language Core Prep)
+# LQFT BUILD SYSTEM - V0.9.1 (Stability & Performance Patch)
 # ---------------------------------------------------------
 # Architect: Parjad Minooei
-# Focus: Custom Memory Arena, O(1) Fast-Path, and High Density
+# Status: Production Core for Multi-Language Roadmap
 
 # Systems Architect Logic: Cross-Platform Compiler Routing
 extra_compile_args = []
@@ -14,7 +14,7 @@ extra_compile_args = []
 if os.name == 'nt':
     # Windows (MSVC or MinGW)
     if 'gcc' in sys.version.lower() or 'mingw' in sys.executable.lower():
-        # Aggressive GCC optimization for the new Slab Allocator
+        # Aggressive GCC optimization for the v0.9.x Slab Allocator
         extra_compile_args = ['-O3']
     else:
         # Microsoft Visual C++ optimizations
@@ -30,7 +30,7 @@ if os.path.exists("README.md"):
         long_description = fh.read()
 
 # Define the Native C-Extension
-# Note: Pointing to 'lqft_engine.c' containing the v1.0.6 Arena Allocator
+# Note: Standardized to 'lqft_engine.c' to match local environment naming.
 lqft_extension = Extension(
     'lqft_c_engine',
     sources=['lqft_engine.c'],
@@ -39,8 +39,8 @@ lqft_extension = Extension(
 
 setup(
     name="lqft-python-engine",
-    version="0.9.0", 
-    description="LQFT Engine: Custom Memory Arena & O(1) Cryptographic Fast-Path (v0.9.0 Stable)",
+    version="0.9.1", 
+    description="LQFT Engine: Custom Arena Allocator & O(1) Fast-Path (v0.9.1 Stable)",
     long_description=long_description,
     long_description_content_type="text/markdown",
     author="Parjad Minooei",