zexus 1.7.1 → 1.7.2

package/src/zexus/vm/fastops.pyx

@@ -0,0 +1,288 @@
+# cython: language_level=3
+# cython: boundscheck=False
+# cython: wraparound=False
+# cython: cdivision=True
+
+"""
+Cython-accelerated hot-path VM execution.
+
+Implements a fast dispatch loop for common bytecode ops used in benchmarks.
+Falls back to Python execution for unsupported ops by raising NotImplementedError.
+"""
+
+from zexus.object import List as ZList
+from zexus.object import Map as ZMap
+from zexus.object import String as ZString
+
+
+def _resolve(name, dict env, dict closure_cells):
+    if name in env:
+        val = env[name]
+        if hasattr(val, "value"):
+            return val.value
+        return val
+    if closure_cells is not None and name in closure_cells:
+        cell = closure_cells[name]
+        if hasattr(cell, "value"):
+            return cell.value
+        return cell
+    return None
+
+
+def _store(name, value, dict env, dict closure_cells):
+    if name in env:
+        current = env[name]
+        if hasattr(current, "value"):
+            current.value = value
+            return
+        env[name] = value
+        return
+    if closure_cells is not None and name in closure_cells:
+        cell = closure_cells[name]
+        if hasattr(cell, "value"):
+            cell.value = value
+            return
+        closure_cells[name] = value
+        return
+    env[name] = value
+
+
+def _call_method(target, method_name, args):
+    if target is None:
+        return None
+    try:
+        if method_name == "set":
+            if isinstance(target, ZMap) and len(args) >= 2:
+                key = args[0]
+                if isinstance(key, str):
+                    key = ZString(key)
+                return target.set(key, args[1])
+            if isinstance(target, ZList) and len(args) >= 2:
+                return target.set(args[0], args[1])
+            if isinstance(target, (dict, list)) and len(args) >= 2:
+                target[args[0]] = args[1]
+                return args[1]
+        if hasattr(target, "call_method"):
+            return target.call_method(method_name, args)
+        attr = getattr(target, method_name, None)
+        if callable(attr):
+            return attr(*args)
+        if isinstance(target, dict) and method_name in target:
+            candidate = target[method_name]
+            return candidate(*args) if callable(candidate) else candidate
+        return attr
+    except Exception:
+        return None
+
+
+def _call_top(fn_obj, args):
+    if fn_obj is None:
+        return None
+    if isinstance(fn_obj, dict) and "bytecode" in fn_obj:
+        raise NotImplementedError("CALL_TOP requires VM execution")
+    try:
+        if callable(fn_obj):
+            return fn_obj(*args)
+        return None
+    except Exception:
+        return None
+
+
+def execute(list instrs, list consts, dict env, dict builtins, dict closure_cells=None):
+    cdef Py_ssize_t ip = 0
+    cdef Py_ssize_t instr_count = len(instrs)
+    cdef list stack = []
+    cdef object op_name
+    cdef object operand
+
+    while ip < instr_count:
+        op_name, operand = instrs[ip]
+        ip += 1
+
+        if op_name == "LOAD_CONST":
+            if isinstance(operand, int) and 0 <= operand < len(consts):
+                stack.append(consts[operand])
+            else:
+                stack.append(operand)
+        elif op_name == "LOAD_NAME":
+            name = consts[operand] if isinstance(operand, int) and 0 <= operand < len(consts) else operand
+            stack.append(_resolve(name, env, closure_cells))
+        elif op_name == "STORE_NAME":
+            name = consts[operand] if isinstance(operand, int) and 0 <= operand < len(consts) else operand
+            val = stack.pop() if stack else None
+            _store(name, val, env, closure_cells)
+        elif op_name == "POP":
+            if stack:
+                stack.pop()
+        elif op_name == "DUP":
+            if stack:
+                stack.append(stack[-1])
+        elif op_name == "ADD":
+            b = stack.pop() if stack else 0
+            a = stack.pop() if stack else 0
+            if hasattr(a, "value"):
+                a = a.value
+            if hasattr(b, "value"):
+                b = b.value
+            stack.append(a + b)
+        elif op_name == "SUB":
+            b = stack.pop() if stack else 0
+            a = stack.pop() if stack else 0
+            if hasattr(a, "value"):
+                a = a.value
+            if hasattr(b, "value"):
+                b = b.value
+            stack.append(a - b)
+        elif op_name == "MUL":
+            b = stack.pop() if stack else 0
+            a = stack.pop() if stack else 0
+            if hasattr(a, "value"):
+                a = a.value
+            if hasattr(b, "value"):
+                b = b.value
+            stack.append(a * b)
+        elif op_name == "DIV":
+            b = stack.pop() if stack else 1
+            a = stack.pop() if stack else 0
+            if hasattr(a, "value"):
+                a = a.value
+            if hasattr(b, "value"):
+                b = b.value
+            stack.append(a / b if b != 0 else 0)
+        elif op_name == "MOD":
+            b = stack.pop() if stack else 1
+            a = stack.pop() if stack else 0
+            stack.append(a % b if b != 0 else 0)
+        elif op_name == "EQ":
+            b = stack.pop() if stack else None
+            a = stack.pop() if stack else None
+            stack.append(a == b)
+        elif op_name == "NEQ":
+            b = stack.pop() if stack else None
+            a = stack.pop() if stack else None
+            stack.append(a != b)
+        elif op_name == "LT":
+            b = stack.pop() if stack else 0
+            a = stack.pop() if stack else 0
+            stack.append(a < b)
+        elif op_name == "GT":
+            b = stack.pop() if stack else 0
+            a = stack.pop() if stack else 0
+            stack.append(a > b)
+        elif op_name == "LTE":
+            b = stack.pop() if stack else 0
+            a = stack.pop() if stack else 0
+            stack.append(a <= b)
+        elif op_name == "GTE":
+            b = stack.pop() if stack else 0
+            a = stack.pop() if stack else 0
+            stack.append(a >= b)
+        elif op_name == "NOT":
+            a = stack.pop() if stack else False
+            stack.append(not a)
+        elif op_name == "NEG":
+            a = stack.pop() if stack else 0
+            stack.append(-a)
+        elif op_name == "JUMP":
+            ip = operand
+        elif op_name == "JUMP_IF_FALSE":
+            cond = stack.pop() if stack else None
+            if not cond:
+                ip = operand
+        elif op_name == "RETURN":
+            return stack.pop() if stack else None
+        elif op_name == "BUILD_LIST":
+            count = operand if operand is not None else 0
+            elements = [stack.pop() for _ in range(count)][::-1]
+            stack.append(elements)
+        elif op_name == "BUILD_MAP":
+            count = operand if operand is not None else 0
+            result = {}
+            for _ in range(count):
+                val = stack.pop(); key = stack.pop()
+                result[key] = val
+            stack.append(result)
+        elif op_name == "BUILD_SET":
+            count = operand if operand is not None else 0
+            elements = [stack.pop() for _ in range(count)][::-1]
+            stack.append(set(elements))
+        elif op_name == "INDEX":
+            idx = stack.pop()
+            obj = stack.pop()
+            try:
+                if isinstance(obj, ZList):
+                    stack.append(obj.get(idx))
+                elif isinstance(obj, ZMap):
+                    stack.append(obj.get(idx))
+                else:
+                    stack.append(obj[idx] if obj is not None else None)
+            except Exception:
+                stack.append(None)
+        elif op_name == "SLICE":
+            end = stack.pop() if stack else None
+            start = stack.pop() if stack else None
+            obj = stack.pop() if stack else None
+            if hasattr(start, "value"):
+                start = start.value
+            if hasattr(end, "value"):
+                end = end.value
+            try:
+                if isinstance(obj, ZList):
+                    stack.append(ZList(obj.elements[start:end]))
+                elif isinstance(obj, ZString):
+                    stack.append(ZString(obj.value[start:end]))
+                else:
+                    stack.append(obj[start:end] if obj is not None else None)
+            except Exception:
+                stack.append(None)
+        elif op_name == "GET_LENGTH":
+            obj = stack.pop() if stack else None
+            try:
+                if obj is None:
+                    stack.append(0)
+                elif isinstance(obj, ZList):
+                    stack.append(len(obj.elements))
+                elif isinstance(obj, ZMap):
+                    stack.append(len(obj.pairs))
+                elif isinstance(obj, ZString):
+                    stack.append(len(obj.value))
+                else:
+                    stack.append(len(obj))
+            except Exception:
+                stack.append(0)
+        elif op_name == "CALL_NAME":
+            name_idx, arg_count = operand
+            func_name = consts[name_idx] if isinstance(name_idx, int) and 0 <= name_idx < len(consts) else name_idx
+            args = [stack.pop() for _ in range(arg_count)][::-1] if arg_count else []
+            fn = _resolve(func_name, env, closure_cells) or builtins.get(func_name)
+            if fn is None:
+                stack.append(None)
+            else:
+                stack.append(fn(*args))
+        elif op_name == "CALL_BUILTIN":
+            name_idx, arg_count = operand
+            func_name = consts[name_idx] if isinstance(name_idx, int) and 0 <= name_idx < len(consts) else name_idx
+            args = [stack.pop() for _ in range(arg_count)][::-1] if arg_count else []
+            fn = builtins.get(func_name)
+            if fn is None:
+                stack.append(None)
+            else:
+                try:
+                    stack.append(fn(*args))
+                except Exception:
+                    stack.append(None)
+        elif op_name == "CALL_METHOD":
+            method_idx, arg_count = operand
+            args = [stack.pop() for _ in range(arg_count)][::-1] if arg_count else []
+            target = stack.pop() if stack else None
+            method_name = consts[method_idx] if isinstance(method_idx, int) and 0 <= method_idx < len(consts) else method_idx
+            stack.append(_call_method(target, method_name, args))
+        elif op_name == "CALL_TOP":
+            arg_count = operand
+            args = [stack.pop() for _ in range(arg_count)][::-1] if arg_count else []
+            fn_obj = stack.pop() if stack else None
+            stack.append(_call_top(fn_obj, args))
+        else:
+            raise NotImplementedError(f"opcode not supported: {op_name}")
+
+    return stack.pop() if stack else None

