xobjects 0.5.9__tar.gz → 0.5.11__tar.gz

xobjects-0.5.11/Architecture.md

@@ -0,0 +1,202 @@
+# Architecture
+
+## Introduction
+
+The library is based on:
+- Buffers: manage chunck of bytes on CPU and GPU (Cuda and OpenCL) memory using different backends
+- Contexts: keep track of buffers, launch functions operating on buffers
+- Basic types: a set of basic types that allow to describe structured data. Basic types are scalars, strings, structs, arrays and unions. User defined classes, composed with basic types, allow to interact with data on buffers and generate C functions to operate with data.
+- C-API generation: The type information allows to write C functions that can be interact with data. The C functions are specialized for CPU, OpenCL and Cuda. Also loops described by annotation in comments are automatically generated for CPU, OpenCL and Cuda.
+
+When a user defined class is created, Python methods and additional metadeta is attached to the class.
+When an instance of a user defined class is instantiated, memory is written to a buffer and a Python object is created to interact with the data.
+The size of an instance may not be known at class defintion time, but it cannot be changed after initialization.
+
+## Contexts and Buffers
+
+A context contain:
+
+- `new_buffer(capacity)`: create new buffer of initial capacity
+- `buffers`: list of weakref to buffers
+-  kernels : Object containing compiled code from sources/
+
+Buffer:
+- `buffer`: low level buffer
+- `allocate(self,size)`: return the offset of the first free memory chunk of given size and grows the buffer if necessary
+- `free(self,offset,size)`: free a chuck of memory of a given size
+- `grow(self,capacity)`: increase the size of a buffer
+- `_new_buffer(capacity)`: creae lowlevel buffer
+- `update_from_native(...)`: Copy data from native buffer into self.buffer starting from offset
+- `update_from_buffer(...)`: Copy data from python buffer such as bytearray, bytes, memoryview, numpy array.data
+- `update_from_nplike(...)`: Copy data from nplike matching dest_dtype
+- `update_from_xbuffer(...)`: Copy data from any xbuffer, don't pass through cpu if possible
+- `copy_to_native(...)`: Copy data from self.buffer into dest
+- `to_native(...)`: Return native data with content at from offset and nbytes
+- `to_nplike(...)`: Return a view in of an nplike
+- `to_bytearray(...)`: Return a byte array: used in update_from_xbuffer
+- `to_pointer_arg(...)`: Return data that can be used as argument in kernel
+
+## Types
+
+Types can be composed of:
+- scalar: numbers, String
+- compound: Struct, Array, Ref, UnionRef
+
+### Scalars
+- examples: Float64, Int64, ...
+- create: Float64(3.14)
+- memory layout
+    - data
+
+### String:
+- create: String(string_or_int)
+- memory layout
+    - size
+    - data
+
+
+### Struct
+- example: struct MyStruct field1 field2 ...
+- create: Struct(dict), Struct(**args)
+- memory layout:
+  - [ instance size ]
+  - static-field1
+  -  ..
+  - static-fieldn
+  - [ offset field 2 ]
+  - [ offset ...     ]
+  - [ offset field n ]
+  - [ dynamic-field1 ]
+  - [ ... ]
+  - [ dynamic-fieldn ]
+
+### Array:
+- example: 'array' 'f64' d1 d2 d3 'C' ; 'array' 'i64' d1 ':' d3 'F' ;
+- where:
+   - 'C'/'F' is C-contiguos or F-contiguous
+   - d1, d2, .. are the dimensions for each axis and ':' means not specified
+- create: Array(d1,d2,...) or Array([...]) or Array(np-array)
+- memory layout:
+  - [size] if not _is_static_shape or not _is_static_type
+  - [dims ... ] len(_dynamic_shape)
+  - [strides...] if nd>1 and dynamic shapes
+  - [offsets] if not _is_static_type
+  - data
+
+### Union:
+- create: Union(obj), Union( (typename,args) )
+- memory layout
+  - typeid
+  - data
+
+### UnionRef:
+- create: UnionRef(obj), UnionRef( (typename,args) )
+- memory layout
+  - typeid
+  - offset
+
+
+### Ref:
+- memory layout
+  - offset
+
+## Implementation details
+
+Assumptions:
+- Python user API cannot change the internal structure of the object but only the content
+- Python object caches the structure information to avoid round trips to access data
+- C user API does not manipulate structures
+
+
+Operation:
+
+- _inspect_args(*args, **args) -> info: Info
+  - check value and calculate size, offsets and dimensions from arguments, recursively
+  - returns at least `size` for `_get_a_buffer` and `value` for `_to_buffer`
+
+- _get_a_buffer(size, _context, _buffer, _offset):
+  - make sure a valid buffer and offset is created
+
+- _to_buffer(buffer, offset, value, info, size?):
+  - set data on buffer with offset from pyhon value, using info and implicitely respecting size
+  - if value same class -> binary copy (passing from context if needed)
+
+- _from_buffer(buffer, offset) -> value:
+  - create python object from data on buffer. Can be a native type (scalar or string) or another XObject (struct, array)
+
+
+- __init__(self,*args,_context=None, _buffer=None, _offset=None,*nargs)
+  - initialize object data on buffer from args and create python object:
+    - use _pre_init(*args,**nargs) -> return args, nargs standard initialization value
+    - check values and calculate size using `_inspect_args`, return info object containing size, offsets and values to be later used by _to_buffer
+    - allocate using `_get_a_buffer`
+    - write data using `_to_buffer`
+    - use `_post_init` to complete object
+`
+- _update(self, value, size=None):
+  - Optional update object content using value, in case respecting size for string
+
+- __get__(field,instance) or __getitem__(self,index...)
+  - if return instance._cache[field.index] else  #should implement item caching for struct and array
+  - else return _from_buffer
+
+- __set__(..., value) or __setitem__(...,value)
+  - if hasattr(self.ftype._update) get object and update in place
+    else call _to_buffer
+
+- json enconding
+  nested object can be initialized using a json enconding
+  d:dict -> type(**d)
+  t:tuple -> type(*t)
+  a:other -> type(a)
+
+
+
+Class content:
+
+- _inspect_args(cls, *args, **nargs) -> size, offsets
+  compute size and sizes and offsets from arguments
+
+- _to_buffer(cls, buffer, offset, value, offsets=None):
+  initialize object on buffer
+
+- _from_buffer(cls, buffer,offset):
+  create python object from initlialized object on buffer,offset
+
+- _size: object size
+  None if dynamic
+
+Instance content:
+
+- _get_size(self) -> size
+
+## C-API
+
+Access
+- `<Class>_get<_attrs>(obj, <indexes>)` -> scalar or object pointer
+- `<Class>_set<_attrs>(obj, <indexes>, scalar)`
+
+e.g. Multipole_get_field_normal(3)
+
+Kernel convention:
+
+```
+<fun>(void **refs){
+          Type0 arg0 = (Type0) refs[0];
+          ....
+          Type1 argN = (TypeN) refs[N];
+        ...
+        }
+```
+
+``` <fun>(buffer1, offset, ..., offset3){
+         Type0 arg0 = (Type0) refs[offset0];
+         ,,,
+         TypeN argN = (TypeN) refs[offsetN];
+}
+```
+
+## TODO
+
+- add free methods to delete data from buffer
+- implement SOA types

xobjects-0.5.11/MANIFEST.in

@@ -0,0 +1,9 @@
+include pyproject.toml
+
+# Include the README
+include *.md
+
+# Include the license file
+include LICENSE
+
+recursive-include xobjects *.h

{xobjects-0.5.9/xobjects.egg-info → xobjects-0.5.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xobjects
-Version: 0.5.9
+Version: 0.5.11
 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.5.11/xobjects/_version.py

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

xobjects-0.5.11/xobjects/headers/atomicadd.h

@@ -0,0 +1,350 @@
+// copyright ################################# //
+// This file is part of the Xtrack Package.    //
+// Copyright (c) CERN, 2025.                   //
+// ########################################### //
+
+#ifndef _ATOMICADD_H_
+#define _ATOMICADD_H_
+
+#include "xobjects/headers/common.h"
+
+
+// Ensure no conflicting atomicAdd macro is defined earlier for CPU or OpenCL
+#ifndef XO_CONTEXT_CUDA
+#ifdef atomicAdd
+    #warning "Warning: atomicAdd macro already defined, undefining it."
+    #undef atomicAdd
+#endif // atomicAdd
+#endif // XO_CONTEXT_CUDA
+
+
+// ################################# //
+// ###        CPU Contexts       ### //
+// ################################# //
+
+#ifdef XO_CONTEXT_CPU
+#include <stdint.h>
+
+#ifdef XO_CONTEXT_CPU_OPENMP
+    #ifndef _OPENMP
+    #error "XO_CONTEXT_CPU_OPENMP set, but compiled without -fopenmp"
+    #endif
+    // OpenMP atomic capture gives us read+write atomically
+    #define OMP_ATOMIC_CAPTURE  _Pragma("omp atomic capture")
+#else
+    #define OMP_ATOMIC_CAPTURE  // No OpenMP: non-atomic fallback
+#endif // XO_CONTEXT_CPU_OPENMP
+
+// Macro to define atomicAdd for different types, will be overloaded via _Generic.
+#define DEF_ATOMIC_ADD(T, SUF)                                  \
+GPUFUN T atomicAdd_##SUF(GPUGLMEM T *addr, T val) {             \
+    T old;                                                      \
+    const T inc = (T)val;                                       \
+    OMP_ATOMIC_CAPTURE                                          \
+    { old = *addr; *addr = *addr + inc; }                       \
+    return old;                                                 \
+}
+
+DEF_ATOMIC_ADD(int8_t ,   i8)
+DEF_ATOMIC_ADD(int16_t,  i16)
+DEF_ATOMIC_ADD(int32_t,  i32)
+DEF_ATOMIC_ADD(int64_t,  i64)
+DEF_ATOMIC_ADD(uint8_t ,  u8)
+DEF_ATOMIC_ADD(uint16_t, u16)
+DEF_ATOMIC_ADD(uint32_t, u32)
+DEF_ATOMIC_ADD(uint64_t, u64)
+DEF_ATOMIC_ADD(float   , f32)
+DEF_ATOMIC_ADD(double  , f64)
+
+// Using _Generic to select the right function based on type (since C11).
+// See https://en.cppreference.com/w/c/language/generic.html
+#define atomicAdd(addr, val) _Generic((addr),        \
+    int8_t*:   atomicAdd_i8,                         \
+    int16_t*:  atomicAdd_i16,                        \
+    int32_t*:  atomicAdd_i32,                        \
+    int64_t*:  atomicAdd_i64,                        \
+    uint8_t*:  atomicAdd_u8,                         \
+    uint16_t*: atomicAdd_u16,                        \
+    uint32_t*: atomicAdd_u32,                        \
+    uint64_t*: atomicAdd_u64,                        \
+    float*:    atomicAdd_f32,                        \
+    double*:   atomicAdd_f64                         \
+)(addr, (val))
+#endif // XO_CONTEXT_CPU
+
+
+// ################################# //
+// ###        GPU Contexts       ### //
+// ################################# //
+
+/* -------------- Design notes for GPU atomics ---------------------------------
+* We will go for a unified approach for CUDA and OpenCL, with macros where needed.
+* We implement 8/16-bit atomic add by atomically CAS'ing the *containing*
+ * 32-bit word. Only the target byte/halfword lane is modified; the neighbor
+ * lane is preserved. This is linearisable: each successful CAS is one atomic
+ * RMW on the 32-bit word.
+ * Assumptions: little-endian lane layout (true on NVIDIA) and natural alignment
+ * of the 16-bit addresses (addr % 2 == 0). 8-bit has no alignment requirement.
+ * Return value matches CUDA semantics: the **old** value at *addr* (fetch-add).
+ * ---------------------------------------------------------------------------*/
+
+// Info: a CAS function (Compare-And-Swap) takes three arguments: a pointer to
+// the value to be modified, the expected old value, and the new value. The
+// second argument helps to recognise if another thread has modified the value
+// in the meantime. The function compares the value at the address with the
+// expected values, and if they are the same, it writes the new value at the
+// address. In any case, the function returns the actual old value at the
+// address. If the returned value is different from the expected value, it
+// means that another thread has modified the value in the meantime.
+
+// Define types and macros for CUDA and OpenCL
+// -------------------------------------------
+#if defined(XO_CONTEXT_CUDA)
+    // CUDA compiler may not have <stdint.h>, so define the types if needed.
+    #ifdef __CUDACC_RTC__
+        // NVRTC (CuPy RawModule default) can’t see <stdint.h>, so detect it via __CUDACC_RTC__
+        typedef signed char        int8_t;
+        typedef short              int16_t;
+        typedef int                int32_t;
+        typedef long long          int64_t;
+        typedef unsigned char      uint8_t;
+        typedef unsigned short     uint16_t;
+        typedef unsigned int       uint32_t;
+        typedef unsigned long long uint64_t;
+    #else
+        // Alternatively, NVCC path is fine with host headers
+        #include <stdint.h>
+    #endif // __CUDACC_RTC__
+    #define GPUVOLATILE    GPUGLMEM
+    #define __XT_CAS_U32(ptr, exp, val) atomicCAS((GPUVOLATILE uint32_t*)(ptr), (uint32_t)(exp), (uint32_t)(val))
+    #define __XT_CAS_U64(ptr, exp, val) atomicCAS((GPUVOLATILE uint64_t*)(ptr), (uint64_t)(exp), (uint64_t)(val))
+    #define __XT_AS_U32_FROM_F32(x) __float_as_uint(x)
+    #define __XT_AS_F32_FROM_U32(x) __uint_as_float(x)
+    #define __XT_AS_U64_FROM_F64(x) __double_as_longlong(x)
+    #define __XT_AS_F64_FROM_U64(x) __longlong_as_double(x)
+#elif defined(XO_CONTEXT_CL)
+    // It seems OpenCL already has the types from <stdint.h> defined.
+    // typedef char           int8_t;
+    // typedef short          int16_t;
+    // typedef int            int32_t;
+    // typedef long           int64_t;
+    // typedef unsigned char  uint8_t;
+    // typedef unsigned short uint16_t;
+    // typedef unsigned int   uint32_t;
+    // typedef unsigned long  uint64_t;
+    #define GPUVOLATILE    GPUGLMEM volatile
+    #if __OPENCL_C_VERSION__ < 110
+        // Map 1.0 "atom_*" names to 1.1+ "atomic_*"
+        #pragma OPENCL EXTENSION cl_khr_global_int32_base_atomics : enable
+        #define atomic_add     atom_add
+        #define atomic_cmpxchg atom_cmpxchg
+    #endif
+    #pragma OPENCL EXTENSION cl_khr_int64_base_atomics : enable
+    #pragma OPENCL EXTENSION cl_khr_fp64 : enable
+    #define __XT_CAS_U32(ptr, exp, val) atomic_cmpxchg((GPUVOLATILE uint32_t*)(ptr), (uint32_t)(exp), (uint32_t)(val))
+    #define __XT_CAS_U64(ptr, exp, val) atom_cmpxchg((GPUVOLATILE uint64_t*)(ptr), (uint64_t)(exp), (uint64_t)(val))
+    #define __XT_AS_U32_FROM_F32(x) as_uint(x)
+    #define __XT_AS_F32_FROM_U32(x) as_float(x)
+    #define __XT_AS_U64_FROM_F64(x) as_ulong(x)
+    #define __XT_AS_F64_FROM_U64(x) as_double(x)
+#endif // XO_CONTEXT_CUDA / XO_CONTEXT_CL
+
+// Define atomic functions per type
+// --------------------------------
+#if defined(XO_CONTEXT_CUDA) || defined(XO_CONTEXT_CL)
+    // Helper: compute (base 32-bit word pointer, shift, mask) for a byte in that word.
+    GPUFUN inline void __xt_lane8(GPUVOLATILE void* addr, GPUVOLATILE uint32_t** w, uint32_t* sh, uint32_t* mask){
+        size_t a = (size_t)addr;
+        *w    = (GPUVOLATILE uint32_t*)(a & ~(size_t)3); // word: align down to 4-byte boundary
+        *sh   = (uint32_t)((a & (size_t)3) * 8U);        // shift 0,8,16,24 depending on byte lane
+        *mask = (uint32_t)(0xFFu << *sh);
+    }
+    // Helper: same for a halfword (16-bit) in the containing 32-bit word.
+    GPUFUN inline void __xt_lane16(GPUVOLATILE void* addr, GPUVOLATILE uint32_t** w, uint32_t* sh, uint32_t* mask){
+        size_t a = (size_t)addr;
+        *w  = (GPUVOLATILE uint32_t*)(a & ~(size_t)3);  // word: align down to 4-byte boundary
+        *sh = (uint32_t)((a & (size_t)2) ? 16U : 0U);   // shift0 or 16 depending on halfword
+        *mask  = (uint32_t)(0xFFFFU << *sh);
+    }
+
+    // ---------------- 8-bit: int8_t / uint8_t (CAS on 32-bit word) --------------
+    GPUFUN int8_t atomicAdd_i8(GPUVOLATILE int8_t* addr, int8_t val){
+        GPUVOLATILE uint32_t *w;
+        uint32_t sh, mask;
+        __xt_lane8(addr, &w, &sh, &mask);
+        uint32_t old = *w, assumed, b, nb, nw;  // byte, newbyte, newword
+        do {
+            assumed = old;
+            b  = (assumed & mask) >> sh;                    // Extract current 8-bit lane
+            nb = (uint32_t)((uint8_t)b + (uint8_t)val);     // Add in modulo-256 (two's complement)
+            nw = (assumed & ~mask) | ((nb & 0xFFU) << sh);  // Merge back updated lane; leave neighbor lanes intact
+            // Try to publish; if someone raced us, retry with their value
+            old = __XT_CAS_U32(w, assumed, nw);
+        } while (old != assumed);
+        return (int8_t)((assumed & mask) >> sh);
+    }
+    GPUFUN uint8_t atomicAdd_u8(GPUVOLATILE uint8_t* addr, uint8_t val){
+        GPUVOLATILE uint32_t *w;
+        uint32_t sh, mask;
+        __xt_lane8(addr, &w, &sh, &mask);
+        uint32_t old = *w, assumed, b, nb, nw;
+        do {
+            assumed = old;
+            b  = (assumed & mask) >> sh;
+            nb = (uint32_t)(b + val);                             /* mod 256 */
+            nw = (assumed & ~mask) | ((nb & 0xFFU) << sh);
+            old = __XT_CAS_U32(w, assumed, nw);
+        } while (old != assumed);
+        return (uint8_t)((assumed & mask) >> sh);
+    }
+
+    // ---------------- 16-bit: int16_t / uint16_t (CAS on 32-bit word) -----------
+    GPUFUN int16_t atomicAdd_i16(GPUVOLATILE int16_t* addr, int16_t val){
+        GPUVOLATILE uint32_t* w;
+        uint32_t sh, mask;
+        __xt_lane16(addr, &w, &sh, &mask);
+        uint32_t old = *w, assumed, b, nb, nw;
+        do {
+            assumed = old;
+            b  = (assumed & mask) >> sh;
+            nb = (uint32_t)((uint16_t)b + (uint16_t)val);
+            nw = (assumed & ~mask) | ((nb & 0xFFFFU) << sh);
+            old = __XT_CAS_U32(w, assumed, nw);
+        } while (old != assumed);
+        return (int16_t)((assumed & mask) >> sh);
+    }
+    GPUFUN uint16_t atomicAdd_u16(GPUVOLATILE uint16_t* addr, uint16_t val){
+        GPUVOLATILE uint32_t* w;
+        uint32_t sh, mask;
+        __xt_lane16(addr, &w, &sh, &mask);
+        uint32_t old = *w, assumed, b, nb, nw;
+        do {
+            assumed = old;
+            b  = (assumed & mask) >> sh;
+            nb = (uint32_t)(b + val);
+            nw = (assumed & ~mask) | ((nb & 0xFFFFU) << sh);
+            old = __XT_CAS_U32(w, assumed, nw);
+        } while (old != assumed);
+        return (uint16_t)((assumed & mask) >> sh);
+    }
+
+    // ---------------- 32-bit: int32_t / uint32_t (built-in) -----------
+    GPUFUN int32_t atomicAdd_i32(GPUVOLATILE int32_t* addr, int32_t val){
+    #ifdef XO_CONTEXT_CUDA
+        return atomicAdd(addr, val);
+    #else // XO_CONTEXT_CL
+        return atomic_add(addr, val);
+    #endif // XO_CONTEXT_CUDA / XO_CONTEXT_CL
+    }
+    GPUFUN uint32_t atomicAdd_u32(GPUVOLATILE uint32_t* addr, uint32_t val){
+    #ifdef XO_CONTEXT_CUDA
+        return atomicAdd(addr, val);
+    #else // XO_CONTEXT_CL
+        return atomic_add(addr, val);
+    #endif // XO_CONTEXT_CUDA / XO_CONTEXT_CL
+    }
+
+    // ---------------- 64-bit: int64_t / uint64_t (built-in or CAS on 64-bit word) -----------
+    GPUFUN int64_t atomicAdd_i64(GPUVOLATILE int64_t* addr, int64_t val){
+        uint64_t old, nw;
+        do {
+            old = *addr;
+            nw = old + val;
+        } while (__XT_CAS_U64((GPUVOLATILE uint64_t*)addr, old, nw) != old);
+        return old;
+    }
+    GPUFUN uint64_t atomicAdd_u64(GPUVOLATILE uint64_t* addr, uint64_t val){
+    #ifdef XO_CONTEXT_CUDA
+        return atomicAdd(addr, val);
+    #else // XO_CONTEXT_CL
+        return atom_add(addr, val);
+    #endif // XO_CONTEXT_CUDA / XO_CONTEXT_CL
+    }
+
+    // ---------------- 32-bit: float (built-in or CAS on 32-bit word) -----------
+    GPUFUN float atomicAdd_f32(GPUVOLATILE float* addr, float val){
+    #ifdef XO_CONTEXT_CUDA
+        return atomicAdd(addr, val);
+    #else // XO_CONTEXT_CL
+        uint32_t old, nw;
+        do {
+            old = __XT_AS_U32_FROM_F32(*addr);
+            nw = __XT_AS_U32_FROM_F32(__XT_AS_F32_FROM_U32(old) + val);
+        } while (__XT_CAS_U32((GPUVOLATILE uint32_t*)addr, old, nw) != old);
+        return __XT_AS_F32_FROM_U32(old);
+    #endif // XO_CONTEXT_CUDA / XO_CONTEXT_CL
+    }
+
+    // ---------------- 64-bit: float (built-in or CAS on 64-bit word) -----------
+    GPUFUN double atomicAdd_f64(GPUVOLATILE double* addr, double val){
+    #if __CUDA_ARCH__ >= 600
+        return atomicAdd(addr, val);
+    #else // XO_CONTEXT_CL || __CUDA_ARCH__ < 600
+        uint64_t old, nw;
+        do {
+            old = __XT_AS_U64_FROM_F64(*addr);
+            nw = __XT_AS_U64_FROM_F64(__XT_AS_F64_FROM_U64(old) + val);
+        } while (__XT_CAS_U64((GPUVOLATILE uint64_t*)addr, old, nw) != old);
+        return __XT_AS_F64_FROM_U64(old);
+    #endif // __CUDA_ARCH__ >= 600 / XO_CONTEXT_CL
+    }
+#endif // defined(XO_CONTEXT_CUDA) || defined(XO_CONTEXT_CL)
+
+// Define the overloaded function
+// ------------------------------
+#ifdef XO_CONTEXT_CUDA
+    // NVRTC (CuPy RawModule) usually compiles under extern "C".
+    // In C, function overloading is not possible, but we can cheat by doing it in
+    // C++ (with a different name to avoid clashes with the built-in atomicAdd).
+    // This function will then be remapped to atomicAdd() via a macro in C.
+    #ifdef __cplusplus
+    extern "C++" {
+
+    GPUFUN int8_t   xt_atomicAdd(GPUVOLATILE int8_t*  p, int8_t  v)  { return atomicAdd_i8 (p, v); }
+    GPUFUN uint8_t  xt_atomicAdd(GPUVOLATILE uint8_t* p, uint8_t v)  { return atomicAdd_u8 (p, v); }
+    GPUFUN int16_t  xt_atomicAdd(GPUVOLATILE int16_t* p, int16_t v)  { return atomicAdd_i16(p, v); }
+    GPUFUN uint16_t xt_atomicAdd(GPUVOLATILE uint16_t*p, uint16_t v) { return atomicAdd_u16(p, v); }
+    GPUFUN int64_t  xt_atomicAdd(GPUVOLATILE int64_t*p, int64_t v)   { return atomicAdd_i64(p, v); }
+
+    // Existing type definitions: forward to CUDA built-ins
+    GPUFUN int32_t  xt_atomicAdd(GPUVOLATILE int32_t* p, int32_t v)   { return ::atomicAdd(p, v); }
+    GPUFUN uint32_t xt_atomicAdd(GPUVOLATILE uint32_t* p, uint32_t v) { return ::atomicAdd(p, v); }
+    GPUFUN uint64_t xt_atomicAdd(GPUVOLATILE uint64_t* p, uint64_t v) { return ::atomicAdd(p, v); }
+    GPUFUN float    xt_atomicAdd(GPUVOLATILE float* p, float v)       { return ::atomicAdd(p, v); }
+    #if __CUDA_ARCH__ >= 600
+    GPUFUN double   xt_atomicAdd(GPUVOLATILE double* p, double v)     { return ::atomicAdd(p, v); }
+    #else
+    GPUFUN double   xt_atomicAdd(GPUVOLATILE double* p, double v)     { return atomicAdd_f64(p, v); }
+    #endif
+
+    }
+    #endif // __cplusplus
+
+    // ---------- Global remap of the public name on device code ----------
+    // Define AFTER the wrappers so we don't macro-rewrite our own calls.
+    #ifdef atomicAdd
+    #undef atomicAdd
+    #endif
+    #define atomicAdd(ptr, val) xt_atomicAdd((ptr), (val))
+#endif /* XO_CONTEXT_CUDA */
+
+#ifdef XO_CONTEXT_CL
+    #if !__has_attribute(overloadable)
+        #error "The current OpenCL compiler/architecture does not support __attribute__((overloadable))"
+    #endif
+    #define OCL_OVERLOAD __attribute__((overloadable))
+    GPUFUN int8_t   OCL_OVERLOAD atomicAdd(GPUVOLATILE int8_t*  p, int8_t  v)  { return atomicAdd_i8 (p, v); }
+    GPUFUN uint8_t  OCL_OVERLOAD atomicAdd(GPUVOLATILE uint8_t* p, uint8_t v)  { return atomicAdd_u8 (p, v); }
+    GPUFUN int16_t  OCL_OVERLOAD atomicAdd(GPUVOLATILE int16_t* p, int16_t v)  { return atomicAdd_i16(p, v); }
+    GPUFUN uint16_t OCL_OVERLOAD atomicAdd(GPUVOLATILE uint16_t*p, uint16_t v) { return atomicAdd_u16(p, v); }
+    GPUFUN int64_t  OCL_OVERLOAD atomicAdd(GPUVOLATILE int64_t*p, int64_t v)   { return atomicAdd_i64(p, v); }
+    GPUFUN float    OCL_OVERLOAD atomicAdd(GPUVOLATILE float* p, float v)      { return atomicAdd_f32(p, v); }
+    GPUFUN double   OCL_OVERLOAD atomicAdd(GPUVOLATILE double* p, double v)    { return atomicAdd_f64(p, v); }
+
+    // Existing type definitions: forward to OpenCL built-ins
+    GPUFUN int32_t  OCL_OVERLOAD atomicAdd(GPUVOLATILE int32_t* p, int32_t v)   { return atomic_add(p, v); }
+    GPUFUN uint32_t OCL_OVERLOAD atomicAdd(GPUVOLATILE uint32_t* p, uint32_t v) { return atomic_add(p, v); }
+    GPUFUN uint64_t OCL_OVERLOAD atomicAdd(GPUVOLATILE uint64_t* p, uint64_t v) { return atom_add(p, v); }
+#endif // XO_CONTEXT_CL
+
+#endif //_ATOMICADD_H_

xobjects-0.5.11/xobjects/headers/common.h

@@ -0,0 +1,107 @@
+// copyright ################################# //
+// This file is part of the Xtrack Package.    //
+// Copyright (c) CERN, 2025.                   //
+// ########################################### //
+
+
+#ifndef XOBJECTS_COMMON_H
+#define XOBJECTS_COMMON_H
+
+/*
+    Common macros for vectorization and parallelization, as well as common
+    arithmetic operations.
+*/
+
+#ifdef XO_CONTEXT_CPU_SERIAL
+    // We are on CPU, without OpenMP
+
+    #define VECTORIZE_OVER(INDEX_NAME, COUNT) \
+        for (int64_t INDEX_NAME = 0; INDEX_NAME < (COUNT); INDEX_NAME++) {
+
+    #define END_VECTORIZE \
+        }
+#endif  // XO_CONTEXT_CPU_SERIAL
+
+#ifdef XO_CONTEXT_CPU_OPENMP
+    // We are on CPU with the OpenMP context switched on
+
+    #define VECTORIZE_OVER(INDEX_NAME, COUNT) \
+        _Pragma("omp parallel for") \
+        for (int64_t INDEX_NAME = 0; INDEX_NAME < (COUNT); INDEX_NAME++) {
+
+    #define END_VECTORIZE \
+        }
+#endif  // XO_CONTEXT_CPU_OPENMP
+
+
+#ifdef XO_CONTEXT_CUDA
+    // We are on a CUDA GPU
+
+    #define VECTORIZE_OVER(INDEX_NAME, COUNT) { \
+            int64_t INDEX_NAME = blockDim.x * blockIdx.x + threadIdx.x; \
+            if (INDEX_NAME < (COUNT)) {
+
+    #define END_VECTORIZE \
+            } \
+        }
+#endif  // XO_CONTEXT_CUDA
+
+
+#ifdef XO_CONTEXT_CL
+    // We are on an OpenCL GPU
+
+    #define VECTORIZE_OVER(INDEX_NAME, COUNT) \
+        { \
+            int64_t INDEX_NAME = get_global_id(0); \
+            if (INDEX_NAME < (COUNT)) { \
+
+    #define END_VECTORIZE \
+            } \
+        }
+#endif  // XO_CONTEXT_CL
+
+
+/*
+    Qualifier keywords for GPU and optimisation
+*/
+
+#ifdef XO_CONTEXT_CPU // for both serial and OpenMP
+    #define GPUKERN
+    #define GPUFUN      static inline
+    #define GPUGLMEM
+    #define RESTRICT    restrict
+#endif
+
+
+#ifdef XO_CONTEXT_CUDA
+    #define GPUKERN     __global__
+    #define GPUFUN      __device__
+    #define GPUGLMEM
+    #define RESTRICT
+#endif // XO_CONTEXT_CUDA
+
+
+#ifdef XO_CONTEXT_CL
+    #define GPUKERN     __kernel
+    #define GPUFUN
+    #define GPUGLMEM    __global
+    #define RESTRICT
+#endif // XO_CONTEXT_CL
+
+
+/*
+    Common maths-related macros
+*/
+
+#define POW2(X) ((X)*(X))
+#define POW3(X) ((X)*(X)*(X))
+#define POW4(X) ((X)*(X)*(X)*(X))
+#define NONZERO(X) ((X) != 0.0)
+#define NONZERO_TOL(X, TOL) (fabs((X)) > (TOL))
+
+
+#ifndef VECTORIZE_OVER
+#error "Unknown context, or the expected context (XO_CONTEXT_*) flag undefined. Try updating Xobjects?"
+#endif
+
+#endif  // XOBJECTS_COMMON_H

{xobjects-0.5.9 → xobjects-0.5.11}/xobjects/hybrid_class.py

@@ -169,7 +169,7 @@ class MetaHybridClass(type):
 
             setattr(new_class, pyname, _FieldOfDressed(fname, _XoStruct))
 
-        new_class._fields = pynames_list
+        new_class._fields = [ff.name for ff in _XoStruct._fields]
 
         _XoStruct._DressingClass = new_class
 
@@ -295,6 +295,9 @@ class HybridClass(metaclass=MetaHybridClass):
 
         defaults = {}
         for field in obj._XoStruct._fields:
+            if dft := getattr(self, f"_default_{field.name}", None):
+                defaults[field.name] = dft
+                continue
             name = obj._rename.get(field.name, field.name)
             try:
                 defaults[name] = field.get_default()

{xobjects-0.5.9 → xobjects-0.5.11/xobjects.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xobjects
-Version: 0.5.9
+Version: 0.5.11
 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.5.9 → xobjects-0.5.11}/xobjects.egg-info/SOURCES.txt

@@ -1,5 +1,8 @@
+Architecture.md
 LICENSE
+MANIFEST.in
 README.md
+Readme.md
 pyproject.toml
 setup.cfg
 setup.py
@@ -48,4 +51,6 @@ xobjects.egg-info/SOURCES.txt
 xobjects.egg-info/dependency_links.txt
 xobjects.egg-info/entry_points.txt
 xobjects.egg-info/requires.txt
-xobjects.egg-info/top_level.txt
+xobjects.egg-info/top_level.txt
+xobjects/headers/atomicadd.h
+xobjects/headers/common.h

xobjects-0.5.9/xobjects/_version.py

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