cinderx 2026.1.16.2__cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl

cinderx/jit.py

@@ -0,0 +1,230 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# pyre-strict
+
+from contextlib import contextmanager
+from typing import Any, AsyncGenerator, Callable, Coroutine, Generator, TypeVar
+from warnings import catch_warnings, simplefilter, warn
+
+
+# The JIT compiles arbitrary Python functions.  Ideally this type would exclude native
+# functions, but that doesn't seem possible yet.
+#
+# pyre-ignore[33]: Not going to add a new type variable for every use of FuncAny.
+FuncAny = Callable[..., Any]
+
+
+try:
+    from cinderjit import (
+        _deopt_gen,
+        append_jit_list,
+        auto,
+        clear_runtime_stats,
+        compile_after_n_calls,
+        count_interpreted_calls,
+        disable,
+        disable_emit_type_annotation_guards,
+        disable_hir_inliner,
+        disable_specialized_opcodes,
+        enable,
+        enable_emit_type_annotation_guards,
+        enable_hir_inliner,
+        enable_specialized_opcodes,
+        force_compile,
+        force_uncompile,
+        get_allocator_stats,
+        get_and_clear_inline_cache_stats,
+        get_and_clear_runtime_stats,
+        get_compilation_time,
+        get_compile_after_n_calls,
+        get_compiled_functions,
+        get_compiled_size,
+        get_compiled_spill_stack_size,
+        get_compiled_stack_size,
+        get_function_compilation_time,
+        get_function_hir_opcode_counts,
+        get_inlined_functions_stats,
+        get_jit_list,
+        get_num_inlined_functions,
+        is_enabled,
+        is_hir_inliner_enabled,
+        is_inline_cache_stats_collection_enabled,
+        is_jit_compiled,
+        jit_suppress,
+        jit_unsuppress,
+        lazy_compile,
+        mlock_profiler_dependencies,
+        multithreaded_compile_test,
+        page_in_profiler_dependencies,
+        precompile_all,
+        read_jit_list,
+        set_max_code_size,
+    )
+
+except ImportError:
+    TDeoptGenYield = TypeVar("TDeoptGenYield")
+    TDeoptGenSend = TypeVar("TDeoptGenSend")
+    TDeoptGenReturn = TypeVar("TDeoptGenReturn")
+
+    def _deopt_gen(
+        gen: Generator[TDeoptGenYield, TDeoptGenSend, TDeoptGenReturn]
+        | AsyncGenerator[TDeoptGenYield, TDeoptGenSend]
+        | Coroutine[TDeoptGenYield, TDeoptGenSend, TDeoptGenReturn],
+    ) -> bool:
+        return False
+
+    def append_jit_list(entry: str) -> None:
+        return None
+
+    def auto() -> None:
+        return None
+
+    def clear_runtime_stats() -> None:
+        return None
+
+    def compile_after_n_calls(calls: int) -> None:
+        return None
+
+    def count_interpreted_calls(func: FuncAny) -> int:
+        return 0
+
+    def disable(deopt_all: bool = False) -> None:
+        return None
+
+    def disable_emit_type_annotation_guards() -> None:
+        return None
+
+    def disable_hir_inliner() -> None:
+        return None
+
+    def disable_specialized_opcodes() -> None:
+        return None
+
+    def enable() -> None:
+        # Warn here because users might think this is function is how to enable the JIT
+        # when it is not installed.
+        warn(
+            "Cinder JIT is not installed, calling cinderx.jit.enable() is doing nothing"
+        )
+
+    def enable_emit_type_annotation_guards() -> None:
+        return None
+
+    def enable_hir_inliner() -> None:
+        return None
+
+    def enable_specialized_opcodes() -> None:
+        return None
+
+    def force_compile(func: FuncAny) -> bool:
+        return False
+
+    def force_uncompile(func: FuncAny) -> bool:
+        return False
+
+    def get_allocator_stats() -> dict[str, int]:
+        return {}
+
+    def get_and_clear_inline_cache_stats() -> dict[str, object]:
+        return {}
+
+    def get_and_clear_runtime_stats() -> dict[str, object]:
+        return {}
+
+    def get_compilation_time() -> int:
+        return 0
+
+    def get_compile_after_n_calls() -> int | None:
+        return None
+
+    def get_compiled_functions() -> list[FuncAny]:
+        return []
+
+    def get_compiled_size(func: FuncAny) -> int:
+        return 0
+
+    def get_compiled_spill_stack_size(func: FuncAny) -> int:
+        return 0
+
+    def get_compiled_stack_size(func: FuncAny) -> int:
+        return 0
+
+    def get_function_compilation_time(func: FuncAny) -> int:
+        return 0
+
+    def get_function_hir_opcode_counts(func: FuncAny) -> dict[str, int] | None:
+        return {}
+
+    def get_inlined_functions_stats(func: FuncAny) -> dict[str, object]:
+        return {}
+
+    def get_jit_list() -> tuple[dict[str, set[str]], dict[str, dict[str, set[int]]]]:
+        return ({}, {})
+
+    def get_num_inlined_functions(func: FuncAny) -> int:
+        return 0
+
+    def is_enabled() -> bool:
+        return False
+
+    def is_hir_inliner_enabled() -> bool:
+        return False
+
+    def is_inline_cache_stats_collection_enabled() -> bool:
+        return False
+
+    def is_jit_compiled(func: FuncAny) -> bool:
+        return False
+
+    def jit_suppress(func: FuncAny) -> FuncAny:
+        return func
+
+    def jit_unsuppress(func: FuncAny) -> FuncAny:
+        return func
+
+    def lazy_compile(func: FuncAny) -> bool:
+        return False
+
+    def mlock_profiler_dependencies() -> None:
+        return None
+
+    def multithreaded_compile_test() -> None:
+        return None
+
+    def page_in_profiler_dependencies() -> list[str]:
+        return []
+
+    def precompile_all(workers: int = 0) -> bool:
+        return False
+
+    def read_jit_list(path: str) -> None:
+        return None
+
+    def set_max_code_size(max_code_size: int) -> None:
+        return None
+
+
+@contextmanager
+def pause(deopt_all: bool = False) -> Generator[None, None, None]:
+    """
+    Context manager for temporarily pausing the JIT.
+
+    This will disable the JIT from running on new functions, and if you set
+    `deopt_all`, will also de-optimize all currently compiled functions to the
+    interpreter.  When the JIT is unpaused, the compiled functions will be put
+    back.
+    """
+
+    prev_enabled = is_enabled()
+    if prev_enabled:
+        disable(deopt_all=deopt_all)
+
+    try:
+        yield
+    finally:
+        if prev_enabled:
+            # Disable the warning from enable() when the JIT is not
+            # installed/initialized.
+            with catch_warnings():
+                simplefilter("ignore")
+                enable()