package/src/zexus/vm/gas_metering.py

@@ -57,6 +57,8 @@ class GasCost(IntEnum):
     # Function operations
     CALL_NAME = 10  # Base cost for function call
     CALL_TOP = 10
+    CALL_METHOD = 10
+    CALL_BUILTIN = 8
     STORE_FUNC = 5
     BUILD_LAMBDA = 5
     
@@ -74,6 +76,22 @@ class GasCost(IntEnum):
     TX_COMMIT = 30
     TX_REVERT = 20
     LEDGER_APPEND = 40
+    GAS_CHARGE = 2        # Overhead of the charge itself
+    REQUIRE = 5
+    AUDIT_LOG = 15
+    RESTRICT_ACCESS = 5
+    DEFINE_CONTRACT = 50
+    EMIT_EVENT = 10
+    
+    # Error handling
+    SETUP_TRY = 3
+    POP_TRY = 2
+    THROW = 5
+    ENABLE_ERROR_MODE = 2
+    
+    # Parallel operations
+    PARALLEL_START = 15
+    PARALLEL_END = 10
     
     # I/O operations
     PRINT = 10
@@ -90,16 +108,19 @@ class GasMetering:
             gas_limit: Maximum gas allowed (None = unlimited)
             enable_timeout: Enable execution timeout mechanism
         """
-        self.gas_limit = gas_limit if gas_limit is not None else 1_000_000
+        self.gas_limit = gas_limit if gas_limit is not None else 100_000_000
         self.gas_used = 0
         self.enable_timeout = enable_timeout
         self.operation_count = 0
-        self.max_operations = 1_000_000  # Safety limit for operations with generous default
+        self.max_operations = 100_000_000  # Safety limit for operations with generous default
         
         # Track gas usage by operation type for profiling
         self.gas_by_operation: Dict[str, int] = {}
         self.operation_counts: Dict[str, int] = {}
         
+        # OPTIMIZATION: Cache for operation costs to avoid repeated enum lookups
+        self._cost_cache: Dict[str, int] = {}
+        
     def consume(self, operation: str, amount: Optional[int] = None, **kwargs) -> bool:
         """
         Consume gas for an operation
