blosc2 2.7.0__tar.gz → 2.7.1__tar.gz

{blosc2-2.7.0 → blosc2-2.7.1}/ANNOUNCE.rst

@@ -1,4 +1,4 @@
-Announcing Python-Blosc2 2.7.0
+Announcing Python-Blosc2 2.7.1
 ==============================
 
 Updated to latest C-Blosc2 2.15.0. Also, `LazyExpr.evaluate()`

{blosc2-2.7.0/blosc2.egg-info → blosc2-2.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: blosc2
-Version: 2.7.0
+Version: 2.7.1
 Summary: Python wrapper for the C-Blosc2 library
 Author-email: Blosc Development Team <blosc@blosc.org>
 Maintainer-email: Blosc Development Team <blosc@blosc.org>
@@ -23,7 +23,7 @@ Classifier: Programming Language :: Python :: 3.12
 Requires-Python: <4,>=3.10
 Description-Content-Type: text/x-rst
 License-File: LICENSE.txt
-Requires-Dist: numpy>=1.20.3
+Requires-Dist: numpy>=1.21
 Requires-Dist: ndindex>=1.4
 Requires-Dist: msgpack
 Requires-Dist: numexpr

{blosc2-2.7.0 → blosc2-2.7.1}/RELEASE_NOTES.md

@@ -1,5 +1,11 @@
 # Release notes
 
+## Changes from 2.7.0 to 2.7.1
+
+* Updated to latest C-Blosc2 2.15.1.
+  Fixes SIGKILL issues when using the `blosc2` library in old Intel CPUs.
+
+
 ## Changes from 2.6.2 to 2.7.0
 
 * Updated to latest C-Blosc2 2.15.0.

blosc2-2.7.1/VERSION

@@ -0,0 +1 @@
+2.7.1

{blosc2-2.7.0 → blosc2-2.7.1}/blosc2/c-blosc2/ANNOUNCE.md

@@ -1,11 +1,12 @@
-# Announcing C-Blosc2 2.15.0
+# Announcing C-Blosc2 2.15.1
 A fast, compressed and persistent binary data store library for C.
 
 ## What is new?
 
-This is a minor release in which a new io mode
-was added to memory-map files. Furthermore, the `io_cb` read API was changed, so the 
-`SOVERSION` was bumped. In addition, the internal zstd sources were updated to 1.5.6 and some
+This is a maintenance release in which we are fixing calling instructions
+more advanced than available in current CPU, causing a SIGKILL.
+Furthermore, a new `b2nd_nans` function has been added. In addition,
+the internal LZ4 sources were updated to 1.10.0 and some
 other improvements were made.
 
 For more info, please see the release notes in:

{blosc2-2.7.0 → blosc2-2.7.1}/blosc2/c-blosc2/README_B2ND_METALAYER.rst

@@ -1,5 +1,5 @@
 b2nd metalayer
-++++++++++++++
+==============
 
 b2nd format is specified as a metalayer on top of a Blosc2 container for storing
 multidimensional information.  Specifically, this metalayer is named 'b2nd'

{blosc2-2.7.0 → blosc2-2.7.1}/blosc2/c-blosc2/README_CHUNK_FORMAT.rst

@@ -8,7 +8,7 @@ A regular chunk is composed of a header and a blocks section::
     +---------+--------+
 
 Also, there are the so-called lazy chunks that do not have the actual compressed data,
-but only metainformation about how to read it. Lazy chunks typically appear when reading
+but only meta-information about how to read it. Lazy chunks typically appear when reading
 data from persistent media.  A lazy chunk has header and bstarts sections in place and
 in addition, an additional trailer for allowing to read the data blocks::
 

blosc2-2.7.1/blosc2/c-blosc2/README_EXTENSION_FILENAMES.rst

@@ -0,0 +1,8 @@
+Extensions for Blosc2 filenames
+===============================
+
+Blosc2 has different file extensions for different purposes.  Here is a list of the currently supported ones:
+
+- `.b2frame` (but also `.b2f` or `.b2`) (Blosc2 frame): this is the main extension for storing `Blosc2 contiguous frames <README_CFRAME_FORMAT.rst>`_.
+
+- `.b2nd` (Blosc2 n-dimensional): this is just a contiguous frame file with `a metalayer for storing n-dimensional information <README_B2ND_METALAYER.rst>`_ like shape, chunkshape, blockshape and dtype.

{blosc2-2.7.0 → blosc2-2.7.1}/blosc2/c-blosc2/RELEASE_NOTES.md

@@ -1,6 +1,28 @@
 Release notes for C-Blosc2
 ==========================
 
+Changes from 2.15.1 to 2.15.2
+=============================
+
+#XXX version-specific blurb XXX#
+
+
+Changes from 2.15.0 to 2.15.1
+=============================
+
+* Do not pass `-m` flags when compiling `shuffle.c`. This prevents the
+  compiler from incidentally optimizing the code called independently
+  of the runtime CPU check to these instruction sets, effectively
+  causing `SIGILL` on other CPUs.  Fixes #621.  Thanks to @t20100 and @mgorny.
+
+* Internal LZ4 sources bumped to 1.10.0.
+
+* Allow direct loading of plugins by name, without relying on
+  the presence of python. Thanks to @boxerab.
+
+* Add `b2nd_nans` method (PR #624). Thanks to @waynegm.
+
+
 Changes from 2.14.4 to 2.15.0
 =============================
 

{blosc2-2.7.0 → blosc2-2.7.1}/blosc2/c-blosc2/blosc/CMakeLists.txt

@@ -90,7 +90,7 @@ if(LZ4_FOUND)
         target_include_directories(blosc_testing PUBLIC ${LZ4_INCLUDE_DIR})
     endif()
 else()
-    set(LZ4_LOCAL_DIR ${INTERNAL_LIBS}/lz4-1.9.4)
+    set(LZ4_LOCAL_DIR ${INTERNAL_LIBS}/lz4-1.10.0)
     if(BUILD_SHARED)
         target_include_directories(blosc2_shared PRIVATE ${LZ4_LOCAL_DIR})
     endif()
@@ -300,17 +300,11 @@ if(COMPILER_SUPPORT_SSE2)
             set_source_files_properties(
                     shuffle-sse2.c bitshuffle-sse2.c blosclz.c fastcopy.c
                     PROPERTIES COMPILE_OPTIONS "/arch:SSE2")
-            set_property(
-                    SOURCE shuffle.c
-                    APPEND PROPERTY COMPILE_OPTIONS "/arch:SSE2")
         endif()
     else()
         set_source_files_properties(
                 shuffle-sse2.c bitshuffle-sse2.c blosclz.c fastcopy.c
                 PROPERTIES COMPILE_OPTIONS -msse2)
-        set_property(
-                SOURCE shuffle.c
-                APPEND PROPERTY COMPILE_OPTIONS -msse2)
         # Add SIMD flags for the bytedelta filter and Intel (it seems that ARM64 does not need these)
         set_source_files_properties(
                 ${PROJECT_SOURCE_DIR}/plugins/filters/bytedelta/bytedelta.c
@@ -330,16 +324,10 @@ if(COMPILER_SUPPORT_AVX2)
         set_source_files_properties(
                 shuffle-avx2.c bitshuffle-avx2.c
                 PROPERTIES COMPILE_OPTIONS "/arch:AVX2")
-        set_property(
-                SOURCE shuffle.c
-                APPEND PROPERTY COMPILE_OPTIONS "/arch:AVX2")
     else()
         set_source_files_properties(
                 shuffle-avx2.c bitshuffle-avx2.c
                 PROPERTIES COMPILE_OPTIONS -mavx2)
-        set_property(
-                SOURCE shuffle.c
-                APPEND PROPERTY COMPILE_OPTIONS -mavx2)
     endif()
 
     # Define a symbol for the shuffle-dispatch implementation
@@ -354,16 +342,10 @@ if(COMPILER_SUPPORT_AVX512)
         set_source_files_properties(
                 bitshuffle-avx512.c
 		PROPERTIES COMPILE_OPTIONS "/arch:AVX512")
-        set_property(
-                SOURCE shuffle.c
-		APPEND PROPERTY COMPILE_OPTIONS "/arch:AVX512")
     else()
         set_source_files_properties(
                 bitshuffle-avx512.c
                 PROPERTIES COMPILE_OPTIONS "-mavx512f;-mavx512bw")
-        set_property(
-                SOURCE shuffle.c
-                APPEND PROPERTY COMPILE_OPTIONS "-mavx512f;-mavx512bw")
     endif()
 
     # Define a symbol for the shuffle-dispatch implementation
@@ -377,17 +359,11 @@ if(COMPILER_SUPPORT_NEON)
     set_source_files_properties(
             shuffle-neon.c bitshuffle-neon.c
             PROPERTIES COMPILE_OPTIONS "-flax-vector-conversions")
-    set_property(
-            SOURCE shuffle.c
-            APPEND PROPERTY COMPILE_OPTIONS "-flax-vector-conversions")
     if(CMAKE_SYSTEM_PROCESSOR STREQUAL armv7l)
         # Only armv7l needs special -mfpu=neon flag; aarch64 doesn't.
       set_source_files_properties(
             shuffle-neon.c bitshuffle-neon.c
             PROPERTIES COMPILE_OPTIONS "-mfpu=neon;-flax-vector-conversions")
-      set_property(
-            SOURCE shuffle.c
-            APPEND PROPERTY COMPILE_OPTIONS "-mfpu=neon;-flax-vector-conversions")
     endif()
     # Define a symbol for the shuffle-dispatch implementation
     # so it knows NEON is supported even though that file is

{blosc2-2.7.0 → blosc2-2.7.1}/blosc2/c-blosc2/blosc/b2nd.c

@@ -395,6 +395,23 @@ int b2nd_zeros(b2nd_context_t *ctx, b2nd_array_t **array) {
 }
 
 
+int b2nd_nans(b2nd_context_t *ctx, b2nd_array_t **array) {
+  BLOSC_ERROR_NULL(ctx, BLOSC2_ERROR_NULL_POINTER);
+  BLOSC_ERROR_NULL(array, BLOSC2_ERROR_NULL_POINTER);
+
+  BLOSC_ERROR(array_new(ctx, BLOSC2_SPECIAL_NAN, array));
+
+  const int32_t typesize = (*array)->sc->typesize;
+  if (typesize != 4 && typesize != 8)
+  {
+    BLOSC_TRACE_ERROR("Unsupported typesize for NaN");
+    return BLOSC2_ERROR_DATA;
+  }
+
+  return BLOSC2_ERROR_SUCCESS;
+}
+
+
 int b2nd_full(b2nd_context_t *ctx, b2nd_array_t **array, const void *fill_value) {
   BLOSC_ERROR_NULL(ctx, BLOSC2_ERROR_NULL_POINTER);
   BLOSC_ERROR_NULL(array, BLOSC2_ERROR_NULL_POINTER);

{blosc2-2.7.0 → blosc2-2.7.1}/blosc2/c-blosc2/blosc/bitshuffle-altivec.c

@@ -24,6 +24,7 @@
 
 #include "bitshuffle-altivec.h"
 #include "bitshuffle-generic.h"
+#include <stdlib.h>
 
 /* Make sure ALTIVEC is available for the compilation target and compiler. */
 #if defined(__ALTIVEC__) && defined(__VSX__) && defined(_ARCH_PWR8)
@@ -33,7 +34,6 @@
 #include <altivec.h>
 
 #include <stdint.h>
-#include <stdlib.h>
 
 /* The next is useful for debugging purposes */
 #if 0
@@ -592,4 +592,23 @@ int64_t bshuf_untrans_bit_elem_altivec(const void* in, void* out, const size_t s
   return count;
 }
 
-#endif /* defined(__ALTIVEC__) */
+
+const bool is_bshuf_altivec = true;
+
+#else /* defined(__ALTIVEC__) && defined(__VSX__) && defined(_ARCH_PWR8) */
+
+const bool is_bshuf_altivec = false;
+
+int64_t
+bshuf_trans_bit_elem_altivec(const void* in, void* out, const size_t size,
+                             const size_t elem_size) {
+  abort();
+}
+
+int64_t
+bshuf_untrans_bit_elem_altivec(const void* in, void* out, const size_t size,
+                               const size_t elem_size) {
+  abort();
+}
+
+#endif /* defined(__ALTIVEC__) && defined(__VSX__) && defined(_ARCH_PWR8) */

{blosc2-2.7.0 → blosc2-2.7.1}/blosc2/c-blosc2/blosc/bitshuffle-altivec.h

@@ -17,6 +17,12 @@
 
 #include <stddef.h>
 #include <stdint.h>
+#include <stdbool.h>
+
+/**
+ * ALTIVEC-accelerated bit(un)shuffle routines availability.
+*/
+extern const bool is_bshuf_altivec;
 
 BLOSC_NO_EXPORT int64_t
     bshuf_trans_byte_elem_altivec(const void* in, void* out, const size_t size,

{blosc2-2.7.0 → blosc2-2.7.1}/blosc2/c-blosc2/blosc/bitshuffle-avx2.c

@@ -23,6 +23,7 @@
 #include "bitshuffle-avx2.h"
 #include "bitshuffle-sse2.h"
 #include "bitshuffle-generic.h"
+#include <stdlib.h>
 
 /* Make sure AVX2 is available for the compilation target and compiler. */
 #if defined(__AVX2__)
@@ -262,4 +263,22 @@ int64_t bshuf_untrans_bit_elem_AVX(const void* in, void* out, const size_t size,
   return count;
 }
 
+const bool is_bshuf_AVX = true;
+
+#else /* defined(__AVX2__) */
+
+const bool is_bshuf_AVX = false;
+
+int64_t
+bshuf_trans_bit_elem_AVX(const void* in, void* out, const size_t size,
+                         const size_t elem_size) {
+  abort();
+}
+
+int64_t
+bshuf_untrans_bit_elem_AVX(const void* in, void* out, const size_t size,
+                           const size_t elem_size) {
+  abort();
+}
+
 #endif /* defined(__AVX2__) */

{blosc2-2.7.0 → blosc2-2.7.1}/blosc2/c-blosc2/blosc/bitshuffle-avx2.h

@@ -17,6 +17,13 @@
 
 #include <stddef.h>
 #include <stdint.h>
+#include <stdbool.h>
+
+/**
+ * AVX2-accelerated bit(un)shuffle routines availability.
+*/
+extern const bool is_bshuf_AVX;
+
 
 /**
  * AVX2-accelerated bitshuffle routine.

{blosc2-2.7.0 → blosc2-2.7.1}/blosc2/c-blosc2/blosc/bitshuffle-avx512.c

@@ -20,13 +20,15 @@
   rights to use.
 **********************************************************************/
 
-/* Make sure AVX512 is available for the compilation target and compiler. */
-#if defined(__AVX512F__) && defined (__AVX512BW__)
-#include <immintrin.h>
 #include "bitshuffle-avx512.h"
 #include "bitshuffle-avx2.h"
 #include "bitshuffle-sse2.h"
 #include "bitshuffle-generic.h"
+#include <stdlib.h>
+
+/* Make sure AVX512 is available for the compilation target and compiler. */
+#if defined(__AVX512F__) && defined (__AVX512BW__)
+#include <immintrin.h>
 
 
 /* Transpose bits within bytes. */
@@ -158,4 +160,22 @@ int64_t bshuf_untrans_bit_elem_AVX512(const void* in, void* out, const size_t si
   return count;
 }
 
-#endif
+const bool is_bshuf_AVX512 = true;
+
+#else /* defined(__AVX512F__) && defined (__AVX512BW__) */
+
+const bool is_bshuf_AVX512 = false;
+
+int64_t
+bshuf_trans_bit_elem_AVX512(const void* in, void* out, const size_t size,
+                            const size_t elem_size) {
+  abort();
+}
+
+int64_t
+bshuf_untrans_bit_elem_AVX512(const void* in, void* out, const size_t size,
+                              const size_t elem_size) {
+  abort();
+}
+
+#endif /* defined(__AVX512F__) && defined (__AVX512BW__) */

{blosc2-2.7.0 → blosc2-2.7.1}/blosc2/c-blosc2/blosc/bitshuffle-avx512.h

@@ -17,6 +17,12 @@
 
 #include <stddef.h>
 #include <stdint.h>
+#include <stdbool.h>
+
+/**
+ * AVX512-accelerated bit(un)shuffle routines availability.
+*/
+extern const bool is_bshuf_AVX512;
 
 BLOSC_NO_EXPORT int64_t
     bshuf_trans_bit_elem_AVX512(const void* in, void* out, const size_t size,

{blosc2-2.7.0 → blosc2-2.7.1}/blosc2/c-blosc2/blosc/bitshuffle-neon.c

@@ -22,13 +22,13 @@
 
 #include "bitshuffle-neon.h"
 #include "bitshuffle-generic.h"
+#include <stdlib.h>
 
 /* Make sure NEON is available for the compilation target and compiler. */
 #if defined(__ARM_NEON)
 
 #include <arm_neon.h>
 
-#include <stdlib.h>
 
 /* The next is useful for debugging purposes */
 #if 0
@@ -491,4 +491,20 @@ int64_t bshuf_untrans_bit_elem_NEON(const void* in, void* out, const size_t size
     return count;
 }
 
+const bool is_bshuf_NEON = true;
+
+#else /* defined(__ARM_NEON) */
+
+const bool is_bshuf_NEON = false;
+
+int64_t bshuf_trans_bit_elem_NEON(const void* in, void* out, const size_t size,
+                                  const size_t elem_size) {
+  abort();
+}
+
+int64_t bshuf_untrans_bit_elem_NEON(const void* in, void* out, const size_t size,
+                                    const size_t elem_size) {
+  abort();
+}
+
 #endif /* defined(__ARM_NEON) */

{blosc2-2.7.0 → blosc2-2.7.1}/blosc2/c-blosc2/blosc/bitshuffle-neon.h

@@ -17,6 +17,12 @@
 
 #include <stddef.h>
 #include <stdint.h>
+#include <stdbool.h>
+
+/**
+ * NEON-accelerated bit(un)shuffle routines availability.
+*/
+extern const bool is_bshuf_NEON;
 
 /**
   NEON-accelerated bitshuffle routine.

{blosc2-2.7.0 → blosc2-2.7.1}/blosc2/c-blosc2/blosc/bitshuffle-sse2.c

@@ -23,6 +23,7 @@
 
 #include "bitshuffle-sse2.h"
 #include "bitshuffle-generic.h"
+#include <stdlib.h>
 
 /* Make sure SSE2 is available for the compilation target and compiler. */
 #if defined(__SSE2__)
@@ -481,5 +482,22 @@ int64_t bshuf_untrans_bit_elem_SSE(const void* in, void* out, const size_t size,
   return count;
 }
 
+const bool is_bshuf_SSE = true;
+
+#else /* defined(__SSE2__) */
+
+const bool is_bshuf_SSE = false;
+
+int64_t
+bshuf_trans_bit_elem_SSE(const void* in, void* out, const size_t size,
+                         const size_t elem_size) {
+  abort();
+}
+
+int64_t
+bshuf_untrans_bit_elem_SSE(const void* in, void* out, const size_t size,
+                           const size_t elem_size) {
+  abort();
+}
 
 #endif /* defined(__SSE2__) */

{blosc2-2.7.0 → blosc2-2.7.1}/blosc2/c-blosc2/blosc/bitshuffle-sse2.h

@@ -17,6 +17,12 @@
 
 #include <stddef.h>
 #include <stdint.h>
+#include <stdbool.h>
+
+/**
+ * SSE2-accelerated bit(un)shuffle routines availability.
+*/
+extern const bool is_bshuf_SSE;
 
 BLOSC_NO_EXPORT int64_t
     bshuf_trans_byte_elem_SSE(const void* in, void* out, const size_t size,

{blosc2-2.7.0 → blosc2-2.7.1}/blosc2/c-blosc2/blosc/blosc-private.h

@@ -265,25 +265,46 @@ static inline int get_libpath(char *plugin_name, char *libpath, char *python_ver
   return BLOSC2_ERROR_SUCCESS;
 }
 
-
 static inline void* load_lib(char *plugin_name, char *libpath) {
-  if (get_libpath(plugin_name, libpath, "") < 0 && get_libpath(plugin_name, libpath, "3") < 0) {
-    BLOSC_TRACE_ERROR("Problems when running python or python3 for getting plugin path");
-    return NULL;
-  }
+    // Attempt to directly load the library by name
+#if defined(_WIN32)
+    // Windows dynamic library (DLL) format
+    snprintf(libpath, PATH_MAX, "blosc2_%s.dll", plugin_name);
+#else
+    // Unix/Linux/Mac OS dynamic library (.so) format
+    snprintf(libpath, PATH_MAX, "libblosc2_%s.so", plugin_name);
+#endif
+    void* loaded_lib = dlopen(libpath, RTLD_LAZY);
+    if (loaded_lib != NULL) {
+        BLOSC_TRACE_INFO("Successfully loaded %s directly\n", libpath);
+        return loaded_lib;
+    } else {
+#if defined(_WIN32)
+        BLOSC_TRACE_INFO("Failed to load %s directly, error: %s\n", libpath, GetLastError());
+#else
+        BLOSC_TRACE_INFO("Failed to load %s directly, error: %s\n", libpath, dlerror());
+#endif
+    }
+    // If direct loading fails, fallback to using Python to find the library path
+    if (get_libpath(plugin_name, libpath, "") < 0 && get_libpath(plugin_name, libpath, "3") < 0) {
+        BLOSC_TRACE_ERROR("Problems when running python or python3 for getting plugin path");
+        return NULL;
+    }
 
-  if (strlen(libpath) == 0) {
-    BLOSC_TRACE_ERROR("Could not find plugin libpath");
-    return NULL;
-  }
-  void* loaded_lib;
-  BLOSC_TRACE_INFO("libpath for plugin blosc2_%s: %s\n", plugin_name, libpath);
-  loaded_lib = dlopen(libpath, RTLD_LAZY);
-  if (loaded_lib == NULL) {
-    BLOSC_TRACE_ERROR("Attempt to load plugin in path '%s' failed with error: %s",
-                      libpath, dlerror());
-  }
-  return loaded_lib;
+    if (strlen(libpath) == 0) {
+        BLOSC_TRACE_ERROR("Could not find plugin libpath");
+        return NULL;
+    }
+
+    // Try to load the library again with the path from Python
+    loaded_lib = dlopen(libpath, RTLD_LAZY);
+    if (loaded_lib == NULL) {
+        BLOSC_TRACE_ERROR("Attempt to load plugin in path '%s' failed with error: %s", libpath, dlerror());
+    } else {
+        BLOSC_TRACE_INFO("Successfully loaded library with Python path: %s\n", libpath);
+    }
+
+    return loaded_lib;
 }
 
 

{blosc2-2.7.0 → blosc2-2.7.1}/blosc2/c-blosc2/blosc/blosc2-stdio.c

@@ -255,7 +255,7 @@ void *blosc2_stdio_mmap_open(const char *urlpath, const char *mode, void* params
       _print_last_error();
       BLOSC_TRACE_ERROR("Cannot close the handle to the memory-mapped file.");
     }
-    
+
     return NULL;
   }
 #else
@@ -353,7 +353,7 @@ int64_t blosc2_stdio_mmap_write(const void *ptr, int64_t size, int64_t nitems, i
         _print_last_error();
         BLOSC_TRACE_ERROR("Cannot close the handle to the memory-mapped file.");
       }
-      
+
       return 0;
     }
 

{blosc2-2.7.0 → blosc2-2.7.1}/blosc2/c-blosc2/blosc/shuffle-altivec.c

@@ -10,6 +10,7 @@
 
 #include "shuffle-altivec.h"
 #include "shuffle-generic.h"
+#include <stdlib.h>
 
 /* Make sure ALTIVEC is available for the compilation target and compiler. */
 #if defined(__ALTIVEC__) && defined(__VSX__) && defined(_ARCH_PWR8)
@@ -423,4 +424,20 @@ unshuffle_altivec(const int32_t bytesoftype, const int32_t blocksize,
   }
 }
 
-#endif /* defined(__ALTIVEC__) */
+const bool is_shuffle_altivec = true;
+
+#else /* defined(__ALTIVEC__) && defined(__VSX__) && defined(_ARCH_PWR8) */
+
+const bool is_shuffle_altivec = false;
+
+void shuffle_altivec(const int32_t bytesoftype, const int32_t blocksize,
+                     const uint8_t *_src, uint8_t *_dest) {
+  abort();
+}
+
+void unshuffle_altivec(const int32_t bytesoftype, const int32_t blocksize,
+                       const uint8_t *_src, uint8_t *_dest) {
+  abort();
+}
+
+#endif /* defined(__ALTIVEC__) && defined(__VSX__) && defined(_ARCH_PWR8) */

{blosc2-2.7.0 → blosc2-2.7.1}/blosc2/c-blosc2/blosc/shuffle-altivec.h

@@ -16,6 +16,12 @@
 #include "blosc2/blosc2-common.h"
 
 #include <stdint.h>
+#include <stdbool.h>
+
+/**
+ * ALTIVEC-accelerated (un)shuffle routines availability.
+*/
+extern const bool is_shuffle_altivec;
 
 /**
   ALTIVEC-accelerated shuffle routine.

{blosc2-2.7.0 → blosc2-2.7.1}/blosc2/c-blosc2/blosc/shuffle-avx2.c

@@ -10,13 +10,13 @@
 
 #include "shuffle-avx2.h"
 #include "shuffle-generic.h"
+#include <stdlib.h>
 
 /* Make sure AVX2 is available for the compilation target and compiler. */
 #if defined(__AVX2__)
 
 #include <immintrin.h>
 
-#include <stdlib.h>
 #include <stdint.h>
 
 /* The next is useful for debugging purposes */
@@ -746,4 +746,20 @@ unshuffle_avx2(const int32_t bytesoftype, const int32_t blocksize,
   }
 }
 
+const bool is_shuffle_avx2 = true;
+
+#else
+
+const bool is_shuffle_avx2 = false;
+
+void shuffle_avx2(const int32_t bytesoftype, const int32_t blocksize,
+                  const uint8_t *_src, uint8_t *_dest) {
+  abort();
+}
+
+void unshuffle_avx2(const int32_t bytesoftype, const int32_t blocksize,
+                    const uint8_t *_src, uint8_t *_dest) {
+  abort();
+}
+
 #endif /* defined(__AVX2__) */

{blosc2-2.7.0 → blosc2-2.7.1}/blosc2/c-blosc2/blosc/shuffle-avx2.h

@@ -16,6 +16,12 @@
 #include "blosc2/blosc2-common.h"
 
 #include <stdint.h>
+#include <stdbool.h>
+
+/**
+ * AVX2-accelerated (un)shuffle routines availability.
+*/
+extern const bool is_shuffle_avx2;
 
 /**
   AVX2-accelerated shuffle routine.