zexus 1.6.8 → 1.7.2

package/src/zexus/vm/__init__.py

@@ -1,8 +1,118 @@
 """
 Zexus Virtual Machine - Backend Execution Engine
+
+This package provides a comprehensive VM system for Zexus with:
+- Stack-based VM (standard execution)
+- Register-based VM (optimized paths)
+- Parallel VM (multi-core execution)
+- JIT compilation (hot path native code)
+- Peephole optimizer (bytecode optimization)
+- Bytecode caching (persistent across runs)
+- Memory pooling (efficient allocation)
+- Gas metering (resource control)
 """
 
-from .vm import VM as ZexusVM
-from .bytecode import Bytecode
+# Core VM
+from .vm import VM as ZexusVM, VMMode
+from .bytecode import Bytecode, Opcode, BytecodeBuilder
+
+# Caching system (with file-based persistence)
+from .cache import BytecodeCache, CacheStats, FileMetadata
+
+# Compilers
+from .compiler import BytecodeCompiler
+
+# Optimizers
+try:
+    from .optimizer import BytecodeOptimizer
+    OPTIMIZER_AVAILABLE = True
+except ImportError:
+    BytecodeOptimizer = None
+    OPTIMIZER_AVAILABLE = False
+
+try:
+    from .peephole_optimizer import PeepholeOptimizer, OptimizationLevel
+    PEEPHOLE_AVAILABLE = True
+except ImportError:
+    PeepholeOptimizer = None
+    OptimizationLevel = None
+    PEEPHOLE_AVAILABLE = False
+
+# JIT
+try:
+    from .jit import JITCompiler, ExecutionTier
+    JIT_AVAILABLE = True
+except ImportError:
+    JITCompiler = None
+    ExecutionTier = None
+    JIT_AVAILABLE = False
+
+# Register VM
+try:
+    from .register_vm import RegisterVM
+    REGISTER_VM_AVAILABLE = True
+except ImportError:
+    RegisterVM = None
+    REGISTER_VM_AVAILABLE = False
+
+# Parallel VM
+try:
+    from .parallel_vm import ParallelVM, ExecutionMode
+    PARALLEL_VM_AVAILABLE = True
+except ImportError:
+    ParallelVM = None
+    ExecutionMode = None
+    PARALLEL_VM_AVAILABLE = False
+
+# Memory management
+try:
+    from .memory_pool import IntegerPool, StringPool, ListPool
+    MEMORY_POOL_AVAILABLE = True
+except ImportError:
+    IntegerPool = None
+    StringPool = None
+    ListPool = None
+    MEMORY_POOL_AVAILABLE = False
+
+# Gas metering
+try:
+    from .gas_metering import GasMetering, OutOfGasError
+    GAS_METERING_AVAILABLE = True
+except ImportError:
+    GasMetering = None
+    OutOfGasError = None
+    GAS_METERING_AVAILABLE = False
+
+# Profiler
+try:
+    from .profiler import InstructionProfiler, ProfilingLevel
+    PROFILER_AVAILABLE = True
+except ImportError:
+    InstructionProfiler = None
+    ProfilingLevel = None
+    PROFILER_AVAILABLE = False
 
-__all__ = ['ZexusVM', 'Bytecode']
+__all__ = [
+    # Core
+    'ZexusVM', 'VMMode', 'Bytecode', 'Opcode', 'BytecodeBuilder',
+    # Cache
+    'BytecodeCache', 'CacheStats', 'FileMetadata',
+    # Compiler
+    'BytecodeCompiler',
+    # Optimizers
+    'BytecodeOptimizer', 'PeepholeOptimizer', 'OptimizationLevel',
+    # JIT
+    'JITCompiler', 'ExecutionTier',
+    # Advanced VMs
+    'RegisterVM', 'ParallelVM', 'ExecutionMode',
+    # Memory
+    'IntegerPool', 'StringPool', 'ListPool',
+    # Gas
+    'GasMetering', 'OutOfGasError',
+    # Profiler
+    'InstructionProfiler', 'ProfilingLevel',
+    # Availability flags
+    'OPTIMIZER_AVAILABLE', 'PEEPHOLE_AVAILABLE', 'JIT_AVAILABLE',
+    'REGISTER_VM_AVAILABLE', 'PARALLEL_VM_AVAILABLE', 
+    'MEMORY_POOL_AVAILABLE', 'GAS_METERING_AVAILABLE', 'PROFILER_AVAILABLE',
+]