@@ -112,6 +133,11 @@ class GasMetering:
         Returns:
             True if enough gas available, False if out of gas
         """
+        # OPTIMIZATION: Fast path for operation count check (most common failure)
+        self.operation_count += 1
+        if self.operation_count > self.max_operations:
+            return False
+        
         # Calculate gas cost
         if amount is not None:
             cost = amount
@@ -124,16 +150,23 @@ class GasMetering:
         
         # Consume gas
         self.gas_used += cost
-        self.operation_count += 1
         
-        # Track for profiling
-        self.gas_by_operation[operation] = self.gas_by_operation.get(operation, 0) + cost
-        self.operation_counts[operation] = self.operation_counts.get(operation, 0) + 1
+        # Track for profiling (only if needed)
+        if self.gas_by_operation is not None:  # Allow disabling profiling
+            self.gas_by_operation[operation] = self.gas_by_operation.get(operation, 0) + cost
+            self.operation_counts[operation] = self.operation_counts.get(operation, 0) + 1
         
-        # Check operation count limit (prevents infinite loops even with high gas)
+        return True
+
+    def consume_light(self, amount: int = 1) -> bool:
+        """Lightweight gas accounting: only counts operations with a fixed cost."""
+        self.operation_count += 1
         if self.operation_count > self.max_operations:
             return False
-        
+        if self.gas_limit is not None:
+            self.gas_used += amount
+            if self.gas_used > self.gas_limit:
+                return False
         return True
     
     def _get_operation_cost(self, operation: str, **kwargs) -> int:
@@ -147,6 +180,10 @@ class GasMetering:
         Returns:
             Gas cost for the operation
         """