cinderx/opcode.py

@@ -0,0 +1,202 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+
+# Generated via assign_opcode_numbers.py, do not edit.
+
+# This is an addition to python/3.12/Lib/opcode.py, and is intended to be run
+# via `exec` in generate_opcode_h.py with the globals dict obtained from
+# running Lib/opcode.py.
+
+# flake8: noqa
+
+
+# Lib/opcode.py deletes these functions so we need to define them again here.
+# We also need to update opname when we call def_op().
+def init(
+    opname,
+    opmap,
+    hasname,
+    hasjrel,
+    hasjabs,
+    hasconst,
+    hasarg,
+    cache_format,
+    specializations,
+    inline_cache_entries,
+    interp_only=False,
+):
+    def def_op(name, op):
+        opmap[name] = op
+        opname[op] = name
+
+    def name_op(name, op):
+        def_op(name, op)
+        hasname.append(op)
+
+    def jrel_op(name, op):
+        def_op(name, op)
+        hasjrel.append(op)
+
+    def jabs_op(name, op):
+        def_op(name, op)
+        hasjabs.append(op)
+
+    def_op("INVOKE_METHOD", 1)
+    hasconst.append(1)
+    hasarg.append(1)
+    def_op("LOAD_FIELD", 2)
+    hasconst.append(2)
+    hasarg.append(2)
+    cache_format["LOAD_FIELD"] = "{'cache': 2}"
+    def_op("LOAD_OBJ_FIELD", 4)
+    hasconst.append(4)
+    hasarg.append(4)
+    if "LOAD_FIELD" not in specializations:
+        specializations["LOAD_FIELD"] = []
+    specializations["LOAD_FIELD"].append("LOAD_OBJ_FIELD")
+    def_op("LOAD_PRIMITIVE_FIELD", 5)
+    hasconst.append(5)
+    hasarg.append(5)
+    if "LOAD_FIELD" not in specializations:
+        specializations["LOAD_FIELD"] = []
+    specializations["LOAD_FIELD"].append("LOAD_PRIMITIVE_FIELD")
+    def_op("STORE_FIELD", 6)
+    hasconst.append(6)
+    hasarg.append(6)
+    cache_format["STORE_FIELD"] = "{'cache': 2}"
+    def_op("STORE_OBJ_FIELD", 7)
+    hasconst.append(7)
+    hasarg.append(7)
+    if "STORE_FIELD" not in specializations:
+        specializations["STORE_FIELD"] = []
+    specializations["STORE_FIELD"].append("STORE_OBJ_FIELD")
+    def_op("STORE_PRIMITIVE_FIELD", 8)
+    hasconst.append(8)
+    hasarg.append(8)
+    if "STORE_FIELD" not in specializations:
+        specializations["STORE_FIELD"] = []
+    specializations["STORE_FIELD"].append("STORE_PRIMITIVE_FIELD")
+    def_op("BUILD_CHECKED_LIST", 9)
+    hasconst.append(9)
+    hasarg.append(9)
+    cache_format["BUILD_CHECKED_LIST"] = "{'cache': 2}"
+    def_op("BUILD_CHECKED_LIST_CACHED", 10)
+    hasconst.append(10)
+    hasarg.append(10)
+    if "BUILD_CHECKED_LIST" not in specializations:
+        specializations["BUILD_CHECKED_LIST"] = []
+    specializations["BUILD_CHECKED_LIST"].append("BUILD_CHECKED_LIST_CACHED")
+    def_op("LOAD_TYPE", 11)
+    hasconst.append(11)
+    hasarg.append(11)
+    def_op("CAST", 12)
+    hasconst.append(12)
+    hasarg.append(12)
+    cache_format["CAST"] = "{'cache': 2}"
+    def_op("CAST_CACHED", 13)
+    hasconst.append(13)
+    hasarg.append(13)
+    if "CAST" not in specializations:
+        specializations["CAST"] = []
+    specializations["CAST"].append("CAST_CACHED")
+    def_op("LOAD_LOCAL", 14)
+    hasconst.append(14)
+    hasarg.append(14)
+    def_op("STORE_LOCAL", 15)
+    hasconst.append(15)
+    hasarg.append(15)
+    cache_format["STORE_LOCAL"] = "{'cache': 1}"
+    def_op("STORE_LOCAL_CACHED", 16)
+    hasconst.append(16)
+    hasarg.append(16)
+    if "STORE_LOCAL" not in specializations:
+        specializations["STORE_LOCAL"] = []
+    specializations["STORE_LOCAL"].append("STORE_LOCAL_CACHED")
+    def_op("PRIMITIVE_BOX", 17)
+    hasarg.append(17)
+    jrel_op("POP_JUMP_IF_ZERO", 100)
+    hasarg.append(100)
+    inline_cache_entries["POP_JUMP_IF_ZERO"] = 1
+    jrel_op("POP_JUMP_IF_NONZERO", 103)
+    hasarg.append(103)
+    inline_cache_entries["POP_JUMP_IF_NONZERO"] = 1
+    def_op("PRIMITIVE_UNBOX", 18)
+    hasarg.append(18)
+    def_op("PRIMITIVE_BINARY_OP", 19)
+    hasarg.append(19)
+    def_op("PRIMITIVE_UNARY_OP", 20)
+    hasarg.append(20)
+    def_op("PRIMITIVE_COMPARE_OP", 21)
+    hasarg.append(21)
+    def_op("LOAD_ITERABLE_ARG", 22)
+    hasarg.append(22)
+    def_op("LOAD_MAPPING_ARG", 23)
+    hasarg.append(23)
+    def_op("INVOKE_FUNCTION", 24)
+    hasconst.append(24)
+    hasarg.append(24)
+    cache_format["INVOKE_FUNCTION"] = "{'cache': 4}"
+    def_op("INVOKE_FUNCTION_CACHED", 25)
+    hasconst.append(25)
+    hasarg.append(25)
+    if "INVOKE_FUNCTION" not in specializations:
+        specializations["INVOKE_FUNCTION"] = []
+    specializations["INVOKE_FUNCTION"].append("INVOKE_FUNCTION_CACHED")
+    def_op("INVOKE_INDIRECT_CACHED", 26)
+    hasconst.append(26)
+    hasarg.append(26)
+    if "INVOKE_FUNCTION" not in specializations:
+        specializations["INVOKE_FUNCTION"] = []
+    specializations["INVOKE_FUNCTION"].append("INVOKE_INDIRECT_CACHED")
+    def_op("FAST_LEN", 27)
+    hasarg.append(27)
+    def_op("CONVERT_PRIMITIVE", 28)
+    hasarg.append(28)
+    def_op("INVOKE_NATIVE", 29)
+    hasconst.append(29)
+    hasarg.append(29)
+    def_op("LOAD_CLASS", 30)
+    hasconst.append(30)
+    hasarg.append(30)
+    def_op("BUILD_CHECKED_MAP", 31)
+    hasconst.append(31)
+    hasarg.append(31)
+    cache_format["BUILD_CHECKED_MAP"] = "{'cache': 2}"
+    def_op("BUILD_CHECKED_MAP_CACHED", 32)
+    hasconst.append(32)
+    hasarg.append(32)
+    if "BUILD_CHECKED_MAP" not in specializations:
+        specializations["BUILD_CHECKED_MAP"] = []
+    specializations["BUILD_CHECKED_MAP"].append("BUILD_CHECKED_MAP_CACHED")
+    def_op("SEQUENCE_GET", 33)
+    hasarg.append(33)
+    def_op("SEQUENCE_SET", 34)
+    hasarg.append(34)
+    def_op("LIST_DEL", 35)
+    def_op("REFINE_TYPE", 36)
+    hasconst.append(36)
+    hasarg.append(36)
+    def_op("PRIMITIVE_LOAD_CONST", 37)
+    hasconst.append(37)
+    hasarg.append(37)
+    def_op("RETURN_PRIMITIVE", 40)
+    hasarg.append(40)
+    def_op("TP_ALLOC", 41)
+    hasconst.append(41)
+    hasarg.append(41)
+    cache_format["TP_ALLOC"] = "{'cache': 2}"
+    def_op("TP_ALLOC_CACHED", 42)
+    hasconst.append(42)
+    hasarg.append(42)
+    if "TP_ALLOC" not in specializations:
+        specializations["TP_ALLOC"] = []
+    specializations["TP_ALLOC"].append("TP_ALLOC_CACHED")
+    def_op("LOAD_METHOD_STATIC", 43)
+    hasconst.append(43)
+    hasarg.append(43)
+    cache_format["LOAD_METHOD_STATIC"] = "{'cache': 2}"
+    def_op("LOAD_METHOD_STATIC_CACHED", 45)
+    hasconst.append(45)
+    hasarg.append(45)
+    if "LOAD_METHOD_STATIC" not in specializations:
+        specializations["LOAD_METHOD_STATIC"] = []
+    specializations["LOAD_METHOD_STATIC"].append("LOAD_METHOD_STATIC_CACHED")