package/src/zexus/vm/async_optimizer.py

@@ -97,7 +97,7 @@ class FastFuture:
         """Make it awaitable - fast path, no event loop"""
         if self._exception:
             raise self._exception
-        yield from [].__iter__()  # Make it a generator
+        yield from ()
         return self._value
 
 
@@ -143,6 +143,10 @@ class CoroutinePool:
         Args:
             wrapper: Wrapper to release
         """
+        # Make sure underlying coroutine isn't left pending
+        if hasattr(wrapper, "_dispose_coroutine"):
+            wrapper._dispose_coroutine()
+
         if len(self.pool) < self.max_size:
             self.pool.append(wrapper)
     
@@ -169,15 +173,72 @@ class PooledCoroutineWrapper:
         return self._coro.send(value)
     
     def throw(self, typ, val=None, tb=None):
-        """Forward throw"""
-        return self._coro.throw(typ, val, tb)
+        """Forward throw while supporting modern coroutine semantics."""
+        coro_throw = getattr(self._coro, "throw", None)
+        if coro_throw is None:
+            raise AttributeError("Wrapped coroutine does not support throw()")
+
+        # Normalize exception according to modern coroutine API expectations
+        if tb is None and val is None:
+            return coro_throw(typ)
+
+        if tb is None and isinstance(typ, BaseException) and val is None:
+            return coro_throw(typ)
+
+        if isinstance(typ, BaseException):
+            exc = typ
+            if val is not None and val is not exc:
+                exc.args = exc.args or ()
+                exc.args += (val,)
+        elif isinstance(typ, type) and issubclass(typ, BaseException):
+            if isinstance(val, typ):
+                exc = val
+            elif val is None:
+                exc = typ()
+            else:
+                exc = typ(val)
+        else:
+            # Fall back to legacy behaviour for non-exception inputs
+            if tb is not None:
+                return coro_throw(typ, val, tb)
+            if val is not None:
+                return coro_throw(typ, val)
+            return coro_throw(typ)
+
+        if tb is not None and hasattr(exc, "with_traceback"):
+            exc = exc.with_traceback(tb)
+
+        return coro_throw(exc)
     
     def close(self):
         """Close and return to pool"""
+        self._dispose_coroutine()
+        self._pool.release_wrapper(self)
+
+    # Internal helpers -------------------------------------------------
+
+    def _dispose_coroutine(self):
+        coro = getattr(self, "_coro", None)
+        if coro is None:
+            return
+
         try:
-            self._coro.close()
+            close = getattr(coro, "close", None)
+            if callable(close):
+                try:
+                    close()
+                except RuntimeError:
+                    # Coroutine already completed or running elsewhere
+                    pass
         finally:
-            self._pool.release_wrapper(self)
+            self._coro = None
+
+    def __del__(self):
+        try:
+            self._dispose_coroutine()
+        except Exception:
+            # Destructors must never raise
+            pass
 
 
 class BatchAwaitDetector:
@@ -267,9 +328,18 @@ class AsyncOptimizer:
         
         # Use pooling if enabled
         if self.coroutine_pool and self.level.value >= AsyncOptimizationLevel.BASIC.value:
-            return self.coroutine_pool.get_wrapper(coro)
+            wrapper = self.coroutine_pool.get_wrapper(coro)
+            return self._wrap_pooled(wrapper)
         
         return coro
+
+    async def _wrap_pooled(self, wrapper: PooledCoroutineWrapper) -> Any:
+        """Ensure pooled wrappers are released after completion."""
+        try:
+            return await wrapper
+        finally:
+            if self.coroutine_pool:
+                self.coroutine_pool.release_wrapper(wrapper)
     
     async def await_optimized(self, awaitable: Any) -> Any:
         """
@@ -285,6 +355,10 @@ class AsyncOptimizer:
         
         # Fast path for already-resolved futures (MODERATE+)
         if self.level.value >= AsyncOptimizationLevel.MODERATE.value:
+            if not asyncio.isfuture(awaitable) and not asyncio.iscoroutine(awaitable) and not hasattr(awaitable, "__await__"):
+                self.stats.fast_path_hits += 1
+                self.stats.event_loop_skips += 1
+                return awaitable
             if isinstance(awaitable, FastFuture):
                 self.stats.fast_path_hits += 1
                 self.stats.event_loop_skips += 1