zexus 1.7.1 → 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

@@ -328,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:
         """
@@ -346,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