+        # OPTIMIZATION: Check cache first for static costs (no kwargs)
+        if not kwargs and operation in self._cost_cache:
+            return self._cost_cache[operation]
+        
         # Try to get cost from GasCost enum
         try:
             base_cost = GasCost[operation].value
@@ -170,11 +207,15 @@ class GasMetering:
             leaf_count = kwargs.get('leaf_count', 0)
             return base_cost + (leaf_count * 5)
         
-        elif operation in ("CALL_NAME", "CALL_TOP"):
+        elif operation in ("CALL_NAME", "CALL_TOP", "CALL_METHOD", "CALL_BUILTIN"):
             # Cost scales with number of arguments
             arg_count = kwargs.get('arg_count', 0)
             return base_cost + (arg_count * 2)
         
+        # Cache static costs
+        if not kwargs:
+            self._cost_cache[operation] = base_cost
+        
         return base_cost
     
     def check_limit(self) -> bool:

package/src/zexus/vm/jit.py

@@ -18,6 +18,7 @@ Features:
 import hashlib
 import time
 import dis
+import os
 from typing import Dict, Any, Optional, Tuple, Callable, List, Set
 from dataclasses import dataclass, field
 from enum import Enum
@@ -29,6 +30,19 @@ try:
 except ImportError:
     OPTIMIZER_AVAILABLE = False
 
+try:
+    from .gas_metering import OutOfGasError, OperationLimitExceededError
+except Exception:
+    OutOfGasError = None
+    OperationLimitExceededError = None
+
+try:
+    from .native_jit_backend import NativeJITBackend
+    _NATIVE_JIT_AVAILABLE = True
+except Exception:
+    _NATIVE_JIT_AVAILABLE = False
+    NativeJITBackend = None
+
 
 class ExecutionTier(Enum):
     """Execution tiers for tiered compilation"""
@@ -128,6 +142,28 @@ class JITCompiler:
             'RETURN', 'JUMP', 'JUMP_IF_FALSE',
         }
 
