xobjects 0.6.6__tar.gz → 0.6.8__tar.gz

{xobjects-0.6.6/xobjects.egg-info → xobjects-0.6.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xobjects
-Version: 0.6.6
+Version: 0.6.8
 Summary: In-memory serialization and code generator for CPU and GPU
 Home-page: https://xsuite.readthedocs.io/
 Download-URL: https://pypi.python.org/pypi/xobjects

xobjects-0.6.8/xobjects/_version.py

@@ -0,0 +1 @@
+__version__ = "0.6.8"

{xobjects-0.6.6 → xobjects-0.6.8}/xobjects/context.py

@@ -354,25 +354,75 @@ class XContext(ABC):
     ) -> Dict[Tuple[str, tuple], KernelType]:
         pass
 
-    def get_installed_c_source_paths(self) -> List[str]:
-        """Returns a list of include paths registered in dependent packages.
+    def get_installed_c_source_and_library_paths(
+        self,
+    ) -> tuple[set[Path], set[str], set[Path]]:
+        """Returns a list of C paths registered in dependent packages.
 
-        In a package that depends on xobjects, you can register C source paths
-        using the entry point `xobjects.c_sources`. A path to the directory
-        containing the specified module will be added to the include path when
-        building kernels. For example, the following will allow to write
-        ``#include <xtrack/path/to/some/header.h>`` in kernel sources:
+        In a package that depends on xobjects, you can register C source and
+        library paths using the entry point `xobjects.build_info`. These paths
+        will be added to the C include path and the library path when building
+        kernels. For example, the following will allow to write
+        ``#include <xcoll/path/to/some/header.h>`` in kernel sources, and
+        allow to use functions from the library ``xcoll/lib/libFlukaIO.a``:
 
          .. code-block:: toml
             [project.entry-points.xobjects]
-            include = "xtrack"
+            build_info = "xcoll._xobjects:get_build_info"
+
+        and in the file ``xcoll/_xobjects.py``:
+
+         .. code-block:: python
+            from ..general import _pkg_root
+            def get_build_info():
+                return {
+                    "include_dirs": [_pkg_root.parent],
+                    "libraries": ["FlukaIO"],
+                    "library_dirs": [_pkg_root / "lib"],
+                }
         """
-        sources = []
+        sources = set()
+        libs = set()
+        lib_paths = set()
+
+        # Old entry point for backward compatibility
         for ep in entry_points(group="xobjects", name="include"):
             module = ep.load()
             path = Path(module.__file__).parents[1]
-            sources.append(str(path))
-        return sources
+            sources.add(path)
+
+        # New entry point
+        for ep in entry_points(group="xobjects", name="build_info"):
+            get_build_info = ep.load()
+            info = get_build_info()
+            include_dirs = info.get("include_dirs", [])
+            if not hasattr(include_dirs, "__iter__") or isinstance(
+                include_dirs, str
+            ):
+                include_dirs = [include_dirs]
+            include_dirs = [
+                Path(dd).expanduser().resolve() for dd in include_dirs
+            ]
+            sources.update(include_dirs)
+
+            library_dirs = info.get("library_dirs", [])
+            if not hasattr(library_dirs, "__iter__") or isinstance(
+                library_dirs, str
+            ):
+                library_dirs = [library_dirs]
+            library_dirs = [
+                Path(dd).expanduser().resolve() for dd in library_dirs
+            ]
+            lib_paths.update(library_dirs)
+
+            libraries = info.get("libraries", [])
+            if not hasattr(libraries, "__iter__") or isinstance(
+                libraries, str
+            ):
+                libraries = [libraries]
+            libs.update(libraries)
+
+        return sources, libs, lib_paths
 
     @abstractmethod
     def nparray_to_context_array(self, arr, copy=False):

{xobjects-0.6.6 → xobjects-0.6.8}/xobjects/context_cpu.py

@@ -499,10 +499,11 @@ class ContextCpu(XContext):
             xtr_compile_args.append("-DXO_CONTEXT_CPU_SERIAL")
             xtr_link_args.append("-DXO_CONTEXT_CPU_SERIAL")
 
-        extra_include_paths = self.get_installed_c_source_paths()
-        include_flags = [f"-I{path}" for path in extra_include_paths]
-        xtr_compile_args.extend(include_flags)
-        xtr_link_args.extend(include_flags)
+        (
+            extra_include_paths,
+            extra_libraries,
+            extra_library_paths,
+        ) = self.get_installed_c_source_and_library_paths()
 
         if os.name == "nt":  # windows
             # TODO: to be handled properly
@@ -516,6 +517,9 @@ class ContextCpu(XContext):
         ffi_interface.set_source(
             module_name,
             specialized_source,
+            include_dirs=[path.as_posix() for path in extra_include_paths],
+            libraries=list(extra_libraries),
+            library_dirs=[path.as_posix() for path in extra_library_paths],
             extra_compile_args=xtr_compile_args,
             extra_link_args=xtr_link_args,
         )

{xobjects-0.6.6 → xobjects-0.6.8}/xobjects/context_cupy.py

@@ -8,6 +8,7 @@ import os
 import shutil
 import subprocess
 import tempfile
+import warnings
 from typing import Dict, List, Tuple, Literal
 
 import numpy as np
@@ -28,11 +29,24 @@ from .specialize_source import specialize_source
 
 log = logging.getLogger(__name__)
 
+no_fast_compile = False
+"""Disable NVRTC fast compile tuning when building CUDA kernels.
+
+When set to ``True``, ``ContextCupy`` does not pass ``--Ofast-compile=min``
+to NVRTC. The ``XO_CUDA_NO_FAST_COMPILE`` environment variable provides the
+same behavior.
+"""
+
 try:
     import cupy
     import cupyx.scipy
     import cupyx.scipy.interpolate
-    import cupyx.scipy.signal
+    with warnings.catch_warnings():
+        warnings.filterwarnings(
+            'ignore',
+            message=r'cupyx\.jit\.rawkernel is experimental\.',
+            category=FutureWarning)
+        import cupyx.scipy.signal
     import cupyx.scipy.special
     import cupyx.scipy.stats
     from cupyx.scipy import fftpack as cufftp
@@ -385,6 +399,13 @@ class ContextCupy(XContext):
     Creates a Cupy Context object, that allows performing the computations
     on nVidia GPUs.
 
+    The module-level flag ``xobjects.context_cupy.no_fast_compile`` controls
+    whether NVRTC fast compile tuning is disabled. By default it is ``False``,
+    so CUDA kernels built with NVRTC >= 12.9 use ``--Ofast-compile=min`` to
+    reduce compilation time and memory usage, at the cost of some runtime
+    performance. Set it to ``True`` to disable this option. The environment
+    variable ``XO_CUDA_NO_FAST_COMPILE`` also disables it.
+
     Args:
         default_block_size (int):  CUDA thread size that is used by default
             for kernel execution in case a block size is not specified
@@ -477,8 +498,15 @@ class ContextCupy(XContext):
             with open(save_source_as, "w") as fid:
                 fid.write(specialized_source)
 
-        extra_include_paths = self.get_installed_c_source_paths()
-        include_flags = [f"-I{path}" for path in extra_include_paths]
+        (
+            # TODO: how to deal with CUDA libraries?
+            extra_include_paths,
+            _,
+            _,
+        ) = self.get_installed_c_source_and_library_paths()
+        include_flags = [
+            f"-I{path.as_posix()}" for path in extra_include_paths
+        ]
         extra_compile_args = (
             *extra_compile_args,
             *include_flags,
@@ -488,11 +516,20 @@ class ContextCupy(XContext):
         if self.backend == "nvrtc":
             # NVRTC (default): add NVRTC-specific flags
             nvrtc_args = (*extra_compile_args,)
+            fast_compile = not (
+                no_fast_compile or os.environ.get("XO_CUDA_NO_FAST_COMPILE")
+            )
             if nvrtc and nvrtc.getVersion() >= (12, 9):
                 # If supported, skip prohibitively heavy optimisations (e.g.
                 # involving cloning). This it at the expense of <20%
                 # runtime performance, but gain of a lot of compile time and memory.
-                nvrtc_args += ("--Ofast-compile=min",)
+                if fast_compile:
+                    nvrtc_args += ("--Ofast-compile=min",)
+            elif fast_compile:
+                warnings.warn(
+                    "Detected nvrtc version < 12.9, which does not support compile-time optimisation tuning. "
+                    "Compilation time and memory usage might be high: if this is a problem, please update CUDA nvrtc."
+                )
 
             module = cupy.RawModule(
                 code=specialized_source, options=nvrtc_args

{xobjects-0.6.6 → xobjects-0.6.8}/xobjects/context_pyopencl.py

@@ -228,8 +228,15 @@ class ContextPyopencl(XContext):
             with open(save_source_as, "w") as fid:
                 fid.write(specialized_source)
 
-        extra_include_paths = self.get_installed_c_source_paths()
-        include_flags = [f"-I{path}" for path in extra_include_paths]
+        (
+            # TODO: how to deal with OpenCL libraries?
+            extra_include_paths,
+            _,
+            _,
+        ) = self.get_installed_c_source_and_library_paths()
+        include_flags = [
+            f"-I{path.as_posix()}" for path in extra_include_paths
+        ]
 
         extra_compile_args = (
             *extra_compile_args,

{xobjects-0.6.6 → xobjects-0.6.8}/xobjects/headers/atomicadd.h

@@ -102,7 +102,7 @@ DEF_ATOMIC_ADD(double  , f64)
 #if defined(XO_CONTEXT_CUDA)
     // CUDA compiler may not have <stdint.h>, so define the types if needed.
     #if defined(__CUDACC_RTC__) || defined(__HIPCC_RTC__)
-        // NVRTC and HIPRTC (CuPy RawModule default) can’t see <stdint.h> 
+        // NVRTC and HIPRTC (CuPy RawModule default) can’t see <stdint.h>
         // We detect via __CUDACC_RTC__ (Nvidia) or __HIPCC_RTC__ (ROCm)
         typedef signed char        int8_t;
         typedef short              int16_t;

{xobjects-0.6.6 → xobjects-0.6.8/xobjects.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xobjects
-Version: 0.6.6
+Version: 0.6.8
 Summary: In-memory serialization and code generator for CPU and GPU
 Home-page: https://xsuite.readthedocs.io/
 Download-URL: https://pypi.python.org/pypi/xobjects

{xobjects-0.6.6 → xobjects-0.6.8}/xobjects.egg-info/SOURCES.txt

@@ -1,49 +1,10 @@
-.gitignore
-.pre-commit-config.yaml
-.readthedocs.yaml
 Architecture.md
 LICENSE
 MANIFEST.in
 README.md
-contributors_and_credits.txt
-mktest
 pyproject.toml
-release.sh
-requirements.txt
 setup.cfg
 setup.py
-update_cprght_statement.py
-.github/workflows/black.yml
-docs/Makefile
-docs/architecture.rst
-docs/conf.py
-docs/index.rst
-docs/make.bat
-docs/quickstart.rst
-docs/reference.rst
-docs/architecture/contexts.rst
-docs/architecture/types.rst
-examples/api_def.py
-examples/api_init.py
-examples/capi_example.c
-examples/check_assembly.c
-examples/ex_array_init_perf.py
-examples/ex_cpugpu.py
-examples/ex_nested_ref.py
-examples/ex_ref_cpu.py
-examples/ex_struct_cpu.py
-examples/ex_unionref_cpu.py
-examples/ex_unionref_method.py
-examples/init_soa.py
-examples/issue_with_two_pyopencl_contexts.py
-examples/opencl_offsets.py
-examples/simple_kernel.py
-examples/sixtracklib.py
-examples/kernel_basics/kernel_cffi.py
-examples/kernel_basics/kernel_cupy.py
-examples/kernel_basics/kernel_pyopencl.py
-tests/__init__.py
-tests/notest_capi.py
 tests/test_align.py
 tests/test_array.py
 tests/test_buffer.py

xobjects-0.6.6/.github/workflows/black.yml

@@ -1,10 +0,0 @@
-name: Lint
-
-on: [push, pull_request]
-
-jobs:
-  lint:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: psf/black@26.1.0

xobjects-0.6.6/.gitignore

@@ -1,13 +0,0 @@
-__pycache__/
-*.pyc
-*.pyo
-*.swp
-*.egg-info/
-docs/_build
-cov_html
-.vscode
-.pytest_cache
-.coverage
-.idea
-*.c
-**/.DS_Store

xobjects-0.6.6/.pre-commit-config.yaml

@@ -1,12 +0,0 @@
-repos:
-  - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.5.0
-    hooks:
-    -   id: check-yaml
-    -   id: end-of-file-fixer
-    -   id: trailing-whitespace
-  - repo: https://github.com/psf/black
-    rev: 23.10.1
-    hooks:
-      - id: black
-        language_version: python3 # Should be a command that runs python3.6+

xobjects-0.6.6/.readthedocs.yaml

@@ -1,20 +0,0 @@
-# .readthedocs.yaml
-# Read the Docs configuration file
-# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
-
-# Required
-version: 2
-
-# Build documentation in the docs/ directory with Sphinx
-sphinx:
-   configuration: docs/conf.py
-
-# Optionally build your docs in additional formats such as PDF
-formats:
-   - pdf
-
-# Optionally set the version of Python and requirements required to build your docs
-python:
-   version: 3.7
-#   install:
-#   - requirements: docs/requirements.txt

xobjects-0.6.6/contributors_and_credits.txt

@@ -1,7 +0,0 @@
-The following people contributed to the development of this package:
-
-CERN contributors:
- - R. De Maria
- - G. Iadarola
- - P. Kiksiny
- - S. Lopaciuk

xobjects-0.6.6/docs/Makefile

@@ -1,20 +0,0 @@
-# Minimal makefile for Sphinx documentation
-#
-
-# You can set these variables from the command line, and also
-# from the environment for the first two.
-SPHINXOPTS    ?=
-SPHINXBUILD   ?= sphinx-build
-SOURCEDIR     = .
-BUILDDIR      = _build
-
-# Put it first so that "make" without argument is like "make help".
-help:
-	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
-
-.PHONY: help Makefile
-
-# Catch-all target: route all unknown targets to Sphinx using the new
-# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
-%: Makefile
-	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)

xobjects-0.6.6/docs/architecture/contexts.rst

@@ -1,164 +0,0 @@
-Contexts
-========
-
-Devices
--------
-
-
-Buffers
--------
-
-Buffers are able to store data in the host or device from several object types and return data in device or host.
-
-
-Instance methods:
-
-*  write(self, source, offset, nbytes): write nbytes from source that can be a np-like array, bytearray, bytes or another buffer
-*  to_nplike(self,dtype,shape,offset): return a view of the data in a np-like arrays
-*  to_bytearray(self,offset,count): return
-
-.. code::
-
-   def update_from_xbuffer(self,offset, source, source_offset, nbytes):
-       "update from any xbuffer, don't pass through gpu if possible"
-
-   def update_from_buffer(self, offset, buffer):
-       """source is python buffer such as bytearray, numpy array .data"""
-
-   def copy_native(self,offset,nbytes):
-        """return native data with content at from offset and nbytes
-        return native_data
-
-   def update_from_native(self, offset, source, source_offset, nbytes):
-       """update native source into buffer usef in update_from_xbuffer"""
-
-   def to_nplike(self,offset,shape,dtype)
-       """view in nplike"""
-
-   def to_bytearray(self,offset,nbytes)
-       """copy in byte array: used in update_from_xbuffer"""
-
-   def to_pointer_arg(self,offset,nbytes):
-       return self.data[offset:offset+nbytes] #offset can lead to alignement error in opencl if not multiple of 4 bytes
-
-
-
-Arguments for kernels:
-
-- CPU:
-  - numpy array ->  ``ffi.cast("double *", ffi.from_buffer(arr))``
-  - numpy scalar -> no change
-  - s string -> ``ss.decode("utf8")``
-
-- PyOpenCL:
-  - pyopencl.Buffer: [offset:offset+nbytes] or copy back and fort if needs to be aligned
-  - pyopencl.array:  arr.base_data[arr.offset:arr.offset+arr.nbytes] or copy back and fort
-
-- cuda:
-    -  pycuda.array: arr or arr.data
-
-
-nparray.data:    python buffer pointing to start of the array arrays
-clarray.data:  Optional Opencl buffer pointing to the start of the array
-clarray.base_data,clarray.base_data:  Optional Opencl buffer  and offset from where the pointer start
-cupyaray.
-
-
-clarray.base_data[]:
-
-Code generation
----------------
-
-Each context is able to compile source code and make available python callable functions.
-
-The callable functions can take as arguments Python numbers, strings,
-numpy-like arrays (depending on the context) and xobject allocated in the same
-contexts (if not copies will be done).
-
-Source code is optionally pre-processed to adapt it to the context.
-
-The callable functions are defined by:
-*  the name of the function in the source code
-*  the type of parameters
-*  how to pass parallalization instruction (threads for openmp, grid for GPU)
-
-The callable functions are parametrized by name and argument types.
-
-Each xobject type can provide the API source code  the ``_get_c_api()`` class method.
-
-
-
-C Api
-^^^^^^^^^^^^^^^^^^^
-
-General:
-
-- ``<pointer type> <typename>_getp_<field_names>(<typename> obj, <indexes>)``
-- ``<scalar type>  <typename>_get_<field_names>(<typename> obj, <indexes>)``
-- ``<typename>_set_<field_names>(<typename> obj, <indexes>, <scalar_type> value)``
-- ``<int64> <typename>_size_<field_names>(<typename> obj,<indexes>)``
-
-Array:
-- ``<int64> <typename>_len...(<typename> obj) : number of itemns``
-- ``<int64> <typename>_dim...(<typename> obj, int index): size of dimension``
-- ``<int64> <typename>_ndim...(<typename> obj): number of dimensions``
-- ``void <typename>_strides(int* result)``
-
-UnionRef:
-- ``<int64> <typename>_typeid...(<typename> obj) : get member
-- ``void* <typename>_member...(int* result)``
-
-
-Kernels and Functions
-^^^^^^^^^^^^^^^^^^^^^
-
-Context can execute:
-
-- kernels: no return function and executed on a grid
-- functions: only for cpu kernels
-
-
-.. code:: python
-  Kernel(
-    cname,
-    args=Arg(dtype, name: String, const: Boolean)
-    grid=integer, string or list of string or functions of arguments
-    ret=None)
-
-
-Arg:
-
-* atype: argument type:
-  - provide validation function: cls._validate(value) or atype(value)
-  - provide C-type name: atype._get_ctype()  or dtype -> converted to c types,
-  - generate raw argument from value .atype._get_carg() for the interface
-* name: optional, String needed for the grid
-* const: boolean (used in case of copy back)
-
-Code:
-
-* define sources, list of string or files
-* define kernels to expose, list of kernels
-* define preprocessors
-* attach callable kernels to context
-* to be used by CMethod or CProperty
-
-.. code::
-    double x -> Arg(dtype=xo.Float64,name='x'): takes python scalar and np scalar
-    double *restrict x -> Arg(dtype=xo.Float64,pointer=True,const=False,name='x'): takes np.array, xo.Float64 arrays
-    const double *restrict x -> Arg(dtype=xo.Float64,pointer=True,const=True,name='x'): takes np.array, xo.Float64 arrays
-    const Float64_N -> Arg(dtype=xo.Float64[:],const=True,name='x'): takes xo.Float64[:]
-    const Float64_6by6 -> Arg(dtype=xo.Float64[6,6],const=True,name='x'): takes xo.Float64[6,6]
-
-
-
-
-
-*  function: general function
-*  method: implies first attribute is the instance of the class where it is defined
-*  kernel: implies some iteration and no return type
-
-The function can be defined using:
-*   header
-*   source
-*   body