sram-engine 1.0.0__py3-none-any.whl

sram_engine/__init__.py

@@ -0,0 +1 @@
+from .core import SRAMCommandDispatcher, SRAMSession

sram_engine/core.py

@@ -0,0 +1,268 @@
+import os
+import mmap
+import ctypes
+import subprocess
+import sys
+
+# Embedded C Kernel Code (ARM NEON / Multi-threaded Worker Engine)
+C_KERNEL_CODE = """
+#include <stdint.h>
+#include <stdatomic.h>
+#include <pthread.h>
+#include <unistd.h>
+
+#define NUM_THREADS 8
+#define PARTITION_SIZE 40000
+
+typedef struct {
+    uint32_t d[12];
+} Node11D;
+
+typedef struct {
+    pthread_t thread;
+    volatile Node11D *target_base;
+    uint32_t worker_id;
+    uint64_t local_ops;
+    atomic_int running;
+    atomic_int paused;
+} __attribute__((aligned(64))) Target5MsWorker;
+
+static Target5MsWorker worker_pool[NUM_THREADS];
+
+void *target_5ms_worker_routine(void *arg) {
+    Target5MsWorker *w = (Target5MsWorker *__restrict__)arg;
+    uint64_t id = (uint64_t)w->worker_id;
+    uint64_t bytes_per_partition = PARTITION_SIZE * sizeof(Node11D);
+
+    while (atomic_load_explicit(&w->running, memory_order_relaxed)) {
+        if (atomic_load_explicit(&w->paused, memory_order_acquire)) {
+            usleep(50);
+            continue;
+        }
+
+        volatile Node11D *base = w->target_base;
+        if (!base) {
+            usleep(100);
+            continue;
+        }
+        uint64_t current_base = (uint64_t)base;
+        uint64_t end_base = current_base + bytes_per_partition;
+
+        __asm__ __volatile__ (
+            "mov x9, %[base]\\n\\t"
+            "mov x16, %[end_limit]\\n\\t"
+            "mov x10, %[v]\\n\\t"
+            "mov x11, #123\\n\\t"
+            "mov x12, #456\\n\\t"
+            "mov x13, #789\\n\\t"
+            "mov x14, #999\\n\\t"
+            "mov x15, #111\\n\\t"
+            
+            "dup v0.4s, w10\\n\\t"
+            "dup v1.4s, w11\\n\\t"
+            "dup v2.4s, w12\\n\\t"
+            "dup v3.4s, w13\\n\\t"
+            "dup v4.4s, w14\\n\\t"
+            "dup v5.4s, w15\\n\\t"
+            
+            ".rept 500\\n\\t"
+            "stp q0, q1, [x9], #32\\n\\t"
+            "str q2,     [x9], #16\\n\\t"
+            "stp q3, q4, [x9], #32\\n\\t"
+            "str q5,     [x9], #16\\n\\t"
+            ".endr\\n\\t"
+
+            "cmp x9, x16\\n\\t"
+            "b.lt 1f\\n\\t"
+            "mov x9, %[base]\\n\\t"
+            "1:\\n\\t"
+            :
+            : [base] "r" (current_base), [end_limit] "r" (end_base), [v] "r" (id)
+            : "x9", "x10", "x11", "x12", "x13", "x14", "x15", "x16", "v0", "v1", "v2", "v3", "v4", "v5", "memory"
+        );
+        w->local_ops += 1000;
+    }
+    return NULL;
+}
+
+void target_5ms_init(volatile Node11D *base_ptr) {
+    for (int i = 0; i < NUM_THREADS; i++) {
+        worker_pool[i].target_base = base_ptr + (i * PARTITION_SIZE);
+        worker_pool[i].worker_id = i + 1;
+        worker_pool[i].local_ops = 0;
+        atomic_init(&worker_pool[i].running, 1);
+        atomic_init(&worker_pool[i].paused, 0);
+        pthread_create(&worker_pool[i].thread, NULL, target_5ms_worker_routine, &worker_pool[i]);
+    }
+}
+
+void target_5ms_pause_workers(int pause) {
+    for (int i = 0; i < NUM_THREADS; i++) {
+        atomic_store_explicit(&worker_pool[i].paused, pause, memory_order_release);
+    }
+    usleep(150);
+}
+
+void target_5ms_update_base(volatile Node11D *base_ptr) {
+    target_5ms_pause_workers(1);
+    for (int i = 0; i < NUM_THREADS; i++) {
+        worker_pool[i].target_base = base_ptr + (i * PARTITION_SIZE);
+    }
+    target_5ms_pause_workers(0);
+}
+
+uint64_t target_5ms_get_total_ops(void) {
+    uint64_t total = 0;
+    for (int i = 0; i < NUM_THREADS; i++) {
+        total += worker_pool[i].local_ops;
+    }
+    return total;
+}
+
+void target_5ms_destroy(void) {
+    for (int i = 0; i < NUM_THREADS; i++) {
+        atomic_store_explicit(&worker_pool[i].running, 0, memory_order_release);
+        atomic_store_explicit(&worker_pool[i].paused, 0, memory_order_release);
+        pthread_join(worker_pool[i].thread, NULL);
+    }
+}
+"""
+
+class Node11DStruct(ctypes.Structure):
+    _fields_ = [("d", ctypes.c_uint32 * 12)]
+
+class SRAMSession:
+    def __init__(self, session_name, storage_mb):
+        self.session_name = session_name
+        self.window_size = storage_mb * 1024 * 1024
+        
+        internal_dir = "/data/user/0/ru.iiec.pydroid3"
+        if os.access(internal_dir, os.W_OK):
+            work_dir = os.path.join(internal_dir, "app_sram_" + session_name)
+        else:
+            work_dir = os.path.join(os.getcwd(), "app_sram_" + session_name)
+
+        os.makedirs(work_dir, exist_ok=True)
+        
+        self.kernel_c_path = os.path.join(work_dir, "sram_5ms_kernel.c")
+        self.kernel_so_path = os.path.join(work_dir, "sram_5ms_kernel.so")
+        self.pool_file_path = os.path.join(work_dir, "persistent_sram_pool.bin")
+        
+        with open(self.kernel_c_path, "w") as f:
+            f.write(C_KERNEL_CODE)
+            
+        compile_cmd = f"gcc -O3 -march=native -ffast-math -fomit-frame-pointer -shared -fPIC {self.kernel_c_path} -o {self.kernel_so_path} -lpthread"
+        if os.system(compile_cmd) != 0:
+            os.system(f"gcc -O3 -shared -fPIC {self.kernel_c_path} -o {self.kernel_so_path} -lpthread")
+            
+        self._lib = ctypes.CDLL(self.kernel_so_path)
+        self._lib.target_5ms_init.argtypes = [ctypes.c_void_p]
+        self._lib.target_5ms_get_total_ops.restype = ctypes.c_uint64
+        self._lib.target_5ms_pause_workers.argtypes = [ctypes.c_int]
+
+        with open(self.pool_file_path, "wb") as f:
+            f.write(b"\x00" * self.window_size)
+            
+        self.file_obj = open(self.pool_file_path, "r+b")
+        self.mmap_buf = mmap.mmap(self.file_obj.fileno(), length=self.window_size, access=mmap.ACCESS_WRITE)
+        self.storage_ptr = ctypes.cast(
+            ctypes.addressof(ctypes.c_char.from_buffer(self.mmap_buf)), 
+            ctypes.POINTER(Node11DStruct)
+        )
+        
+        self._lib.target_5ms_init(self.storage_ptr)
+        self.is_paused = False
+        self.process = None
+
+    def run_script(self, python_path, multistring):
+        env = os.environ.copy()
+        env["SRAM_SESSION"] = self.session_name
+        env["SRAM_POOL_PATH"] = self.pool_file_path
+        env["SRAM_MULTISTRING"] = str(multistring)
+        env["SRAM_WINDOW_SIZE"] = str(self.window_size)
+
+        print(f"[SRAM] Spawning target script '{python_path}' on session '{self.session_name}'...")
+        self.process = subprocess.Popen([sys.executable, python_path], env=env)
+
+    def pause(self, pause_state: int):
+        self.is_paused = bool(pause_state)
+        self._lib.target_5ms_pause_workers(int(pause_state))
+
+    def resume(self):
+        self.is_paused = False
+        self._lib.target_5ms_pause_workers(0)
+
+    def get_ops(self):
+        return self._lib.target_5ms_get_total_ops()
+
+    def destroy(self):
+        try:
+            if self.process and self.process.poll() is None:
+                self.process.terminate()
+            self._lib.target_5ms_destroy()
+            if self.mmap_buf:
+                self.mmap_buf.close()
+            if self.file_obj:
+                self.file_obj.close()
+            if os.path.exists(self.pool_file_path):
+                os.remove(self.pool_file_path)
+            print(f"[SRAM] Session '{self.session_name}' successfully destroyed.")
+        except Exception as e:
+            print(f"[ERROR] Cleanup error: {e}")
+
+
+class SRAMCommandDispatcher:
+    def __init__(self):
+        self.sessions = {}
+
+    def execute(self, command_line: str):
+        parts = command_line.strip().split()
+        if not parts:
+            return
+
+        cmd = parts[0]
+
+        if cmd == "SRAM_Run":
+            py_path = parts[1]
+            storage_mb = int(parts[3])
+            multistring = parts[5].lower() == 'true'
+            session_name = parts[7]
+
+            session = SRAMSession(session_name, storage_mb)
+            self.sessions[session_name] = session
+            session.run_script(py_path, multistring)
+
+        elif cmd == "SRAM_monitor":
+            session_name = parts[1]
+            if session_name in self.sessions:
+                s = self.sessions[session_name]
+                ops = s.get_ops()
+                print(f"[MONITOR] Session '{session_name}' | Total Ops: {ops:,d} | Paused: {s.is_paused}")
+            else:
+                print(f"[ERROR] Session '{session_name}' not found.")
+
+        elif cmd == "SRAM_pause":
+            session_name = parts[1]
+            if session_name in self.sessions:
+                s = self.sessions[session_name]
+                s.pause(1)
+                print(f"[PAUSE] Session '{session_name}' paused.")
+            else:
+                print(f"[ERROR] Session '{session_name}' not found.")
+
+        elif cmd == "SRAM_resume":
+            session_name = parts[1]
+            if session_name in self.sessions:
+                s = self.sessions[session_name]
+                s.resume()
+                print(f"[RESUME] Session '{session_name}' resumed.")
+            else:
+                print(f"[ERROR] Session '{session_name}' not found.")
+
+        elif cmd == "SRAM_stop":
+            session_name = parts[1]
+            if session_name in self.sessions:
+                s = self.sessions.pop(session_name)
+                s.destroy()
+            else:
+                print(f"[ERROR] Session '{session_name}' not found.")

sram_engine-1.0.0.dist-info/METADATA

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: sram_engine
+Version: 1.0.0
+Summary: High-speed virtual SRAM engine with C/NEON backend
+Author: Developer
+Requires-Python: >=3.6
+Dynamic: author
+Dynamic: requires-python
+Dynamic: summary

sram_engine-1.0.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+sram_engine/__init__.py,sha256=LMvMn4YRKGauGVodhkwKH2_TFo5wgWLR42aVFoxl5Xs,53
+sram_engine/core.py,sha256=9MzNxCjs72ayUGVSWK5DxW5L-BfxyRcU3WEEtuzdFJk,9185
+sram_engine-1.0.0.dist-info/METADATA,sha256=1iJEdc9YLowv1cco49QsiMAC9fiLiPYsTZDhjpxwkUs,214
+sram_engine-1.0.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+sram_engine-1.0.0.dist-info/top_level.txt,sha256=MhzH5GD1s7jO6dX6YG4YQiJ3SzSD2rNcfuSnLPVM31c,12
+sram_engine-1.0.0.dist-info/RECORD,,

sram_engine-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

sram_engine-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+sram_engine