+        # Native JIT backend (optional)
+        self.native_backend = None
+        native_flag = os.environ.get("ZEXUS_NATIVE_JIT", "0")
+        if native_flag.lower() in ("1", "true", "yes"):
+            self.enable_native_backend()
+        if os.environ.get("ZEXUS_JIT_TRACE", "0") in ("1", "true", "yes"):
+            print(f"[JIT TRACE] native_backend={'on' if self.native_backend else 'off'}")
+
+    def enable_native_backend(self) -> bool:
+        if self.native_backend is not None:
+            return True
+        if not _NATIVE_JIT_AVAILABLE:
+            return False
+        try:
+            self.native_backend = NativeJITBackend(debug=self.debug)
+            if self.debug:
+                print("🔧 JIT: Native backend enabled")
+            return True
+        except Exception:
+            self.native_backend = None
+            return False
+
     def should_compile(self, bytecode_hash: str) -> bool:
         """
         Determine if bytecode should be JIT compiled
@@ -217,6 +253,33 @@ class JITCompiler:
 
         start_time = time.time()
 
+        # Native JIT path
+        if self.native_backend is not None:
+            try:
+                native_fn = self.native_backend.compile(bytecode)
+                if native_fn is not None:
+                    self.compilation_cache[bytecode_hash] = native_fn
+                    compilation_time = time.time() - start_time
+                    self.stats.compilations += 1
+                    self.stats.compilation_time += compilation_time
+                    self.stats.average_compilation_time = (
+                        self.stats.compilation_time / self.stats.compilations
+                    )
+                    self.stats.tier_promotions += 1
+
+                    if bytecode_hash in self.hot_paths:
+                        info = self.hot_paths[bytecode_hash]
+                        info.compiled_version = native_fn
+                        info.compilation_time = compilation_time
+                        info.tier = ExecutionTier.JIT_NATIVE
+
+                    if self.debug:
+                        print(f"✅ JIT: Native compiled {bytecode_hash[:8]} in {compilation_time*1000:.2f}ms")
+                    return native_fn
+            except Exception:
+                if self.debug:
+                    print(f"⚠️  JIT: Native backend failed for {bytecode_hash[:8]}, falling back")
+
         try:
             # Step 1: Analyze stack behavior
             stack_frames = self._analyze_stack_behavior(bytecode)
@@ -242,7 +305,11 @@ class JITCompiler:
             compiled = compile(python_code, f'<jit:{bytecode_hash[:8]}>', 'exec')
 
             # Step 5: Create executable function
-            namespace = {'__builtins__': {}}
+            namespace = {
+                '__builtins__': {},
+                'OutOfGasError': OutOfGasError,
+                'OperationLimitExceededError': OperationLimitExceededError,
+            }
             exec(compiled, namespace)
             jit_function = namespace.get('jit_execute')
 
@@ -518,7 +585,7 @@ class JITCompiler:
                     stats = self.optimizer.get_stats()
                     if stats['total_optimizations'] > 0:
                         print(f"🔧 JIT Optimizer: {stats['original_size']} → {stats['optimized_size']} instructions "
-                              f"({stats['size_reduction_pct']:.1f}% reduction)")
+                              f"({stats['size_reduction']:.1f}% reduction)")
                 return optimized, constants
             except Exception as e:
                 if self.debug:
@@ -787,6 +854,14 @@ class JITCompiler:
         lines = [
             "def jit_execute(vm, stack, env):",
             "    # JIT-compiled native code",
+            "    gas = getattr(vm, 'gas_metering', None)",
+            "    def _gas(op, **kwargs):",
+            "        if gas is None:",
+            "            return",
+            "        if not gas.consume(op, **kwargs):",
+            "            if gas.operation_count > gas.max_operations:",
+            "                raise OperationLimitExceededError(gas.operation_count, gas.max_operations)",
+            "            raise OutOfGasError(gas.gas_used, gas.gas_limit, op)",
         ]
         
         # Track variable assignments for efficient code generation
@@ -800,6 +875,7 @@ class JITCompiler:
             frame = stack_frames[i]
             
             if opcode == 'LOAD_CONST':
+                lines.append("    _gas('LOAD_CONST')")
                 if operand < len(constants):
                     const_val = constants[operand]
                     var_name = f"const_{operand}_{i}"
@@ -813,6 +889,7 @@ class JITCompiler:
                 stack_height += 1
                 
             elif opcode == 'LOAD_NAME':
+                lines.append("    _gas('LOAD_NAME')")
                 if operand < len(constants):
                     name = constants[operand]
                     var_name = f"var_{operand}_{i}"
@@ -826,6 +903,7 @@ class JITCompiler:
                 stack_height += 1
                 
             elif opcode == 'STORE_NAME':
+                lines.append("    _gas('STORE_NAME')")
                 if operand < len(constants):
                     name = constants[operand]
                     if stack_height > 0:
@@ -833,6 +911,7 @@ class JITCompiler:
                         stack_height -= 1
                         
             elif opcode == 'STORE_CONST':
+                lines.append("    _gas('STORE_NAME')")
                 if isinstance(operand, tuple) and len(operand) == 2:
                     name_idx, const_idx = operand
                     if name_idx < len(constants) and const_idx < len(constants):
@@ -841,6 +920,7 @@ class JITCompiler:
                         lines.append(f"    env[{repr(name)}] = {repr(const_val)}")
                         
             elif opcode in ['ADD', 'SUB', 'MUL', 'DIV', 'MOD', 'POW']:
+                lines.append(f"    _gas('{opcode}')")
                 if stack_height >= 2:
                     # Generate efficient arithmetic
                     operator = self._opcode_to_operator(opcode)
@@ -883,6 +963,7 @@ class JITCompiler:
                     stack_height -= 1  # 2 popped, 1 pushed = net -1
                     
             elif opcode == 'RETURN':
+                lines.append("    _gas('RETURN')")
                 if stack_height > 0:
                     lines.append("    return stack[-1]")
                 else: