sseflags 0.1__tar.gz

sseflags-0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mikhail Ryazanov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

sseflags-0.1/PKG-INFO

@@ -0,0 +1,187 @@
+Metadata-Version: 2.4
+Name: sseflags
+Version: 0.1
+Summary: Python package for accessing DAZ and FTZ flags
+Author: Mikhail Ryazanov
+License-Expression: MIT
+Project-URL: homepage, https://github.com/MikhailRyazanov/SSEflags
+Project-URL: documentation, https://github.com/MikhailRyazanov/SSEflags/README.md
+Project-URL: github, https://github.com/MikhailRyazanov/SSEflags.git
+Project-URL: issues, https://github.com/MikhailRyazanov/SSEflags/issues
+Keywords: SSE,AVX,subnormal,denormal
+Classifier: Development Status :: 4 - Beta
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# SSE flags
+
+NumPy for x86 platforms (IA-32 and AMD64 architectures) uses SSE and/or AVX for
+floating-point calculations. Unfortunately, on Intel CPUs, they work very
+slowly with
+[subnormal (denormal) numbers](https://en.wikipedia.org/wiki/Subnormal_number).
+To avoid such performance degradation, if somewhat worse floating-point
+accuracy in extreme cases can be tolerated, the
+[DAZ (denormals-are-zero) and FTZ (flush-to-zero) CPU flags](https://www.intel.com/content/www/us/en/docs/dpcpp-cpp-compiler/developer-guide-reference/2025-2/set-the-ftz-and-daz-flags.html)
+were introduced to treat input and/or output subnormal numbers as zeros. This
+module provides access to these CPU flags from Python.
+
+To test the effect on your system, use ``sseflags.benchmark.run()`` or run
+```
+    python3 -m sseflags.benchmark
+```
+in the command line. Example output on Intel i9-12900K (subnormal numbers are
+very slow):
+```
+    Times in milliseconds:
+    default    1.979
+    ========================
+             FTZ off  FTZ on
+    ------------------------
+    DAZ off    1.993   2.037
+    DAZ on     6.669   0.037
+    ========================
+```
+
+AMD CPUs do not show performance degradation on subnormal numbers in the 64-bit
+mode, and thus enabling DAZ/FTZ can only decrease the accuracy slightly.
+Example benchmarks on AMD Ryzen 7 6800U (negligible degradation for subnormal
+numbers; notice that times are in *micro*seconds):
+```
+    Times in microseconds:
+    default   16.834
+    ========================
+             FTZ off  FTZ on
+    ------------------------
+    DAZ off   16.829  15.383
+    DAZ on    15.353  14.500
+    ========================
+```
+Nevertheless, DAZ/FTZ might be useful in 32-bit Python (same CPU, noticeable
+difference):
+```
+    Times in milliseconds:
+    default    0.229
+    ========================
+             FTZ off  FTZ on
+    ------------------------
+    DAZ off    0.225   0.131
+    DAZ on     0.224   0.131
+    ========================
+```
+
+On other architectures, or if the underlying Cython extension is not built, the
+module only reports that it has no effect.
+
+
+## ``sseflags`` module
+
+```
+get_flags()
+    Query current states of the DAZ and FTZ flags, see set_flags() for details.
+    Can be used for restoring the default behavior:
+
+        flags = get_flags()            # remember the original flag states
+        set_flags(daz=True, ftz=True)  # enable DAZ and FTZ
+        ...                            # do some calculations
+        set_flags(**flags)             # restore the original flag states
+
+    Returns
+    -------
+    flags : dict
+        dictionary with the keys 'daz' and 'ftz', values of which represent the
+        corresponding flag state: True for set, False for cleared, None if not
+        implemented
+
+
+set_flags(daz=None, ftz=None, verbose=False)
+    Set the DAZ (denormals-are-zero) and/or FTZ (flush-to-zero) CPU flags for
+    SSE and AVX floating-point calculations, which can be useful for Intel CPUs
+    that work very slowly with subnormal (denormal) numbers.
+
+    On unsupported architectures, or if the underlying Cython extension was not
+    built, this function only reports that it has no effect. The availability
+    can be checked by calling set_flags() without arguments.
+
+    Parameters
+    ----------
+    daz : bool or None, optional
+        True to set, False to clear the DAZ flag; None (default) to leave
+        unchanged
+
+    ftz : bool or None, optional
+        True to set, False to clear the FTZ flag; None (default) to leave
+        unchanged
+
+    verbose : bool, optional
+        pass True to print a warning if the operation is not implemented
+
+    Returns
+    -------
+    implemented : bool
+        True if this operation is implemented, False if not
+```
+
+### ``sseflags.benchmark`` submodule
+
+```
+run(repeat=100, min_t=1.0, verbose=True)
+    Run benchmarks with all possible combinations of the DAZ and FTZ flags to
+    check their effect on NumPy performance (see run_flags() for details).
+
+    Parameters
+    ----------
+    repeat : int, optional
+        number of iterations in a batch
+
+    min_t : float, optional
+        minimal amount of time in seconds to benchmark each combination
+
+    verbose : bool, optional
+        pass False to suppress the progress report
+
+
+run_flags(flags, repeat=100, min_t=1.0)
+    Set the DAZ and FTZ flags to given states and run a benchmark of NumPy
+    matrix multiplication. Each iteration involves multiplication of normal
+    numbers that would produce subnormal numbers and multiplication of
+    subnormal numbers by normal numbers, which also would produce subnormal
+    numbers.
+
+    The test is designed for clear demonstration of performance degradation (if
+    it is present); the effect for real-world data is usually less severe.
+
+    Parameters
+    ----------
+    flags : dict
+        dictionary with arguments passed to sseflags.set_flags()
+
+    repeat : int, optional
+        number of iterations in a batch
+
+    min_t : float, optional
+        batches are repeated until this amount of seconds passes
+
+    Returns
+    -------
+    time : float
+        average time per iteration in seconds
+```
+
+## Installation
+
+Compiled wheels for Linux, macOS and Windows can be installed
+[from PyPI](https://pypi.org/project/sseflags).
+They use [“Stable ABI”](https://docs.python.org/3/c-api/stable.html#stable-abi)
+that should be compatible with all Python versions ⩾3.10. For portability, a
+“universal wheel” is also available. It does not contain the Cython extension,
+and thus has no effect on computations, but can be installed on unsupported
+systems.

sseflags-0.1/README.md

@@ -0,0 +1,163 @@
+# SSE flags
+
+NumPy for x86 platforms (IA-32 and AMD64 architectures) uses SSE and/or AVX for
+floating-point calculations. Unfortunately, on Intel CPUs, they work very
+slowly with
+[subnormal (denormal) numbers](https://en.wikipedia.org/wiki/Subnormal_number).
+To avoid such performance degradation, if somewhat worse floating-point
+accuracy in extreme cases can be tolerated, the
+[DAZ (denormals-are-zero) and FTZ (flush-to-zero) CPU flags](https://www.intel.com/content/www/us/en/docs/dpcpp-cpp-compiler/developer-guide-reference/2025-2/set-the-ftz-and-daz-flags.html)
+were introduced to treat input and/or output subnormal numbers as zeros. This
+module provides access to these CPU flags from Python.
+
+To test the effect on your system, use ``sseflags.benchmark.run()`` or run
+```
+    python3 -m sseflags.benchmark
+```
+in the command line. Example output on Intel i9-12900K (subnormal numbers are
+very slow):
+```
+    Times in milliseconds:
+    default    1.979
+    ========================
+             FTZ off  FTZ on
+    ------------------------
+    DAZ off    1.993   2.037
+    DAZ on     6.669   0.037
+    ========================
+```
+
+AMD CPUs do not show performance degradation on subnormal numbers in the 64-bit
+mode, and thus enabling DAZ/FTZ can only decrease the accuracy slightly.
+Example benchmarks on AMD Ryzen 7 6800U (negligible degradation for subnormal
+numbers; notice that times are in *micro*seconds):
+```
+    Times in microseconds:
+    default   16.834
+    ========================
+             FTZ off  FTZ on
+    ------------------------
+    DAZ off   16.829  15.383
+    DAZ on    15.353  14.500
+    ========================
+```
+Nevertheless, DAZ/FTZ might be useful in 32-bit Python (same CPU, noticeable
+difference):
+```
+    Times in milliseconds:
+    default    0.229
+    ========================
+             FTZ off  FTZ on
+    ------------------------
+    DAZ off    0.225   0.131
+    DAZ on     0.224   0.131
+    ========================
+```
+
+On other architectures, or if the underlying Cython extension is not built, the
+module only reports that it has no effect.
+
+
+## ``sseflags`` module
+
+```
+get_flags()
+    Query current states of the DAZ and FTZ flags, see set_flags() for details.
+    Can be used for restoring the default behavior:
+
+        flags = get_flags()            # remember the original flag states
+        set_flags(daz=True, ftz=True)  # enable DAZ and FTZ
+        ...                            # do some calculations
+        set_flags(**flags)             # restore the original flag states
+
+    Returns
+    -------
+    flags : dict
+        dictionary with the keys 'daz' and 'ftz', values of which represent the
+        corresponding flag state: True for set, False for cleared, None if not
+        implemented
+
+
+set_flags(daz=None, ftz=None, verbose=False)
+    Set the DAZ (denormals-are-zero) and/or FTZ (flush-to-zero) CPU flags for
+    SSE and AVX floating-point calculations, which can be useful for Intel CPUs
+    that work very slowly with subnormal (denormal) numbers.
+
+    On unsupported architectures, or if the underlying Cython extension was not
+    built, this function only reports that it has no effect. The availability
+    can be checked by calling set_flags() without arguments.
+
+    Parameters
+    ----------
+    daz : bool or None, optional
+        True to set, False to clear the DAZ flag; None (default) to leave
+        unchanged
+
+    ftz : bool or None, optional
+        True to set, False to clear the FTZ flag; None (default) to leave
+        unchanged
+
+    verbose : bool, optional
+        pass True to print a warning if the operation is not implemented
+
+    Returns
+    -------
+    implemented : bool
+        True if this operation is implemented, False if not
+```
+
+### ``sseflags.benchmark`` submodule
+
+```
+run(repeat=100, min_t=1.0, verbose=True)
+    Run benchmarks with all possible combinations of the DAZ and FTZ flags to
+    check their effect on NumPy performance (see run_flags() for details).
+
+    Parameters
+    ----------
+    repeat : int, optional
+        number of iterations in a batch
+
+    min_t : float, optional
+        minimal amount of time in seconds to benchmark each combination
+
+    verbose : bool, optional
+        pass False to suppress the progress report
+
+
+run_flags(flags, repeat=100, min_t=1.0)
+    Set the DAZ and FTZ flags to given states and run a benchmark of NumPy
+    matrix multiplication. Each iteration involves multiplication of normal
+    numbers that would produce subnormal numbers and multiplication of
+    subnormal numbers by normal numbers, which also would produce subnormal
+    numbers.
+
+    The test is designed for clear demonstration of performance degradation (if
+    it is present); the effect for real-world data is usually less severe.
+
+    Parameters
+    ----------
+    flags : dict
+        dictionary with arguments passed to sseflags.set_flags()
+
+    repeat : int, optional
+        number of iterations in a batch
+
+    min_t : float, optional
+        batches are repeated until this amount of seconds passes
+
+    Returns
+    -------
+    time : float
+        average time per iteration in seconds
+```
+
+## Installation
+
+Compiled wheels for Linux, macOS and Windows can be installed
+[from PyPI](https://pypi.org/project/sseflags).
+They use [“Stable ABI”](https://docs.python.org/3/c-api/stable.html#stable-abi)
+that should be compatible with all Python versions ⩾3.10. For portability, a
+“universal wheel” is also available. It does not contain the Cython extension,
+and thus has no effect on computations, but can be installed on unsupported
+systems.

sseflags-0.1/pyproject.toml

@@ -0,0 +1,44 @@
+[project]
+name = "sseflags"
+description = "Python package for accessing DAZ and FTZ flags"
+readme = "README.md"
+requires-python = ">= 3.10"
+license = "MIT"
+authors = [{name = "Mikhail Ryazanov"}]
+keywords = ["SSE", "AVX", "subnormal", "denormal"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Topic :: Software Development :: Libraries :: Python Modules",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+]
+dynamic = ["version"]  # __version__ from sseflags/__init__.py
+
+[project.urls]
+homepage = "https://github.com/MikhailRyazanov/SSEflags"
+documentation = "https://github.com/MikhailRyazanov/SSEflags/README.md"
+github = "https://github.com/MikhailRyazanov/SSEflags.git"
+issues = "https://github.com/MikhailRyazanov/SSEflags/issues"
+
+[build-system]
+requires = ["setuptools >= 77.0", "cython >= 3"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+include = ["sseflags"]
+
+[tool.cibuildwheel]
+environment.FORCE_COLOR = 1
+environment.PIP_PROGRESS_BAR = "off"
+test-requires = "abi3audit"
+test-command = "python -m abi3audit -v --summary {wheel}"
+
+[tool.cibuildwheel.linux]
+archs = ["i686", "x86_64"]
+
+[tool.cibuildwheel.windows]
+archs = ["x86", "AMD64"]

sseflags-0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

sseflags-0.1/setup.py

@@ -0,0 +1,27 @@
+import os
+from pathlib import Path
+import sys
+from setuptools import setup, Extension
+
+sys.path.insert(0, '')  # include CWD (missing in build isolation)
+from sseflags import __version__
+
+if sys.platform == 'win32':  # for MSVC
+    extra_compile_args = ['/Os']
+else:  # for GCC and Clang
+    extra_compile_args = ['-Os', '-g0']
+ext_modules = [
+    # ("Path" below is a workaround for Setuptools bug on Windows,
+    #  see https://github.com/pypa/setuptools/issues/5093)
+    Extension('sseflags._lib', [Path('sseflags/_lib.pyx')],
+              extra_compile_args=extra_compile_args,
+              define_macros=[('Py_LIMITED_API', 0x030A0000)],  # 0x0B = 11
+              py_limited_api=True)
+]
+# "sseflags=none python -m build --wheel" to build a "universal" wheel
+# (...-none-any.whl) without Cython extension
+if os.environ.get('sseflags') == 'none':
+    ext_modules = None
+
+setup(version=__version__, ext_modules=ext_modules,
+      options={'bdist_wheel': {'py_limited_api': 'cp310'}})

sseflags-0.1/sseflags/__init__.py

@@ -0,0 +1,72 @@
+try:
+    from ._lib import _get_daz, _get_ftz, _set_daz, _set_ftz
+    _ext = True
+except ImportError:
+    _ext = False
+
+__version__ = '0.1'
+
+
+def get_flags():
+    """
+    Query current states of the DAZ and FTZ flags, see set_flags() for details.
+    Can be used for restoring the default behavior:
+
+        flags = get_flags()            # remember the original flag states
+        set_flags(daz=True, ftz=True)  # enable DAZ and FTZ
+        ...                            # do some calculations
+        set_flags(**flags)             # restore the original flag states
+
+    Returns
+    -------
+    flags : dict
+        dictionary with the keys 'daz' and 'ftz', values of which represent the
+        corresponding flag state: True for set, False for cleared, None if not
+        implemented
+    """
+    flags = {'daz': None, 'ftz': None}
+    if _ext:
+        flags['daz'] = _get_daz()
+        flags['ftz'] = _get_ftz()
+    return flags
+
+
+def set_flags(daz=None, ftz=None, verbose=False):
+    """
+    Set the DAZ (denormals-are-zero) and/or FTZ (flush-to-zero) CPU flags for
+    SSE and AVX floating-point calculations, which can be useful for Intel CPUs
+    that work very slowly with subnormal (denormal) numbers.
+
+    On unsupported architectures, or if the underlying Cython extension was not
+    built, this function only reports that it has no effect. The availability
+    can be checked by calling set_flags() without arguments.
+
+    Parameters
+    ----------
+    daz : bool or None, optional
+        True to set, False to clear the DAZ flag; None (default) to leave
+        unchanged
+
+    ftz : bool or None, optional
+        True to set, False to clear the FTZ flag; None (default) to leave
+        unchanged
+
+    verbose : bool, optional
+        pass True to print a warning if the operation is not implemented
+
+    Returns
+    -------
+    implemented : bool
+        True if this operation is implemented, False if not
+    """
+    if _ext:
+        if daz is not None:
+            _set_daz(daz)
+        if ftz is not None:
+            _set_ftz(ftz)
+        return True
+
+    if verbose:
+        print('Cannot change the DAZ/FTZ flags: the extension was not '
+              'compiled or is not needed for this CPU.')
+    return False

sseflags-0.1/sseflags/_lib.pyx

@@ -0,0 +1,54 @@
+# cython: language_level=3
+# (disable unneeded features to reduce compiled size)
+# cython: always_allow_keywords=False, auto_pickle=False, binding=False
+
+from libcpp cimport bool
+
+
+cdef extern from *:
+    r""" // C code for Cython
+    #include <stdbool.h>
+    #include <pmmintrin.h>
+    #include <xmmintrin.h>
+
+    void c_set_daz(bool on) {
+        _MM_SET_DENORMALS_ZERO_MODE(on ? _MM_DENORMALS_ZERO_ON
+                                       : _MM_DENORMALS_ZERO_OFF);
+    }
+
+    void c_set_ftz(bool on) {
+        _MM_SET_FLUSH_ZERO_MODE((on ? _MM_FLUSH_ZERO_ON
+                                    : _MM_FLUSH_ZERO_OFF));
+    }
+
+    bool c_get_daz(void) {
+        return _MM_GET_DENORMALS_ZERO_MODE();
+    }
+
+    bool c_get_ftz(void) {
+        return _MM_GET_FLUSH_ZERO_MODE();
+    }
+    """
+    # Cython declarations (not exported)
+    void c_set_daz(bool on) nogil
+    void c_set_ftz(bool on) nogil
+    bool c_get_daz() nogil
+    bool c_get_ftz() nogil
+
+
+# Python wrappers for the C functions above
+
+cpdef void _set_daz(bool on) noexcept nogil:
+    c_set_daz(on)
+
+
+cpdef void _set_ftz(bool on) noexcept nogil:
+    c_set_ftz(on)
+
+
+cpdef bool _get_daz() noexcept nogil:
+    return c_get_daz()
+
+
+cpdef bool _get_ftz() noexcept nogil:
+    return c_get_ftz()

sseflags-0.1/sseflags/benchmark.py

@@ -0,0 +1,121 @@
+from itertools import count
+from sys import float_info
+from time import time
+
+import numpy as np
+
+from . import set_flags, get_flags
+
+
+def run(repeat=100, min_t=1.0, verbose=True):
+    """
+    Run benchmarks with all possible combinations of the DAZ and FTZ flags to
+    check their effect on NumPy performance (see run_flags() for details).
+
+    Parameters
+    ----------
+    repeat : int, optional
+        number of iterations in a batch
+
+    min_t : float, optional
+        minimal amount of time in seconds to benchmark each combination
+
+    verbose : bool, optional
+        pass False to suppress the progress report
+    """
+    def vprint(*args):
+        if verbose:
+            print(*args)
+
+    flags = get_flags()
+    vprint(f'Default: {flags}.')
+
+    if not set_flags():
+        print('Setting DAZ/FTZ is not implemented.')
+        return
+
+    res = {}
+    for daz, ftz in [(None, None),
+                     (False, False), (False, True),
+                     (True, False), (True, True)]:
+        res[daz, ftz] = run_flags({'daz': daz, 'ftz': ftz},
+                                  repeat=repeat, min_t=min_t)
+        vprint(f'Done {get_flags()}.')
+
+    set_flags(**flags)
+    vprint(f'Restored: {get_flags()}.\n')
+
+    if max(res.values()) < 100e-6:
+        prefix = 'micro'
+        factor = 1e6
+    else:
+        prefix = 'milli'
+        factor = 1e3
+
+    def fmt(daz, ftz):
+        return f'{res[(daz, ftz)] * factor:6.3f}'
+
+    print(f'Times in {prefix}seconds:')
+    print(f'default   {fmt(None, None)}')
+    print('=' * 24)
+    print('         FTZ off  FTZ on')
+    print('-' * 24)
+    print(f'DAZ off   {fmt(False, False)}  {fmt(False, True)}')
+    print(f'DAZ on    {fmt(True, False)}  {fmt(True, True)}')
+    print('=' * 24)
+
+
+def run_flags(flags, repeat=100, min_t=1.0):
+    """
+    Set the DAZ and FTZ flags to given states and run a benchmark of NumPy
+    matrix multiplication. Each iteration involves multiplication of normal
+    numbers that would produce subnormal numbers and multiplication of
+    subnormal numbers by normal numbers, which also would produce subnormal
+    numbers.
+
+    The test is designed for clear demonstration of performance degradation (if
+    it is present); the effect for real-world data is usually less severe.
+
+    Parameters
+    ----------
+    flags : dict
+        dictionary with arguments passed to sseflags.set_flags()
+
+    repeat : int, optional
+        number of iterations in a batch
+
+    min_t : float, optional
+        batches are repeated until this amount of seconds passes
+
+    Returns
+    -------
+    time : float
+        average time per iteration in seconds
+    """
+    if None not in flags:
+        # to ensure that subnormal test data can be created
+        set_flags(daz=False, ftz=False)
+
+    # Python "float" (= NumPy "float64" = C "double" = IEEE 754 "binary64")
+    # numbers below 2**float_info.min_exp are subnormal and span
+    # float_info.mant_dig binary orders of magnitude, thus:
+    # A consists of normal elements, whose products would be subnormal,
+    # B consists of subnormal elements
+    x = np.arange(float_info.mant_dig)
+    A = 2.0**(float_info.min_exp / 2 - (x + x[:, None]) / 2)
+    B = 2.0**(float_info.min_exp - (x + x[:, None]) / 2)
+    C = np.ones_like(B)
+
+    set_flags(**flags)
+    t0 = time()
+    for i in count(1):
+        for _ in range(repeat):
+            A.dot(A)  # sum(normal * normal = subnormal) = subnormal
+            B.dot(C)  # sum(subnormal * 1.0 = subnormal) = subnormal
+        if time() > t0 + min_t:
+            break
+    return (time() - t0) / (i * repeat)
+
+
+if __name__ == '__main__':
+    run()

sseflags-0.1/sseflags.egg-info/PKG-INFO

@@ -0,0 +1,187 @@
+Metadata-Version: 2.4
+Name: sseflags
+Version: 0.1
+Summary: Python package for accessing DAZ and FTZ flags
+Author: Mikhail Ryazanov
+License-Expression: MIT
+Project-URL: homepage, https://github.com/MikhailRyazanov/SSEflags
+Project-URL: documentation, https://github.com/MikhailRyazanov/SSEflags/README.md
+Project-URL: github, https://github.com/MikhailRyazanov/SSEflags.git
+Project-URL: issues, https://github.com/MikhailRyazanov/SSEflags/issues
+Keywords: SSE,AVX,subnormal,denormal
+Classifier: Development Status :: 4 - Beta
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# SSE flags
+
+NumPy for x86 platforms (IA-32 and AMD64 architectures) uses SSE and/or AVX for
+floating-point calculations. Unfortunately, on Intel CPUs, they work very
+slowly with
+[subnormal (denormal) numbers](https://en.wikipedia.org/wiki/Subnormal_number).
+To avoid such performance degradation, if somewhat worse floating-point
+accuracy in extreme cases can be tolerated, the
+[DAZ (denormals-are-zero) and FTZ (flush-to-zero) CPU flags](https://www.intel.com/content/www/us/en/docs/dpcpp-cpp-compiler/developer-guide-reference/2025-2/set-the-ftz-and-daz-flags.html)
+were introduced to treat input and/or output subnormal numbers as zeros. This
+module provides access to these CPU flags from Python.
+
+To test the effect on your system, use ``sseflags.benchmark.run()`` or run
+```
+    python3 -m sseflags.benchmark
+```
+in the command line. Example output on Intel i9-12900K (subnormal numbers are
+very slow):
+```
+    Times in milliseconds:
+    default    1.979
+    ========================
+             FTZ off  FTZ on
+    ------------------------
+    DAZ off    1.993   2.037
+    DAZ on     6.669   0.037
+    ========================
+```
+
+AMD CPUs do not show performance degradation on subnormal numbers in the 64-bit
+mode, and thus enabling DAZ/FTZ can only decrease the accuracy slightly.
+Example benchmarks on AMD Ryzen 7 6800U (negligible degradation for subnormal
+numbers; notice that times are in *micro*seconds):
+```
+    Times in microseconds:
+    default   16.834
+    ========================
+             FTZ off  FTZ on
+    ------------------------
+    DAZ off   16.829  15.383
+    DAZ on    15.353  14.500
+    ========================
+```
+Nevertheless, DAZ/FTZ might be useful in 32-bit Python (same CPU, noticeable
+difference):
+```
+    Times in milliseconds:
+    default    0.229
+    ========================
+             FTZ off  FTZ on
+    ------------------------
+    DAZ off    0.225   0.131
+    DAZ on     0.224   0.131
+    ========================
+```
+
+On other architectures, or if the underlying Cython extension is not built, the
+module only reports that it has no effect.
+
+
+## ``sseflags`` module
+
+```
+get_flags()
+    Query current states of the DAZ and FTZ flags, see set_flags() for details.
+    Can be used for restoring the default behavior:
+
+        flags = get_flags()            # remember the original flag states
+        set_flags(daz=True, ftz=True)  # enable DAZ and FTZ
+        ...                            # do some calculations
+        set_flags(**flags)             # restore the original flag states
+
+    Returns
+    -------
+    flags : dict
+        dictionary with the keys 'daz' and 'ftz', values of which represent the
+        corresponding flag state: True for set, False for cleared, None if not
+        implemented
+
+
+set_flags(daz=None, ftz=None, verbose=False)
+    Set the DAZ (denormals-are-zero) and/or FTZ (flush-to-zero) CPU flags for
+    SSE and AVX floating-point calculations, which can be useful for Intel CPUs
+    that work very slowly with subnormal (denormal) numbers.
+
+    On unsupported architectures, or if the underlying Cython extension was not
+    built, this function only reports that it has no effect. The availability
+    can be checked by calling set_flags() without arguments.
+
+    Parameters
+    ----------
+    daz : bool or None, optional
+        True to set, False to clear the DAZ flag; None (default) to leave
+        unchanged
+
+    ftz : bool or None, optional
+        True to set, False to clear the FTZ flag; None (default) to leave
+        unchanged
+
+    verbose : bool, optional
+        pass True to print a warning if the operation is not implemented
+
+    Returns
+    -------
+    implemented : bool
+        True if this operation is implemented, False if not
+```
+
+### ``sseflags.benchmark`` submodule
+
+```
+run(repeat=100, min_t=1.0, verbose=True)
+    Run benchmarks with all possible combinations of the DAZ and FTZ flags to
+    check their effect on NumPy performance (see run_flags() for details).
+
+    Parameters
+    ----------
+    repeat : int, optional
+        number of iterations in a batch
+
+    min_t : float, optional
+        minimal amount of time in seconds to benchmark each combination
+
+    verbose : bool, optional
+        pass False to suppress the progress report
+
+
+run_flags(flags, repeat=100, min_t=1.0)
+    Set the DAZ and FTZ flags to given states and run a benchmark of NumPy
+    matrix multiplication. Each iteration involves multiplication of normal
+    numbers that would produce subnormal numbers and multiplication of
+    subnormal numbers by normal numbers, which also would produce subnormal
+    numbers.
+
+    The test is designed for clear demonstration of performance degradation (if
+    it is present); the effect for real-world data is usually less severe.
+
+    Parameters
+    ----------
+    flags : dict
+        dictionary with arguments passed to sseflags.set_flags()
+
+    repeat : int, optional
+        number of iterations in a batch
+
+    min_t : float, optional
+        batches are repeated until this amount of seconds passes
+
+    Returns
+    -------
+    time : float
+        average time per iteration in seconds
+```
+
+## Installation
+
+Compiled wheels for Linux, macOS and Windows can be installed
+[from PyPI](https://pypi.org/project/sseflags).
+They use [“Stable ABI”](https://docs.python.org/3/c-api/stable.html#stable-abi)
+that should be compatible with all Python versions ⩾3.10. For portability, a
+“universal wheel” is also available. It does not contain the Cython extension,
+and thus has no effect on computations, but can be installed on unsupported
+systems.

sseflags-0.1/sseflags.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+sseflags/__init__.py
+sseflags/_lib.pyx
+sseflags/benchmark.py
+sseflags.egg-info/PKG-INFO
+sseflags.egg-info/SOURCES.txt
+sseflags.egg-info/dependency_links.txt
+sseflags.egg-info/top_level.txt

sseflags-0.1/sseflags.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

sseflags-0.1/sseflags.egg-info/top_level.txt

@@ -0,0 +1 @@
+sseflags