zexus 1.6.8 → 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 = 100_000  # Safety limit for operations
+        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: