aether-dsc 0.2.0__tar.gz → 0.2.2__tar.gz

aether_dsc-0.2.2/NOTICE

@@ -0,0 +1,8 @@
+aether
+Copyright 2026 Alessandro Masat
+
+The table-driven exp and log in aether/backend/cpu/simd/math/PacketExpLog.h
+follow the algorithms of ARM optimized-routines
+(https://github.com/ARM-software/optimized-routines, math/exp.c and math/log.c),
+Copyright (c) Arm Limited, MIT OR Apache-2.0 WITH LLVM-exception. The lookup
+tables in PacketExpLogTables.h were regenerated for aether.

{aether_dsc-0.2.0/aether_dsc.egg-info → aether_dsc-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aether-dsc
-Version: 0.2.0
+Version: 0.2.2
 Summary: aether-dsc — the sealed AETHER header payload: opaque, digest-named, no readable source in the wheel
 Author: Alessandro Masat
 License: Apache-2.0
@@ -58,3 +58,7 @@ refused, never shipped silently broken.
 The blob is a zlib-compressed tar — not obfuscation against a determined
 reader, just enough that `strings`/`cat` on the wheel does not hand back
 readable C++ source.
+
+## Threading
+
+Free-threaded CPython (3.13t/3.14t) is supported: the compiled modules declare GIL-free operation and the GIL stays disabled after import. Any number of threads may call module-level functions, build, compile, plan and cache concurrently. Distinct objects may be used from distinct threads without synchronisation. One stateful object (a stream, capture, launcher, graph, composer, plan, pipeline, active set, host kernel or arg block) shared by several threads is memory-safe — its calls serialise and a consumed object raises — but the ORDER of those calls is the caller's responsibility, exactly as for a NumPy array or a CuPy stream. CUDA adds two rules of its own: a stream capture is begun, filled and ended by one thread, and while any capture is open no thread may synchronise the whole device (stream-level synchronisation is fine). GPU routes are supported on free-threaded 3.14; on 3.13t the CPU route runs.

{aether_dsc-0.2.0 → aether_dsc-0.2.2}/README.md

@@ -39,3 +39,7 @@ refused, never shipped silently broken.
 The blob is a zlib-compressed tar — not obfuscation against a determined
 reader, just enough that `strings`/`cat` on the wheel does not hand back
 readable C++ source.
+
+## Threading
+
+Free-threaded CPython (3.13t/3.14t) is supported: the compiled modules declare GIL-free operation and the GIL stays disabled after import. Any number of threads may call module-level functions, build, compile, plan and cache concurrently. Distinct objects may be used from distinct threads without synchronisation. One stateful object (a stream, capture, launcher, graph, composer, plan, pipeline, active set, host kernel or arg block) shared by several threads is memory-safe — its calls serialise and a consumed object raises — but the ORDER of those calls is the caller's responsibility, exactly as for a NumPy array or a CuPy stream. CUDA adds two rules of its own: a stream capture is begun, filled and ended by one thread, and while any capture is open no thread may synchronise the whole device (stream-level synchronisation is fine). GPU routes are supported on free-threaded 3.14; on 3.13t the CPU route runs.

{aether_dsc-0.2.0 → aether_dsc-0.2.2}/aether_dsc/__init__.py

@@ -31,6 +31,8 @@ goes through :func:`seal`; see :mod:`aether_dsc.seal`'s module docstring.
 """
 from __future__ import annotations
 
+import threading
+
 from ._core import Payload, PAYLOAD_DIR, _unpack, digest_of
 # Imported from `_seal_impl`, deliberately NOT from `.seal`:
 # `aether_dsc/seal.py` is `python -m aether_dsc.seal`'s CLI file, and
@@ -48,9 +50,10 @@ __all__ = ["Payload", "seal", "payload", "version", "PAYLOAD_DIR"]
 #: `constexpr version()`), because a sealed payload speaks for exactly one
 #: aether checkout and a version skew between the two would silently claim
 #: otherwise.
-version = "0.2.0"
+version = "0.2.2"
 
 _PAYLOAD_CACHE: Payload | None = None
+_PAYLOAD_LOCK = threading.Lock()
 
 
 def payload() -> Payload:
@@ -66,6 +69,14 @@ def payload() -> Payload:
     `$HAWK_AETHER_INCLUDE`: a caller that wants "seal if there is no
     blob" asks for it explicitly, `payload()` never guesses.
     """
+    cached = _PAYLOAD_CACHE
+    if cached is not None:
+        return cached
+    with _PAYLOAD_LOCK:
+        return _payload_locked()
+
+
+def _payload_locked() -> Payload:
     global _PAYLOAD_CACHE
     if _PAYLOAD_CACHE is not None:
         return _PAYLOAD_CACHE
@@ -96,4 +107,5 @@ def _reset_payload_cache() -> None:
     freshly written blob in a test's tmp `_payload/` dir) is picked up
     without restarting the process."""
     global _PAYLOAD_CACHE
-    _PAYLOAD_CACHE = None
+    with _PAYLOAD_LOCK:
+        _PAYLOAD_CACHE = None

{aether_dsc-0.2.0 → aether_dsc-0.2.2}/aether_dsc/payload_headers_host.txt

@@ -24,6 +24,7 @@
 # ever observed.
 aether/backend/cpu/simd/math/PacketArcTrig.h
 aether/backend/cpu/simd/math/PacketExpLog.h
+aether/backend/cpu/simd/math/PacketExpLogTables.h
 aether/backend/cpu/simd/math/PacketHyperbolic.h
 aether/backend/cpu/simd/math/PacketMathCore.h
 aether/backend/cpu/simd/math/PacketMisc.h

{aether_dsc-0.2.0 → aether_dsc-0.2.2/aether_dsc.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aether-dsc
-Version: 0.2.0
+Version: 0.2.2
 Summary: aether-dsc — the sealed AETHER header payload: opaque, digest-named, no readable source in the wheel
 Author: Alessandro Masat
 License: Apache-2.0
@@ -58,3 +58,7 @@ refused, never shipped silently broken.
 The blob is a zlib-compressed tar — not obfuscation against a determined
 reader, just enough that `strings`/`cat` on the wheel does not hand back
 readable C++ source.
+
+## Threading
+
+Free-threaded CPython (3.13t/3.14t) is supported: the compiled modules declare GIL-free operation and the GIL stays disabled after import. Any number of threads may call module-level functions, build, compile, plan and cache concurrently. Distinct objects may be used from distinct threads without synchronisation. One stateful object (a stream, capture, launcher, graph, composer, plan, pipeline, active set, host kernel or arg block) shared by several threads is memory-safe — its calls serialise and a consumed object raises — but the ORDER of those calls is the caller's responsibility, exactly as for a NumPy array or a CuPy stream. CUDA adds two rules of its own: a stream capture is begun, filled and ended by one thread, and while any capture is open no thread may synchronise the whole device (stream-level synchronisation is fine). GPU routes are supported on free-threaded 3.14; on 3.13t the CPU route runs.

{aether_dsc-0.2.0 → aether_dsc-0.2.2}/aether_dsc.egg-info/SOURCES.txt

@@ -14,5 +14,6 @@ aether_dsc.egg-info/SOURCES.txt
 aether_dsc.egg-info/dependency_links.txt
 aether_dsc.egg-info/requires.txt
 aether_dsc.egg-info/top_level.txt
-aether_dsc/_payload/a9c89146169d59183c41dba2a050a420a5f3dd40729154ae547b61a2239c38b8.bin
-tests/test_aether_dsc.py
+aether_dsc/_payload/c19a2ae533cbef09f605b99cce9c58d42fa00928b99327a361023a3f8f3cc7d1.bin
+tests/test_aether_dsc.py
+tests/test_ft_payload.py

{aether_dsc-0.2.0 → aether_dsc-0.2.2}/pyproject.toml

@@ -14,7 +14,7 @@ name = "aether-dsc"
 # aether-dsc ships a SEALED payload of that exact checkout, so a version skew
 # between the two would silently claim a payload speaks for a different
 # aether than it does.
-version = "0.2.0"
+version = "0.2.2"
 description = "aether-dsc — the sealed AETHER header payload: opaque, digest-named, no readable source in the wheel"
 readme = "README.md"
 requires-python = ">=3.9"
@@ -67,6 +67,9 @@ aether_dsc = ["py.typed", "_payload/*.bin", "payload_headers.txt",
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]
+markers = [
+    "ft: free-threading rows (raptor.conformance.freethreading) -- skip on a GIL build; select with -m ft on 3.13t/3.14t.",
+]
 # Makes `import aether_dsc` work against the checked-out tree without an
 # install — this repo root, prepended to sys.path before collection (mirrors
 # raptor's/hawk's own pyproject convention).

aether_dsc-0.2.2/tests/test_ft_payload.py

@@ -0,0 +1,109 @@
+# Copyright 2026 Alessandro Masat
+# SPDX-License-Identifier: Apache-2.0
+
+"""Free-threading rows for aether-dsc (FT-1 and FT-3: one ``Payload`` identity).
+
+On a GIL build the rows SKIP with a reason; the name manifest keeps "skipped"
+from degrading into "silently not collected".
+"""
+
+from __future__ import annotations
+
+import sys
+import threading
+import time
+
+import pytest
+
+import aether_dsc
+from raptor.conformance import freethreading as ft
+from raptor.conformance.freethreading import declare_ft_row, register_ft_row
+
+pytestmark = pytest.mark.ft
+
+declare_ft_row(
+    "FT-1-GIL-FREE-AETHER-DSC", "aether-dsc",
+    "importing aether_dsc leaves the GIL off")
+declare_ft_row(
+    "FT-3-PAYLOAD-IDENTITY", "aether-dsc",
+    "16 threads on a cold payload() cache get one Payload object")
+
+EXPECTED_TESTS = frozenset(
+    {
+        "test_manifest_all_tests_collected",
+        "test_rows_declared_and_collected",
+        "test_gil_free_import",
+        "test_payload_cold_cache_single_identity",
+        "test_payload_cold_cache_single_identity_slow_unpack",
+    }
+)
+
+THREADS = 16
+
+
+def _cold_race(rounds: int) -> None:
+    for _ in range(rounds):
+        aether_dsc._reset_payload_cache()
+        barrier = threading.Barrier(THREADS)
+        got: list[object] = []
+        errors: list[BaseException] = []
+
+        def work() -> None:
+            try:
+                barrier.wait()
+                got.append(aether_dsc.payload())
+            except BaseException as exc:  # noqa: BLE001 - checked below
+                errors.append(exc)
+
+        pool = [threading.Thread(target=work) for _ in range(THREADS)]
+        for t in pool:
+            t.start()
+        for t in pool:
+            t.join()
+        assert not errors, errors
+        assert len(got) == THREADS
+        assert len({id(p) for p in got}) == 1, "payload() returned distinct objects"
+        assert all(p is got[0] for p in got)
+        assert aether_dsc.payload() is got[0]
+
+
+def test_manifest_all_tests_collected(request):
+    here = {
+        i.name for i in request.session.items if i.module is sys.modules[__name__]
+    }
+    assert EXPECTED_TESTS <= here, sorted(EXPECTED_TESTS - here)
+    assert {n for n in here if "[" not in n} <= EXPECTED_TESTS
+
+
+def test_rows_declared_and_collected():
+    ft.assert_ft_rows_complete("aether-dsc")
+
+
+@register_ft_row("FT-1-GIL-FREE-AETHER-DSC")
+def test_gil_free_import():
+    ft.require_free_threaded()
+    ft.assert_gil_free("aether_dsc")
+
+
+@register_ft_row("FT-3-PAYLOAD-IDENTITY")
+def test_payload_cold_cache_single_identity():
+    try:
+        _cold_race(50)
+    finally:
+        aether_dsc._reset_payload_cache()
+
+
+def test_payload_cold_cache_single_identity_slow_unpack(monkeypatch):
+    # Widen the check-then-set window: a slow unpack makes an unlocked
+    # cold-cache race certain on every interpreter, GIL or not.
+    real = aether_dsc._unpack
+
+    def slow(data):
+        time.sleep(0.02)
+        return real(data)
+
+    monkeypatch.setattr(aether_dsc, "_unpack", slow)
+    try:
+        _cold_race(3)
+    finally:
+        aether_dsc._reset_payload_cache()

aether_dsc-0.2.0/NOTICE

@@ -1,2 +0,0 @@
-aether
-Copyright 2026 Alessandro Masat