cinderx/static.py

@@ -0,0 +1,113 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# pyre-strict
+
+# pyre-ignore[21]: _cinderx is not using cpp_python_extension() yet.
+from _cinderx import StaticTypeError  # noqa: F401
+
+# pyre-ignore[21]: _static is defined as part of _cinderx.
+from _static import (  # noqa: F401
+    __build_cinder_class__,
+    _clear_dlopen_cache,
+    _clear_dlsym_cache,
+    _property_missing_fget,
+    _property_missing_fset,
+    _sizeof_dlopen_cache,
+    _sizeof_dlsym_cache,
+    # Checked Containers
+    chkdict,
+    chklist,
+    FAST_LEN_ARRAY,
+    FAST_LEN_DICT,
+    FAST_LEN_INEXACT,
+    FAST_LEN_LIST,
+    FAST_LEN_SET,
+    FAST_LEN_STR,
+    FAST_LEN_TUPLE,
+    init_subclass,
+    install_sp_audit_hook,
+    is_static_callable,
+    is_static_module,
+    is_type_static,
+    lookup_native_symbol,
+    make_context_decorator_wrapper,
+    make_recreate_cm,
+    posix_clock_gettime_ns,
+    PRIM_OP_ADD_DBL,
+    PRIM_OP_ADD_INT,
+    PRIM_OP_AND_INT,
+    PRIM_OP_DIV_DBL,
+    PRIM_OP_DIV_INT,
+    PRIM_OP_DIV_UN_INT,
+    PRIM_OP_EQ_DBL,
+    PRIM_OP_EQ_INT,
+    PRIM_OP_GE_DBL,
+    PRIM_OP_GE_INT,
+    PRIM_OP_GE_UN_INT,
+    PRIM_OP_GT_DBL,
+    PRIM_OP_GT_INT,
+    PRIM_OP_GT_UN_INT,
+    PRIM_OP_INV_INT,
+    PRIM_OP_LE_DBL,
+    PRIM_OP_LE_INT,
+    PRIM_OP_LE_UN_INT,
+    PRIM_OP_LSHIFT_INT,
+    PRIM_OP_LT_DBL,
+    PRIM_OP_LT_INT,
+    PRIM_OP_LT_UN_INT,
+    PRIM_OP_MOD_DBL,
+    PRIM_OP_MOD_INT,
+    PRIM_OP_MOD_UN_INT,
+    PRIM_OP_MUL_DBL,
+    PRIM_OP_MUL_INT,
+    PRIM_OP_NE_DBL,
+    PRIM_OP_NE_INT,
+    PRIM_OP_NEG_DBL,
+    PRIM_OP_NEG_INT,
+    PRIM_OP_NOT_INT,
+    PRIM_OP_OR_INT,
+    PRIM_OP_POW_DBL,
+    PRIM_OP_POW_INT,
+    PRIM_OP_POW_UN_INT,
+    PRIM_OP_RSHIFT_INT,
+    PRIM_OP_RSHIFT_UN_INT,
+    PRIM_OP_SUB_DBL,
+    PRIM_OP_SUB_INT,
+    PRIM_OP_XOR_INT,
+    rand,
+    RAND_MAX,
+    resolve_primitive_descr,
+    SEQ_ARRAY_INT64,
+    SEQ_CHECKED_LIST,
+    SEQ_LIST,
+    SEQ_LIST_INEXACT,
+    SEQ_REPEAT_INEXACT_NUM,
+    SEQ_REPEAT_INEXACT_SEQ,
+    SEQ_REPEAT_PRIMITIVE_NUM,
+    SEQ_REPEAT_REVERSED,
+    SEQ_SUBSCR_UNCHECKED,
+    SEQ_TUPLE,
+    # Static Methods,
+    set_type_code,
+    set_type_final,
+    set_type_static,
+    set_type_static_final,
+    # Static Classes
+    staticarray,
+    TYPED_ARRAY,
+    TYPED_BOOL,
+    TYPED_CHAR,
+    TYPED_DOUBLE,
+    TYPED_INT16,
+    TYPED_INT32,
+    TYPED_INT64,
+    TYPED_INT8,
+    TYPED_INT_16BIT,
+    TYPED_INT_32BIT,
+    TYPED_INT_64BIT,
+    TYPED_OBJECT,
+    TYPED_SINGLE,
+    TYPED_UINT16,
+    TYPED_UINT32,
+    TYPED_UINT64,
+    TYPED_UINT8,
+)

cinderx/strictmodule.py

@@ -0,0 +1,6 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# pyre-strict
+
+NONSTRICT_MODULE_KIND = 0
+STRICT_MODULE_KIND = 1
+STATIC_MODULE_KIND = 2