Script 'mail_helper' called by obssrc Hello community, here is the log from the commit of package snapraid for openSUSE:Factory checked in at 2026-04-22 17:01:17 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/snapraid (Old) and /work/SRC/openSUSE:Factory/.snapraid.new.11940 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "snapraid" Wed Apr 22 17:01:17 2026 rev:7 rq:1348705 version:14.3 Changes: -------- --- /work/SRC/openSUSE:Factory/snapraid/snapraid.changes 2026-04-10 18:03:13.219122898 +0200 +++ /work/SRC/openSUSE:Factory/.snapraid.new.11940/snapraid.changes 2026-04-22 17:02:13.338508198 +0200 @@ -1,0 +2,15 @@ +Wed Apr 22 07:37:05 UTC 2026 - Paolo Stivanin <[email protected]> + +- Update to 14.3: + * On ARM64 (AArch64), replaced the inline assembly implementation of + 128-bit multiplication with a __uint128_t-based version. + This avoids potential miscompilations of the experimental MuseAir + hash observed with aggressive compiler optimizations (e.g. -O2/-O3) + on some toolchains (notably Apple Silicon), while still generating + optimal code on modern compilers. + * Fixed the speed computation of the undocumented -T option for the + recovery functions. The reported values are now comparable to those + of the generation functions. Note that the real speed is unchanged + from the previous version, only the way it is measured has changed. + +------------------------------------------------------------------- Old: ---- snapraid-14.2.tar.gz New: ---- snapraid-14.3.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ snapraid.spec ++++++ --- /var/tmp/diff_new_pack.SnTT31/_old 2026-04-22 17:02:14.570559038 +0200 +++ /var/tmp/diff_new_pack.SnTT31/_new 2026-04-22 17:02:14.578559368 +0200 @@ -17,7 +17,7 @@ Name: snapraid -Version: 14.2 +Version: 14.3 Release: 0 Summary: Disk array backup for many large rarely-changed files License: GPL-3.0-or-later ++++++ snapraid-14.2.tar.gz -> snapraid-14.3.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/snapraid-14.2/.version new/snapraid-14.3/.version --- old/snapraid-14.2/.version 2026-04-09 23:40:04.000000000 +0200 +++ new/snapraid-14.3/.version 2026-04-16 14:33:48.000000000 +0200 @@ -1 +1 @@ -14.2 \ No newline at end of file +14.3 \ No newline at end of file diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/snapraid-14.2/COPYING new/snapraid-14.3/COPYING --- old/snapraid-14.2/COPYING 2026-04-09 17:56:49.000000000 +0200 +++ new/snapraid-14.3/COPYING 2026-04-16 14:20:32.000000000 +0200 @@ -1,28 +1,11 @@ -The SnapRAID project is provided under: +The SnapRAID project as a whole, including all its contributions and +modifications to included libraries, is provided under the GPL-3.0-or-later +License. - SPDX-License-Identifier: GPL-3.0-or-later +The RAID library is provided under the GPL-2.0-or-later License. -Being under the terms of the GNU General Public License version 3 or any later -version according with: +The TommyDS library is provided under the BSD-2-Clause License. - LICENSES/GPL-3.0 - -The parity generation and verification code int the raid/ directory is -provided under: - - SPDX-License-Identifier: GPL-2.0-or-later - -Being under the terms of the GNU General Public License version 2 or any later -version according with: - - LICENSES/GPL-2.0 - -The TommyDS project is provided under: - - SPDX-License-Identifier: BSD-2-Clause - -Being under the terms of the BSD 2 Clause version according with: - - LICENSES/BSD-2-Clause +The full text for these licenses is available in the LICENSES/ directory. All contributions to the SnapRAID project are subject to this COPYING file. diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/snapraid-14.2/HISTORY new/snapraid-14.3/HISTORY --- old/snapraid-14.2/HISTORY 2026-04-09 23:37:43.000000000 +0200 +++ new/snapraid-14.3/HISTORY 2026-04-16 14:20:32.000000000 +0200 @@ -1,6 +1,19 @@ SnapRAID HISTORY ================ +14.3 2026/04 +============ + * On ARM64 (AArch64), replaced the inline assembly implementation of + 128-bit multiplication with a `__uint128_t`-based version. + This avoids potential miscompilations of the experimental MuseAir + hash observed with aggressive compiler optimizations (e.g. -O2/-O3) + on some toolchains (notably Apple Silicon), while still generating + optimal code on modern compilers. + * Fixed the speed computation of the undocumented -T option for the + recovery functions. The reported values are now comparable to those + of the generation functions. Note that the real speed is unchanged + from the previous version, only the way it is measured has changed. + 14.2 2026/04 ============ * Added a workaround for filesystems with a broken implementation of diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/snapraid-14.2/INSTALL new/snapraid-14.3/INSTALL --- old/snapraid-14.2/INSTALL 2026-01-26 22:49:58.000000000 +0100 +++ new/snapraid-14.3/INSTALL 2026-04-15 18:50:46.000000000 +0200 @@ -7,9 +7,9 @@ tar xf snapraid-.tar.gz cd snapraid-* -To configure and build SnapRAID, run: +To configure the build environment and compile the binary, run: - ./configure + ./configure --prefix=/usr --sysconfdir=/etc make To run the application's correctness tests, execute: diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/snapraid-14.2/cmdline/speed.c new/snapraid-14.3/cmdline/speed.c --- old/snapraid-14.2/cmdline/speed.c 2026-04-09 17:56:49.000000000 +0200 +++ new/snapraid-14.3/cmdline/speed.c 2026-04-16 14:31:12.000000000 +0200 @@ -71,7 +71,9 @@ void** v; if (nd < 0) - nd = 8; + nd = 8; /* default */ + if (nd < 6) + nd = 6; /* minimum */ if (size < 0) size = 256 * KIBI; else @@ -117,23 +119,42 @@ raid_cpu_info(vendor, &family, &model); - printf("CPU %s, family %u, model %u, flags%s%s%s%s%s%s\n", vendor, family, model, + printf("CPU %s, family %u, model %u, flags%s%s%s%s%s%s%s%s\n", vendor, family, model, raid_cpu_has_sse2() ? " sse2" : "", raid_cpu_has_ssse3() ? " ssse3" : "", raid_cpu_has_crc32() ? " crc32" : "", raid_cpu_has_avx2() ? " avx2" : "", + raid_cpu_has_avx512bw() ? " avx512bw" : "", + raid_cpu_has_avx512gfni() ? " avx512gfni" : "", raid_cpu_has_slowmult() ? " slowmult" : "", raid_cpu_has_slowextendedreg() ? " slowext" : "" ); } +#elif defined(__aarch64__) || defined(_M_ARM64) + printf("CPU 64-bit ARM (AArch64)\n"); +#elif defined(__arm__) || defined(_M_ARM) + printf("CPU 32-bit ARM\n"); +#elif defined(__powerpc64__) + printf("CPU 64-bit PowerPC\n"); +#elif defined(__powerpc__) + printf("CPU 32-bit PowerPC\n"); +#elif defined(__riscv) + printf("CPU RISC-V\n"); +#elif defined(__s390x__) + printf("CPU 64-bit IBM Z / s390x\n"); #else - printf("CPU is not a x86/x64\n"); + printf("CPU of unknown architecture\n"); #endif #if WORDS_BIGENDIAN printf("Memory is big-endian %d-bit\n", (int)sizeof(void*) * 8); #else printf("Memory is little-endian %d-bit\n", (int)sizeof(void*) * 8); #endif +#if defined(__SIZEOF_INT128__) + printf("128-bit integers are supported\n"); +#else + printf("128-bit integers are not supported\n"); +#endif #if HAVE_FUTIMENS printf("Support nanosecond timestamps with futimens()\n"); @@ -717,9 +738,10 @@ fflush(stdout); SPEED_START { - for (j = 0; j < nd; ++j) - /* +1 to avoid GEN1 optimized case */ - raid_rec1_int8(1, id, ip + 1, nd, size, v); + /* ensure to use same hardware in the delta step */ + raid_gen_ptr[0] = sizeof(void*) == 8 ? raid_gen1_int64 : raid_gen1_int32; + /* +1 to avoid GEN1 optimized case */ + raid_rec1_int8(1, id, ip + 1, nd, size, v); } SPEED_STOP printf("%8" PRIu64, ds / dt); @@ -729,23 +751,27 @@ #ifdef CONFIG_SSSE3 if (raid_cpu_has_ssse3()) { SPEED_START { - for (j = 0; j < nd; ++j) - /* +1 to avoid GEN1 optimized case */ - raid_rec1_ssse3(1, id, ip + 1, nd, size, v); + /* ensure to use same hardware in the delta step */ + raid_gen_ptr[0] = raid_gen1_sse2; + /* +1 to avoid GEN1 optimized case */ + raid_rec1_ssse3(1, id, ip + 1, nd, size, v); } SPEED_STOP printf("%8" PRIu64, ds / dt); + fflush(stdout); } #endif #ifdef CONFIG_AVX2 if (raid_cpu_has_avx2()) { SPEED_START { - for (j = 0; j < nd; ++j) - /* +1 to avoid GEN1 optimized case */ - raid_rec1_avx2(1, id, ip + 1, nd, size, v); + /* ensure to use same hardware in the delta step */ + raid_gen_ptr[0] = raid_gen1_avx2; + /* +1 to avoid GEN1 optimized case */ + raid_rec1_avx2(1, id, ip + 1, nd, size, v); } SPEED_STOP printf("%8" PRIu64, ds / dt); + fflush(stdout); } #endif #endif @@ -756,9 +782,10 @@ fflush(stdout); SPEED_START { - for (j = 0; j < nd; ++j) - /* +1 to avoid GEN2 optimized case */ - raid_rec2_int8(2, id, ip + 1, nd, size, v); + /* ensure to use same hardware in the delta step */ + raid_gen_ptr[1] = sizeof(void*) == 8 ? raid_gen2_int64 : raid_gen2_int32; + /* +1 to avoid GEN2 optimized case */ + raid_rec2_int8(2, id, ip + 1, nd, size, v); } SPEED_STOP printf("%8" PRIu64, ds / dt); @@ -768,23 +795,31 @@ #ifdef CONFIG_SSSE3 if (raid_cpu_has_ssse3()) { SPEED_START { - for (j = 0; j < nd; ++j) - /* +1 to avoid GEN2 optimized case */ - raid_rec2_ssse3(2, id, ip + 1, nd, size, v); + /* ensure to use same hardware in the delta step */ +#ifdef CONFIG_X86_64 + raid_gen_ptr[1] = raid_gen2_sse2ext; +#else + raid_gen_ptr[1] = raid_gen2_sse2; +#endif + /* +1 to avoid GEN2 optimized case */ + raid_rec2_ssse3(2, id, ip + 1, nd, size, v); } SPEED_STOP printf("%8" PRIu64, ds / dt); + fflush(stdout); } #endif #ifdef CONFIG_AVX2 if (raid_cpu_has_avx2()) { SPEED_START { - for (j = 0; j < nd; ++j) - /* +1 to avoid GEN1 optimized case */ - raid_rec2_avx2(2, id, ip + 1, nd, size, v); + /* ensure to use same hardware in the delta step */ + raid_gen_ptr[1] = raid_gen2_avx2; + /* +1 to avoid GEN1 optimized case */ + raid_rec2_avx2(2, id, ip + 1, nd, size, v); } SPEED_STOP printf("%8" PRIu64, ds / dt); + fflush(stdout); } #endif #endif @@ -795,8 +830,9 @@ fflush(stdout); SPEED_START { - for (j = 0; j < nd; ++j) - raid_recX_int8(3, id, ip, nd, size, v); + /* ensure to use same hardware in the delta step */ + raid_gen_ptr[2] = raid_gen3_int8; + raid_recX_int8(3, id, ip, nd, size, v); } SPEED_STOP printf("%8" PRIu64, ds / dt); @@ -806,21 +842,33 @@ #ifdef CONFIG_SSSE3 if (raid_cpu_has_ssse3()) { SPEED_START { - for (j = 0; j < nd; ++j) - raid_recX_ssse3(3, id, ip, nd, size, v); + /* ensure to use same hardware in the delta step */ +#ifdef CONFIG_X86_64 + raid_gen_ptr[2] = raid_gen3_ssse3ext; +#else + raid_gen_ptr[2] = raid_gen3_ssse3; +#endif + raid_recX_ssse3(3, id, ip, nd, size, v); } SPEED_STOP printf("%8" PRIu64, ds / dt); + fflush(stdout); } #endif #ifdef CONFIG_AVX2 if (raid_cpu_has_avx2()) { SPEED_START { - for (j = 0; j < nd; ++j) - raid_recX_avx2(3, id, ip, nd, size, v); + /* ensure to use same hardware in the delta step */ +#ifdef CONFIG_X86_64 + raid_gen_ptr[2] = raid_gen3_avx2ext; +#else + raid_gen_ptr[2] = raid_gen3_ssse3; +#endif + raid_recX_avx2(3, id, ip, nd, size, v); } SPEED_STOP printf("%8" PRIu64, ds / dt); + fflush(stdout); } #endif #endif @@ -831,8 +879,9 @@ fflush(stdout); SPEED_START { - for (j = 0; j < nd; ++j) - raid_recX_int8(4, id, ip, nd, size, v); + /* ensure to use same hardware in the delta step */ + raid_gen_ptr[3] = raid_gen4_int8; + raid_recX_int8(4, id, ip, nd, size, v); } SPEED_STOP printf("%8" PRIu64, ds / dt); @@ -842,21 +891,33 @@ #ifdef CONFIG_SSSE3 if (raid_cpu_has_ssse3()) { SPEED_START { - for (j = 0; j < nd; ++j) - raid_recX_ssse3(4, id, ip, nd, size, v); + /* ensure to use same hardware in the delta step */ +#ifdef CONFIG_X86_64 + raid_gen_ptr[3] = raid_gen4_ssse3ext; +#else + raid_gen_ptr[3] = raid_gen4_ssse3; +#endif + raid_recX_ssse3(4, id, ip, nd, size, v); } SPEED_STOP printf("%8" PRIu64, ds / dt); + fflush(stdout); } #endif #ifdef CONFIG_AVX2 if (raid_cpu_has_avx2()) { SPEED_START { - for (j = 0; j < nd; ++j) - raid_recX_avx2(4, id, ip, nd, size, v); + /* ensure to use same hardware in the delta step */ +#ifdef CONFIG_X86_64 + raid_gen_ptr[3] = raid_gen4_avx2ext; +#else + raid_gen_ptr[3] = raid_gen4_ssse3; +#endif + raid_recX_avx2(4, id, ip, nd, size, v); } SPEED_STOP printf("%8" PRIu64, ds / dt); + fflush(stdout); } #endif #endif @@ -867,8 +928,9 @@ fflush(stdout); SPEED_START { - for (j = 0; j < nd; ++j) - raid_recX_int8(5, id, ip, nd, size, v); + /* ensure to use same hardware in the delta step */ + raid_gen_ptr[4] = raid_gen5_int8; + raid_recX_int8(5, id, ip, nd, size, v); } SPEED_STOP printf("%8" PRIu64, ds / dt); @@ -878,21 +940,33 @@ #ifdef CONFIG_SSSE3 if (raid_cpu_has_ssse3()) { SPEED_START { - for (j = 0; j < nd; ++j) - raid_recX_ssse3(5, id, ip, nd, size, v); + /* ensure to use same hardware in the delta step */ +#ifdef CONFIG_X86_64 + raid_gen_ptr[4] = raid_gen5_ssse3ext; +#else + raid_gen_ptr[4] = raid_gen5_ssse3; +#endif + raid_recX_ssse3(5, id, ip, nd, size, v); } SPEED_STOP printf("%8" PRIu64, ds / dt); + fflush(stdout); } #endif #ifdef CONFIG_AVX2 if (raid_cpu_has_avx2()) { SPEED_START { - for (j = 0; j < nd; ++j) - raid_recX_avx2(5, id, ip, nd, size, v); + /* ensure to use same hardware in the delta step */ +#ifdef CONFIG_X86_64 + raid_gen_ptr[4] = raid_gen5_avx2ext; +#else + raid_gen_ptr[4] = raid_gen5_ssse3; +#endif + raid_recX_avx2(5, id, ip, nd, size, v); } SPEED_STOP printf("%8" PRIu64, ds / dt); + fflush(stdout); } #endif #endif @@ -903,8 +977,9 @@ fflush(stdout); SPEED_START { - for (j = 0; j < nd; ++j) - raid_recX_int8(6, id, ip, nd, size, v); + /* ensure to use same hardware in the delta step */ + raid_gen_ptr[5] = raid_gen6_int8; + raid_recX_int8(6, id, ip, nd, size, v); } SPEED_STOP printf("%8" PRIu64, ds / dt); @@ -914,21 +989,33 @@ #ifdef CONFIG_SSSE3 if (raid_cpu_has_ssse3()) { SPEED_START { - for (j = 0; j < nd; ++j) - raid_recX_ssse3(6, id, ip, nd, size, v); + /* ensure to use same hardware in the delta step */ +#ifdef CONFIG_X86_64 + raid_gen_ptr[5] = raid_gen6_ssse3ext; +#else + raid_gen_ptr[5] = raid_gen6_ssse3; +#endif + raid_recX_ssse3(6, id, ip, nd, size, v); } SPEED_STOP printf("%8" PRIu64, ds / dt); + fflush(stdout); } #endif #ifdef CONFIG_AVX2 if (raid_cpu_has_avx2()) { SPEED_START { - for (j = 0; j < nd; ++j) - raid_recX_avx2(6, id, ip, nd, size, v); + /* ensure to use same hardware in the delta step */ +#ifdef CONFIG_X86_64 + raid_gen_ptr[5] = raid_gen6_avx2ext; +#else + raid_gen_ptr[5] = raid_gen6_ssse3; +#endif + raid_recX_avx2(6, id, ip, nd, size, v); } SPEED_STOP printf("%8" PRIu64, ds / dt); + fflush(stdout); } #endif #endif diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/snapraid-14.2/cmdline/util.c new/snapraid-14.3/cmdline/util.c --- old/snapraid-14.2/cmdline/util.c 2026-04-09 17:56:49.000000000 +0200 +++ new/snapraid-14.3/cmdline/util.c 2026-04-15 18:50:46.000000000 +0200 @@ -562,6 +562,13 @@ * Overwrites B contents with C's high 64 bits. */ #if defined(__x86_64__) || defined(_M_X64) +/* + * This is intentionally placed before the __SIZEOF_INT128__ implementation. + * + * This implementation happens to generate more efficient code. + * While this likely depends only on the compiler, as long as it remains faster, + * we will keep it in this order. + */ static inline void util_mum(uint64_t* A, uint64_t* B) { uint64_t a = *A; @@ -578,7 +585,38 @@ *A = low; *B = high; } +#elif defined(__SIZEOF_INT128__) +static inline void util_mum(uint64_t* A, uint64_t* B) +{ + __uint128_t product = ((__uint128_t)*A) * ((__uint128_t)*B); + *A = (uint64_t)product; + *B = (uint64_t)(product >> 64); +} #elif defined(__aarch64__) || defined(_M_ARM64) +/* + * This is intentionally placed after the __SIZEOF_INT128__ implementation. + * + * Although the code looks correct, there is a report of this + * implementation failing the self-test on macOS (Darwin 25.4.0, arm64) + * with Apple clang 21.0.0 (clang-2100.0.123.102). + * + * See: https://github.com/amadvance/snapraid/issues/43 + * + * Note that the implementation is the same of OpenSSL: + * + * #elif defined(__aarch64__) && defined(SIXTY_FOUR_BIT_LONG) + * #if defined(__GNUC__) && __GNUC__ >= 2 + * #define BN_UMULT_HIGH(a, b) ({ \ + * register BN_ULONG ret; \ + * asm ("umulh %0,%1,%2" \ + * : "=r"(ret) \ + * : "r"(a), "r"(b)); \ + * ret; }) + * #endif + * #endif + * + * See: https://github.com/openssl/openssl/blob/0463cbf185680e66a3a8960f10cd33001377d28e/crypto/bn/bn_local.h#L439 + */ static inline void util_mum(uint64_t* A, uint64_t* B) { uint64_t a = *A; @@ -593,13 +631,6 @@ *A = low; *B = high; } -#elif defined(__SIZEOF_INT128__) -static inline void util_mum(uint64_t* A, uint64_t* B) -{ - __uint128_t product = ((__uint128_t)*A) * ((__uint128_t)*B); - *A = (uint64_t)product; - *B = (uint64_t)(product >> 64); -} #else static inline void util_mum(uint64_t* A, uint64_t* B) { diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/snapraid-14.2/configure new/snapraid-14.3/configure --- old/snapraid-14.2/configure 2026-04-09 23:38:53.000000000 +0200 +++ new/snapraid-14.3/configure 2026-04-16 14:32:22.000000000 +0200 @@ -1,6 +1,6 @@ #! /bin/sh # Guess values for system-dependent variables and create Makefiles. -# Generated by GNU Autoconf 2.72 for SnapRAID CLI 14.2. +# Generated by GNU Autoconf 2.72 for SnapRAID CLI 14.3. # # # Copyright (C) 1992-1996, 1998-2017, 2020-2023 Free Software Foundation, @@ -600,8 +600,8 @@ # Identity of this package. PACKAGE_NAME='SnapRAID CLI' PACKAGE_TARNAME='snapraid' -PACKAGE_VERSION='14.2' -PACKAGE_STRING='SnapRAID CLI 14.2' +PACKAGE_VERSION='14.3' +PACKAGE_STRING='SnapRAID CLI 14.3' PACKAGE_BUGREPORT='' PACKAGE_URL='https://www.snapraid.it' @@ -1336,7 +1336,7 @@ # Omit some internal or obsolete options to make the list less imposing. # This message is too long to be a string in the A/UX 3.1 sh. cat <<_ACEOF -'configure' configures SnapRAID CLI 14.2 to adapt to many kinds of systems. +'configure' configures SnapRAID CLI 14.3 to adapt to many kinds of systems. Usage: $0 [OPTION]... [VAR=VALUE]... @@ -1407,7 +1407,7 @@ if test -n "$ac_init_help"; then case $ac_init_help in - short | recursive ) echo "Configuration of SnapRAID CLI 14.2:";; + short | recursive ) echo "Configuration of SnapRAID CLI 14.3:";; esac cat <<\_ACEOF @@ -1530,7 +1530,7 @@ test -n "$ac_init_help" && exit $ac_status if $ac_init_version; then cat <<\_ACEOF -SnapRAID CLI configure 14.2 +SnapRAID CLI configure 14.3 generated by GNU Autoconf 2.72 Copyright (C) 2023 Free Software Foundation, Inc. @@ -2116,7 +2116,7 @@ This file contains any messages produced by compilers while running configure, to aid debugging if configure makes a mistake. -It was created by SnapRAID CLI $as_me 14.2, which was +It was created by SnapRAID CLI $as_me 14.3, which was generated by GNU Autoconf 2.72. Invocation command line was $ $0$ac_configure_args_raw @@ -3415,7 +3415,7 @@ # Define the identity of the package. PACKAGE='snapraid' - VERSION='14.2' + VERSION='14.3' printf "%s\n" "#define PACKAGE \"$PACKAGE\"" >>confdefs.h @@ -9204,7 +9204,7 @@ # report actual input values of CONFIG_FILES etc. instead of their # values after options handling. ac_log=" -This file was extended by SnapRAID CLI $as_me 14.2, which was +This file was extended by SnapRAID CLI $as_me 14.3, which was generated by GNU Autoconf 2.72. Invocation command line was CONFIG_FILES = $CONFIG_FILES @@ -9269,7 +9269,7 @@ cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_cs_config='$ac_cs_config_escaped' ac_cs_version="\\ -SnapRAID CLI config.status 14.2 +SnapRAID CLI config.status 14.3 configured by $0, generated by GNU Autoconf 2.72, with options \\"\$ac_cs_config\\" diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/snapraid-14.2/raid/check.c new/snapraid-14.3/raid/check.c --- old/snapraid-14.2/raid/check.c 2026-04-09 17:56:49.000000000 +0200 +++ new/snapraid-14.3/raid/check.c 2026-04-15 18:50:47.000000000 +0200 @@ -11,7 +11,7 @@ * This function checks if the specified failed blocks satisfy the redundancy * information using the data from the known valid parity blocks. * - * It's similar at raid_check(), just with a different format for arguments. + * It's similar to raid_check(), just with a different format for arguments. * * The number of failed blocks @nr must be strictly less than the number of * parities @nv, because you need one more parity to validate the recovering. @@ -25,7 +25,7 @@ * @ip[] Vector of @nv indexes of the valid parity blocks. * The indexes start from 0. They must be in order. * @nd Number of data blocks. - * @size Size of the blocks pointed by @v. It must be a multiplier of 64. + * @size Size of the blocks pointed by @v. It must be a multiple of 64. * @v Vector of pointers to the blocks of data and parity. * It has (@nd + @ip[@nv - 1] + 1) elements. The starting elements are the * blocks for data, following with the parity blocks. diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/snapraid-14.2/raid/combo.h new/snapraid-14.3/raid/combo.h --- old/snapraid-14.2/raid/combo.h 2026-04-09 17:56:49.000000000 +0200 +++ new/snapraid-14.3/raid/combo.h 2026-04-15 18:50:47.000000000 +0200 @@ -9,7 +9,7 @@ /** * Get the first permutation with repetition of r of n elements. * - * Typical use is with permutation_next() in the form : + * Typical use is with permutation_next() in the form: * * int i[R]; * permutation_first(R, N, i); @@ -17,7 +17,7 @@ * code using i[0], i[1], ..., i[R-1] * } while (permutation_next(R, N, i)); * - * It's equivalent at the code : + * It's equivalent to the code: * * for(i[0]=0;i[0]<N;++i[0]) * for(i[1]=0;i[1]<N;++i[1]) @@ -75,7 +75,7 @@ /** * Get the first combination without repetition of r of n elements. * - * Typical use is with combination_next() in the form : + * Typical use is with combination_next() in the form: * * int i[R]; * combination_first(R, N, i); @@ -83,7 +83,7 @@ * code using i[0], i[1], ..., i[R-1] * } while (combination_next(R, N, i)); * - * It's equivalent at the code : + * It's equivalent to the code: * * for(i[0]=0;i[0]<N-(R-1);++i[0]) * for(i[1]=i[0]+1;i[1]<N-(R-2);++i[1]) @@ -133,7 +133,7 @@ /* initialize all the next positions, if any */ while (i < r) { - /* each position start at the next value of the previous one */ + /* each position starts at the next value of the previous one */ c[i] = c[i - 1] + 1; ++i; } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/snapraid-14.2/raid/cpu.h new/snapraid-14.3/raid/cpu.h --- old/snapraid-14.2/raid/cpu.h 2026-04-09 17:56:49.000000000 +0200 +++ new/snapraid-14.3/raid/cpu.h 2026-04-16 09:56:03.000000000 +0200 @@ -30,7 +30,7 @@ asm volatile ( /* uses a direct encoding of the XGETBV instruction as only recent */ /* assemblers support it. */ - /* the next line is equivalent at: "xgetbv\n" */ + /* the next line is equivalent to: "xgetbv\n" */ ".byte 0x0f, 0x01, 0xd0\n" : "=a" (reg[0]), "=d" (reg[3]) : "c" (0) @@ -85,7 +85,7 @@ return 1; } -static inline int raid_cpu_match_avx(uint32_t cpuid_1_ecx, uint32_t cpuid_7_ebx, uint32_t xcr0) +static inline int raid_cpu_match_avx(uint32_t cpuid_1_ecx, uint32_t cpuid_7_ebx, uint32_t cpuid_7_ecx, uint32_t xcr0) { uint32_t reg[4]; @@ -101,6 +101,9 @@ if ((reg[1] & cpuid_7_ebx) != cpuid_7_ebx) return 0; + if ((reg[2] & cpuid_7_ecx) != cpuid_7_ecx) + return 0; + return 1; } @@ -114,7 +117,7 @@ * Before an application attempts to use the SSE and/or SSE2 extensions, it should check * that they are present on the processor: * 1. Check that the processor supports the CPUID instruction. Bit 21 of the EFLAGS - * register can be used to check processor's support the CPUID instruction. + * register can be used to check if the processor supports the CPUID instruction. * 2. Check that the processor supports the SSE and/or SSE2 extensions (true if * CPUID.01H:EDX.SSE[bit 25] = 1 and/or CPUID.01H:EDX.SSE2[bit 26] = 1). */ @@ -174,9 +177,10 @@ * also detect support for AVX2 by checking CPUID.(EAX=07H, ECX=0H):EBX.AVX2[bit 5]. */ return raid_cpu_match_avx( - (1 << 27) | (1 << 28), /* OSXSAVE and AVX */ - 1 << 5, /* AVX2 */ - 3 << 1); /* OS saves XMM and YMM registers */ + (1 << 27) | (1 << 28), /* Leaf 1, ECX: XSAVE and AVX */ + 1 << 5, /* Leaf 7, EBX: AVX2 */ + 0, /* Leaf 7, ECX: */ + 3 << 1); /* XCR0: OS saves XMM and YMM registers */ } static inline int raid_cpu_has_avx512bw(void) @@ -196,9 +200,20 @@ /* note that intentionally we don't check for AVX and AVX2 */ /* because the documentation doesn't require that */ return raid_cpu_match_avx( - 1 << 27, /* XSAVE/XGETBV */ - (1 << 16) | (1 << 30), /* AVX512F and AVX512BW */ - (3 << 1) | (7 << 5)); /* OS saves XMM, YMM and ZMM registers */ + 1 << 27, /* Leaf 1, ECX: XSAVE/XGETBV */ + (1 << 16) | (1 << 30), /* Leaf 7, EBX: AVX512F and AVX512BW */ + 0, /* Leaf 7, ECX: */ + (3 << 1) | (7 << 5)); /* XCR0: OS saves XMM, YMM and ZMM registers */ +} + +static inline int raid_cpu_has_avx512gfni(void) +{ + return raid_cpu_match_avx( + 1 << 27, /* Leaf 1, ECX: XSAVE/XGETBV */ + 1 << 16, /* Leaf 7, EBX: AVX512F (Foundation) */ + 1 << 8, /* Leaf 7, ECX: GFNI */ + (3 << 1) | (7 << 5) /* XCR0: OS saves XMM, YMM and ZMM registers */ + ); } /** @@ -266,7 +281,7 @@ /** * Check if the processor has a slow extended set of SSE registers. - * If yes, it's better to limit the unroll to the firsrt 8 registers. + * If yes, it's better to limit the unrolling to the first 8 registers. */ static inline int raid_cpu_has_slowextendedreg(void) { diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/snapraid-14.2/raid/int.c new/snapraid-14.3/raid/int.c --- old/snapraid-14.2/raid/int.c 2026-04-09 17:56:49.000000000 +0200 +++ new/snapraid-14.3/raid/int.c 2026-04-16 14:20:32.000000000 +0200 @@ -384,7 +384,7 @@ (void)nr; /* unused, it's always 1 */ - /* if it's RAID5 uses the faster function */ + /* if it's RAID5, use the faster function */ if (ip[0] == 0) { raid_rec1of1(id, nd, size, vv); return; @@ -441,7 +441,7 @@ (void)nr; /* unused, it's always 2 */ - /* if it's RAID6 recovering with P and Q uses the faster function */ + /* if it's RAID6, recovering with P and Q uses the faster function */ if (ip[0] == 0 && ip[1] == 1) { raid_rec2of2_int8(id, ip, nd, size, vv); return; @@ -489,7 +489,7 @@ * * we solve inverting the coefficients matrix. * - * Note that referring at previous equations you have: + * Note that referring to previous equations you have: * PD[0] = Pd, PD[1] = Qd, PD[2] = Rd, ... * D[0] = Dx, D[1] = Dy, D[2] = Dz, ... */ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/snapraid-14.2/raid/memory.h new/snapraid-14.3/raid/memory.h --- old/snapraid-14.2/raid/memory.h 2026-04-09 17:56:49.000000000 +0200 +++ new/snapraid-14.3/raid/memory.h 2026-04-15 18:50:47.000000000 +0200 @@ -22,7 +22,7 @@ * end. * * To avoid this effect, it's better if all the blocks are allocated - * with a fixed displacement trying to reduce the cache addresses sharing. + * with a fixed displacement trying to reduce the cache address sharing. * * The selected displacement was chosen empirically with some speed tests * with 8/12/16/20/24 data buffers of 256 KB. @@ -34,7 +34,7 @@ * gen2 6814 [MB/s] * genz 3033 [MB/s] * - * These are the results with displacement resulting in improvements + * These are the results with displacement, resulting in improvements * in the order of 20% or more: * * sse2 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/snapraid-14.2/raid/raid.c new/snapraid-14.3/raid/raid.c --- old/snapraid-14.2/raid/raid.c 2026-04-09 17:56:49.000000000 +0200 +++ new/snapraid-14.3/raid/raid.c 2026-04-16 14:20:32.000000000 +0200 @@ -363,7 +363,7 @@ } else { /* * Unused parities are going to be rewritten with - * not significative data, because we don't have + * not significant data, because we don't have * functions able to compute only a subset of * parities. * diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/snapraid-14.2/raid/raid.h new/snapraid-14.3/raid/raid.h --- old/snapraid-14.2/raid/raid.h 2026-04-09 17:56:49.000000000 +0200 +++ new/snapraid-14.3/raid/raid.h 2026-04-15 18:50:47.000000000 +0200 @@ -83,7 +83,7 @@ * * @nd Number of data blocks. * @np Number of parities blocks to compute. - * @size Size of the blocks pointed by @v. It must be a multiplier of 64. + * @size Size of the blocks pointed by @v. It must be a multiple of 64. * @v Vector of pointers to the blocks of data and parity. * It has (@nd + @np) elements. The starting elements are the blocks for * data, following with the parity blocks. @@ -119,7 +119,7 @@ * @nd + 1, just like positions in the @v vector. * @nd Number of data blocks. * @np Number of parity blocks. - * @size Size of the blocks pointed by @v. It must be a multiplier of 64. + * @size Size of the blocks pointed by @v. It must be a multiple of 64. * @v Vector of pointers to the blocks of data and parity. * It has (@nd + @np) elements. The starting elements are the blocks * for data, following with the parity blocks. @@ -139,7 +139,7 @@ * @ip[] Vector of @nr indexes of the parity blocks to use for recovering. * The indexes start from 0. They must be in order. * @nd Number of data blocks. - * @size Size of the blocks pointed by @v. It must be a multiplier of 64. + * @size Size of the blocks pointed by @v. It must be a multiple of 64. * @v Vector of pointers to the blocks of data and parity. * It has (@nd + @ip[@nr - 1] + 1) elements. The starting elements are the * blocks for data, following with the parity blocks. @@ -166,7 +166,7 @@ * @nd + 1, just like positions in the @v vector. * @nd Number of data blocks. * @np Number of parity blocks. - * @size Size of the blocks pointed by @v. It must be a multiplier of 64. + * @size Size of the blocks pointed by @v. It must be a multiple of 64. * @v Vector of pointers to the blocks of data and parity. * It has (@nd + @np) elements. The starting elements are the blocks * for data, following with the parity blocks. @@ -182,7 +182,7 @@ * available redundancy. * * It uses a brute force method, and then the call can be expensive. - * The expected execution time is proportional at the binomial coefficient + * The expected execution time is proportional to the binomial coefficient * @np + @nd choose @np - 1, usually written as: * * ( @np + @nd ) @@ -203,7 +203,7 @@ * @nd + 1, just like positions in the @v vector. * @nd Number of data blocks. * @np Number of parity blocks. - * @size Size of the blocks pointed by @v. It must be a multiplier of 64. + * @size Size of the blocks pointed by @v. It must be a multiple of 64. * @v Vector of pointers to the blocks of data and parity. * It has (@nd + @np) elements. The starting elements are the blocks * for data, following with the parity blocks. diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/snapraid-14.2/raid/test.h new/snapraid-14.3/raid/test.h --- old/snapraid-14.2/raid/test.h 2026-04-09 17:56:49.000000000 +0200 +++ new/snapraid-14.3/raid/test.h 2026-04-15 18:50:47.000000000 +0200 @@ -7,7 +7,7 @@ /** * Tests insertion function. * - * Test raid_insert() with all the possible combinations of elements to insert. + * Tests raid_insert() with all the possible combinations of elements to insert. * * Returns 0 on success. */ @@ -16,7 +16,7 @@ /** * Tests sorting function. * - * Test raid_sort() with all the possible combinations of elements to sort. + * Tests raid_sort() with all the possible combinations of elements to sort. * * Returns 0 on success. */ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/snapraid-14.2/raid/x86.c new/snapraid-14.3/raid/x86.c --- old/snapraid-14.2/raid/x86.c 2026-04-02 15:55:53.000000000 +0200 +++ new/snapraid-14.3/raid/x86.c 2026-04-16 14:20:32.000000000 +0200 @@ -326,7 +326,7 @@ asm volatile ("movdqa %0,%%xmm7" : : "m" (gfconst16.low4[0])); for (i = 0; i < size; i += 16) { - /* last disk without the by two multiplication */ + /* last disk without the multiplication by two */ asm volatile ("movdqa %0,%%xmm4" : : "m" (v[l][i])); asm volatile ("movdqa %xmm4,%xmm0");
