codon-jit 0.5.2__tar.gz → 0.5.3__tar.gz

{codon_jit-0.5.2 → codon_jit-0.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codon-jit
-Version: 0.5.2
+Version: 0.5.3
 Summary: Codon JIT decorator
 Home-page: https://exaloop.io
 Author: Exaloop Inc.

codon_jit-0.5.3/README.md

@@ -0,0 +1,79 @@
+To install:
+
+```bash
+$ pip install .
+```
+
+If Codon is installed in non-standard directory, please set `CODON_DIR` accordingly.
+
+To use:
+
+```python
+import codon
+
+@codon.jit
+def ...
+```
+
+## Compiler options
+
+Configure the shared JIT before the first `@codon.jit`, `@codon.convert`, or
+`codon.execute()` call:
+
+```python
+import codon
+
+codon.set_options(fastmath=True, pynum=False)
+
+@codon.jit
+def divide(value, divisor):
+	return value // divisor
+
+assert divide(-3, 2) == -1
+```
+
+Option names match the fields in `codon/compiler/options.h`:
+
+| Type | Options |
+| --- | --- |
+| `bool` | `debug`, `pmempty`, `capture`, `native`, `pynum`, `noexc`, `fastmath`, `autopy`, `autofree`, `unordereddict` |
+| `str` | `libdevice`, `gpuName`, `gpuFeat`, `gpuOutput`, `log`, `march`, `mcpu` |
+| List of `str` | `plugins`, `defines`, `disabled`, `mattrs` |
+
+Defaults match `Options`, except the JIT compiles in release mode (`debug=False`).
+For example, `pynum=False` selects C numerical semantics, `fastmath=True` relaxes
+floating-point semantics, and `unordereddict=True` selects unordered dictionaries.
+`defines=["SIZE=64", "LABEL=str:example"]` supplies compile-time constants using
+the same syntax as the CLI's `-D` flag. Plugins are loaded before initialization.
+Logging controls the compiler's process-wide logger.
+
+Repeated `set_options()` calls merge settings; list-valued options are replaced,
+not appended. Values are copied, and invalid names or values leave the previous
+configuration intact. Unknown options and invalid field types raise `ValueError`
+(non-JSON-serializable Python values raise `TypeError`). Initialization failures
+raise `JITError`.
+
+Options cannot change after the first JIT use: `set_options()` then raises
+`RuntimeError`. This avoids invalidating compiled functions or changing semantics
+partway through a session. Options are preserved across the JIT's automatic
+error-recovery resets. Internal execution-mode fields (`argv0`, `jit`, `test`,
+`standalone`, `pyext`, and `ctor`) are not configurable through this API.
+
+`debug=True` here controls compiler optimization/debug information. The existing
+`@codon.jit(debug=...)` argument and `CODON_JIT_DEBUG` control diagnostic verbosity.
+
+Independent low-level wrappers accept the same keyword options and allow updates
+until their first `execute()` or `run_wrapper()` call:
+
+```python
+wrapper = codon.JITWrapper(pynum=False)
+wrapper.set_options(fastmath=True)
+wrapper.execute("assert -3 // 2 == -1", "<example>", 1, False)
+```
+
+The C bridge exposes `jit_validate_options(json)` and
+`jit_init_with_options(name, json)`, using a JSON object with the same field names.
+Both return `CJITResult`; errors are allocated strings that the caller must
+`free()`. Successful initialization returns the JIT handle in `result`, owned by
+the caller and released with `jit_exit()`. The original `jit_init(name)` remains
+available with its existing defaults.

codon_jit-0.5.3/codon/__init__.py

@@ -0,0 +1,9 @@
+# Copyright (C) 2022-2026 Exaloop Inc. <https://exaloop.io>
+
+__all__ = [
+    "jit", "convert", "set_options", "JITError", "JITWrapper", "_jit_register_fn", "_jit"
+]
+
+from .decorator import jit, convert, execute, set_options, JITError, JITWrapper, _jit_register_fn, _jit_callback_fn, _jit
+
+__codon__ = False

{codon_jit-0.5.2 → codon_jit-0.5.3}/codon/decorator.py

@@ -1,6 +1,7 @@
 # Copyright (C) 2022-2026 Exaloop Inc. <https://exaloop.io>
 
 from argparse import ArgumentError
+from copy import deepcopy
 import ctypes
 import inspect
 import sys
@@ -146,9 +147,36 @@ def _codon_type(arg, **kwargs):
 def _codon_types(args, **kwargs):
     return tuple(_codon_type(arg, **kwargs) for arg in args)
 
+_jit_options = {}
+_jit_initialized = False
+_jit_started = False
+
+
+def set_options(**options):
+    """Configure the shared JIT before using jit, convert, or execute.
+
+    Keys match compiler Options fields, for example fastmath=True or pynum=False.
+    Calls merge settings. Invalid options leave the current configuration intact.
+    """
+    if _jit_started:
+        raise RuntimeError("JIT options must be set before the first JIT use")
+    options = deepcopy(options)
+    _jit.set_options(**options)
+    _jit_options.update(options)
+
+
 def _reset_jit():
-    global _jit
-    _jit = JITWrapper()
+    global _jit, _jit_initialized
+    _jit = JITWrapper(**_jit_options)
+    _jit_initialized = False
+    return _jit
+
+
+def _get_jit():
+    global _jit_initialized, _jit_started
+    if _jit_initialized:
+        return _jit
+    _jit_started = True
     init_code = (
         "from internal.python import "
         "setup_decorator, PyTuple_GetItem, PyObject_GetAttrString\n"
@@ -159,6 +187,7 @@ def _reset_jit():
     if debug_override == 2:
         print(f"[jit_debug] execute:\n{init_code}", file=sys.stderr)
     _jit.execute(init_code, "", 0, int(debug_override > 0))
+    _jit_initialized = True
     return _jit
 
 _jit = _reset_jit()
@@ -232,7 +261,7 @@ def convert(t):
 
     if debug_override == 2:
         print(f"[jit_debug] execute:\n{code}", file=sys.stderr)
-    _jit.execute(code, "", 0, int(debug_override > 0))
+    _get_jit().execute(code, "", 0, int(debug_override > 0))
     custom_conversions[t] = name
     return t
 
@@ -244,7 +273,7 @@ def _jit_register_fn(f, pyvars, debug):
             fn, fl = f.__code__.co_filename, f.__code__.co_firstlineno
         if debug == 2:
             print(f"[jit_debug] execute:\n{obj_str}", file=sys.stderr)
-        _jit.execute(obj_str, fn, fl, int(debug > 0))
+        _get_jit().execute(obj_str, fn, fl, int(debug > 0))
         return obj_name
     except JITError:
         _reset_jit()
@@ -270,7 +299,7 @@ def _jit_callback_fn(fn,
         types = _codon_types(args, debug=debug, sample_size=sample_size)
         if debug > 0:
             print("[python] {}({})".format(obj_name, list(types)), file=sys.stderr)
-        return _jit.run_wrapper(
+        return _get_jit().run_wrapper(
             obj_name, list(types), module, list(pyvars), args, int(debug > 0)
         )
     except JITError:
@@ -323,7 +352,7 @@ def execute(code, debug=0):
     try:
         if debug == 2:
             print(f"[jit_debug] execute:\n{code}", file=sys.stderr)
-        _jit.execute(code, "<internal>", 0, int(debug))
+        _get_jit().execute(code, "<internal>", 0, int(debug))
     except JITError:
         _reset_jit()
         raise

{codon_jit-0.5.2 → codon_jit-0.5.3}/codon/jit.pxd

@@ -8,6 +8,8 @@ cdef extern from "codon/compiler/jit_extern.h":
         char *error
 
     void *jit_init(char *name)
+    CJITResult jit_init_with_options(const char *name, const char *options)
+    CJITResult jit_validate_options(const char *options)
     void jit_exit(void *jit)
 
     cdef char *get_jit_library()

{codon_jit-0.5.2 → codon_jit-0.5.3}/codon/jit.pyx

@@ -6,6 +6,7 @@
 # cython: c_string_encoding=utf8
 
 cimport codon.jit
+import json
 from libc.stdlib cimport malloc, calloc, free
 from libc.string cimport strcpy
 from libc.stdint cimport int32_t, uint8_t
@@ -26,14 +27,37 @@ cdef str get_free_str(char *s):
 
 cdef class JITWrapper:
     cdef void* jit
+    cdef bytes options
 
-    def __cinit__(self):
-        self.jit = codon.jit.jit_init(b"codon jit")
+    def __cinit__(self, **options):
+        self.jit = NULL
+        self.options = b"{}"
+        self.set_options(**options)
 
     def __dealloc__(self):
         codon.jit.jit_exit(self.jit)
 
+    def set_options(self, **options):
+        """Set compiler options before this JIT's first execution."""
+        if self.jit is not NULL:
+            raise RuntimeError("JIT options must be set before the first execution")
+        settings = json.loads(self.options)
+        settings.update(options)
+        cdef bytes encoded = json.dumps(settings).encode('utf-8')
+        result = codon.jit.jit_validate_options(encoded)
+        if result.error is not NULL:
+            raise ValueError(get_free_str(result.error))
+        self.options = encoded
+
+    cdef initialize(self):
+        if self.jit is NULL:
+            result = codon.jit.jit_init_with_options(b"codon jit", self.options)
+            if result.error is not NULL:
+                raise JITError(get_free_str(result.error))
+            self.jit = result.result
+
     def execute(self, code: str, filename: str, fileno: int, debug) -> str:
+        self.initialize()
         result = codon.jit.jit_execute_safe(
             self.jit, code.encode('utf-8'), filename.encode('utf-8'), fileno, <uint8_t>debug
         )
@@ -44,6 +68,7 @@ cdef class JITWrapper:
             raise JITError(msg)
 
     def run_wrapper(self, name: str, types: list[str], module: str, pyvars: list[str], args, debug) -> object:
+        self.initialize()
         cdef char** c_types = <char**>calloc(len(types), sizeof(char*))
         cdef char** c_pyvars = <char**>calloc(len(pyvars), sizeof(char*))
         if not c_types or not c_pyvars:

codon_jit-0.5.3/codon/version.py

@@ -0,0 +1,5 @@
+__version__         = "0.5.3"
+CODON_VERSION       = "0.20.3"
+CODON_VERSION_MAJOR = 0
+CODON_VERSION_MINOR = 20
+CODON_VERSION_PATCH = 3

{codon_jit-0.5.2 → codon_jit-0.5.3}/codon_jit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codon-jit
-Version: 0.5.2
+Version: 0.5.3
 Summary: Codon JIT decorator
 Home-page: https://exaloop.io
 Author: Exaloop Inc.

codon_jit-0.5.2/README.md

@@ -1,16 +0,0 @@
-To install:
-
-```bash
-$ pip install .
-```
-
-If Codon is installed in non-standard directory, please set `CODON_DIR` accordingly.
-
-To use:
-
-```python
-import codon
-
-@codon.jit
-def ...
-```

codon_jit-0.5.2/codon/__init__.py

@@ -1,9 +0,0 @@
-# Copyright (C) 2022-2026 Exaloop Inc. <https://exaloop.io>
-
-__all__ = [
-    "jit", "convert", "JITError", "JITWrapper", "_jit_register_fn", "_jit"
-]
-
-from .decorator import jit, convert, execute, JITError, JITWrapper, _jit_register_fn, _jit_callback_fn, _jit
-
-__codon__ = False

codon_jit-0.5.2/codon/version.py

@@ -1,5 +0,0 @@
-__version__         = "0.5.2"
-CODON_VERSION       = "0.20.2"
-CODON_VERSION_MAJOR = 0
-CODON_VERSION_MINOR = 20
-CODON_VERSION_PATCH = 2