=== Applying patches on top of PostgreSQL commit ID 7c872849407730fa01e2c13b2d47483bc3ff6e7e === /etc/rc.d/jail: WARNING: Per-jail configuration via jail_* variables is obsolete. Please consider migrating to /etc/jail.conf. Tue Apr 15 19:03:19 UTC 2025 On branch cf/5538 nothing to commit, working tree clean === using 'git am' to apply patch ./v4-0001-SVE-support-for-hex-encode-and-hex-decode.patch === Applying: SVE support for hex encode and hex decode Using index info to reconstruct a base tree... M config/c-compiler.m4 M configure M configure.ac M meson.build M src/include/pg_config.h.in Falling back to patching base and 3-way merge... Auto-merging src/include/pg_config.h.in Auto-merging meson.build CONFLICT (content): Merge conflict in meson.build Auto-merging configure.ac CONFLICT (content): Merge conflict in configure.ac Auto-merging configure CONFLICT (content): Merge conflict in configure Auto-merging config/c-compiler.m4 CONFLICT (content): Merge conflict in config/c-compiler.m4 error: Failed to merge in the changes. hint: Use 'git am --show-current-patch=diff' to see the failed patch Patch failed at 0001 SVE support for hex encode and hex decode When you have resolved this problem, run "git am --continue". If you prefer to skip this patch, run "git am --skip" instead. To restore the original branch and stop patching, run "git am --abort". Unstaged changes after reset: M config/c-compiler.m4 M configure M configure.ac M meson.build M src/backend/utils/adt/encode.c M src/include/pg_config.h.in M src/include/utils/builtins.h === using patch(1) to apply patch ./v4-0001-SVE-support-for-hex-encode-and-hex-decode.patch === patching file config/c-compiler.m4 Hunk #1 FAILED at 704. 1 out of 1 hunk FAILED -- saving rejects to file config/c-compiler.m4.rej patching file configure Hunk #1 succeeded at 17810 (offset 642 lines). patching file configure.ac Hunk #1 succeeded at 2094 (offset 73 lines). patching file meson.build Hunk #1 succeeded at 2367 (offset 173 lines). patching file src/backend/utils/adt/encode.c patching file src/include/pg_config.h.in Hunk #1 succeeded at 671 (offset 23 lines). patching file src/include/utils/builtins.h Unstaged changes after reset: M configure M configure.ac M meson.build M src/backend/utils/adt/encode.c M src/include/pg_config.h.in M src/include/utils/builtins.h Removing config/c-compiler.m4.rej === using 'git apply' to apply patch ./v4-0001-SVE-support-for-hex-encode-and-hex-decode.patch === Applied patch to 'config/c-compiler.m4' with conflicts. Applied patch to 'configure' with conflicts. Applied patch to 'configure.ac' with conflicts. Applied patch to 'meson.build' with conflicts. Applied patch to 'src/backend/utils/adt/encode.c' cleanly. Applied patch to 'src/include/pg_config.h.in' cleanly. Applied patch to 'src/include/utils/builtins.h' cleanly. U config/c-compiler.m4 U configure U configure.ac U meson.build diff --cc config/c-compiler.m4 index 5f3e1d1faf9,d99ecfb2a74..00000000000 --- a/config/c-compiler.m4 +++ b/config/c-compiler.m4 @@@ -746,54 -705,60 +746,114 @@@ f undefine([Ac_cachevar])dnl ])# PGAC_AVX512_POPCNT_INTRINSICS ++<<<<<<< ours +# PGAC_SVE_POPCNT_INTRINSICS +# -------------------------- +# Check if the compiler supports the SVE popcount instructions using the +# svptrue_b64, svdup_u64, svcntb, svld1_u64, svld1_u8, svadd_u64_x, +# svcnt_u64_x, svcnt_u8_x, svaddv_u64, svaddv_u8, svwhilelt_b8_s32, +# svand_n_u64_x, and svand_n_u8_x intrinsic functions. +# +# If the intrinsics are supported, sets pgac_sve_popcnt_intrinsics. +AC_DEFUN([PGAC_SVE_POPCNT_INTRINSICS], +[define([Ac_cachevar], [AS_TR_SH([pgac_cv_sve_popcnt_intrinsics])])dnl +AC_CACHE_CHECK([for svcnt_x], [Ac_cachevar], +[AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include + + char buf[128]; + + #if defined(__has_attribute) && __has_attribute (target) + __attribute__((target("arch=armv8-a+sve"))) + #endif + static int popcount_test(void) + { + svbool_t pred = svptrue_b64(); + svuint8_t vec8; + svuint64_t accum1 = svdup_u64(0), + accum2 = svdup_u64(0), + vec64; + char *p = buf; + uint64_t popcnt, + mask = 0x5555555555555555; + + vec64 = svand_n_u64_x(pred, svld1_u64(pred, (const uint64_t *) p), mask); + accum1 = svadd_u64_x(pred, accum1, svcnt_u64_x(pred, vec64)); + p += svcntb(); + + vec64 = svand_n_u64_x(pred, svld1_u64(pred, (const uint64_t *) p), mask); + accum2 = svadd_u64_x(pred, accum2, svcnt_u64_x(pred, vec64)); + p += svcntb(); + + popcnt = svaddv_u64(pred, svadd_u64_x(pred, accum1, accum2)); + + pred = svwhilelt_b8_s32(0, sizeof(buf)); + vec8 = svand_n_u8_x(pred, svld1_u8(pred, (const uint8_t *) p), 0x55); + return (int) (popcnt + svaddv_u8(pred, svcnt_u8_x(pred, vec8))); + }]], + [return popcount_test();])], + [Ac_cachevar=yes], + [Ac_cachevar=no])]) +if test x"$Ac_cachevar" = x"yes"; then + pgac_sve_popcnt_intrinsics=yes +fi +undefine([Ac_cachevar])dnl +])# PGAC_SVE_POPCNT_INTRINSICS ++======= + # PGAC_ARM_SVE_HEX_INTRINSICS + # ------------------------------ + # Check if the compiler supports the ARM SVE intrinsic required for hex coding: + # svtbl, svlsr_x, svand_z, svcreate2, etc. + # + # If the intrinsics are supported, sets pgac_arm_sve_hex_intrinsics. + AC_DEFUN([PGAC_ARM_SVE_HEX_INTRINSICS], + [define([Ac_cachevar], [AS_TR_SH([pgac_cv_arm_sve_hex_intrinsics])])dnl + AC_CACHE_CHECK([for svtbl, svlsr_x, svand_z, svcreate2, etc], [Ac_cachevar], + [AC_LINK_IFELSE([AC_LANG_PROGRAM([#include + #if defined(__has_attribute) && __has_attribute (target) + __attribute__((target("arch=armv8-a+sve"))) + #endif + static int hex_coding_test(void) + { + int vec_len = svcntb(); + char input@<:@32@:>@; + char output@<:@32@:>@; + svbool_t pred = svptrue_b8(), cmp1, cmp2; + svuint8_t bytes, hextbl_vec; + svuint8x2_t merged; + + if (vec_len >= 16) + { + /* intrinsics used in hex_encode_sve */ + hextbl_vec = svld1(svwhilelt_b8(0, 16), (uint8_t *) "0123456789ABCDEF"); + bytes = svld1(pred, (uint8_t *) input); + bytes = svlsr_x(pred, bytes, 4); + bytes = svand_x(pred, bytes, 0xF); + merged = svcreate2(svtbl(hextbl_vec, bytes), svtbl(hextbl_vec, bytes)); + svst2(pred, (uint8_t *) output, merged); + + /* intrinsics used in hex_decode_sve */ + bytes = svget2(svld2(pred, (uint8_t *) output), 0); + bytes = svsub_x(pred, bytes, 48); + cmp1 = svcmplt(pred, bytes, 16); + cmp2 = svcmpgt(pred, bytes, 9); + if (svptest_any(pred, svnot_z(pred, svorr_z(pred, cmp1, cmp2)))) + return 0; + bytes = svsel(svand_z(pred, cmp1, cmp2), bytes, bytes); + bytes = svlsl_x(pred, bytes, svcntp_b8(pred, pred)); + svst1(pred, output, bytes); + + /* return computed value, to prevent the above being optimized away */ + return output@<:@0@:>@ == 0; + } + + return 0; + }], + [return hex_coding_test();])], + [Ac_cachevar=yes], + [Ac_cachevar=no])]) + if test x"$Ac_cachevar" = x"yes"; then + pgac_arm_sve_hex_intrinsics=yes + fi + undefine([Ac_cachevar])dnl + ])# PGAC_ARM_SVE_HEX_INTRINSICS ++>>>>>>> theirs diff --cc configure index 0936010718d,e445cb14518..00000000000 --- a/configure +++ b/configure @@@ -17739,73 -17168,81 +17739,146 @@@ $as_echo "#define USE_AVX512_POPCNT_WIT fi fi ++<<<<<<< ours +# Check for SVE popcount intrinsics +# +if test x"$host_cpu" = x"aarch64"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for svcnt_x" >&5 +$as_echo_n "checking for svcnt_x... " >&6; } +if ${pgac_cv_sve_popcnt_intrinsics+:} false; then : ++======= + # Check for ARM SVE intrinsics for hex coding + # + if test x"$host_cpu" = x"aarch64"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for svtbl, svlsr_z, svand_z, svcreate2, etc" >&5 + $as_echo_n "checking for svtbl, svlsr_z, svand_z, svcreate2, etc... " >&6; } + if ${pgac_cv_arm_sve_hex_intrinsics+:} false; then : ++>>>>>>> theirs $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include ++<<<<<<< ours + + char buf[128]; + + #if defined(__has_attribute) && __has_attribute (target) + __attribute__((target("arch=armv8-a+sve"))) + #endif + static int popcount_test(void) + { + svbool_t pred = svptrue_b64(); + svuint8_t vec8; + svuint64_t accum1 = svdup_u64(0), + accum2 = svdup_u64(0), + vec64; + char *p = buf; + uint64_t popcnt, + mask = 0x5555555555555555; + + vec64 = svand_n_u64_x(pred, svld1_u64(pred, (const uint64_t *) p), mask); + accum1 = svadd_u64_x(pred, accum1, svcnt_u64_x(pred, vec64)); + p += svcntb(); + + vec64 = svand_n_u64_x(pred, svld1_u64(pred, (const uint64_t *) p), mask); + accum2 = svadd_u64_x(pred, accum2, svcnt_u64_x(pred, vec64)); + p += svcntb(); + + popcnt = svaddv_u64(pred, svadd_u64_x(pred, accum1, accum2)); + + pred = svwhilelt_b8_s32(0, sizeof(buf)); + vec8 = svand_n_u8_x(pred, svld1_u8(pred, (const uint8_t *) p), 0x55); + return (int) (popcnt + svaddv_u8(pred, svcnt_u8_x(pred, vec8))); + } +int +main () +{ +return popcount_test(); ++======= + #if defined(__has_attribute) && __has_attribute (target) + __attribute__((target("arch=armv8-a+sve"))) + #endif + static int hex_coding_test(void) + { + int vec_len = svcntb(); + char input[32]; + char output[32]; + svbool_t pred = svptrue_b8(), cmp1, cmp2; + svuint8_t bytes, hextbl_vec; + svuint8x2_t merged; + + if (vec_len >= 16) + { + /* intrinsics used in hex_encode_sve */ + hextbl_vec = svld1(svwhilelt_b8(0, 16), (uint8_t *) "0123456789ABCDEF"); + bytes = svld1(pred, (uint8_t *) input); + bytes = svlsr_x(pred, bytes, 4); + bytes = svand_x(pred, bytes, 0xF); + merged = svcreate2(svtbl(hextbl_vec, bytes), svtbl(hextbl_vec, bytes)); + svst2(pred, (uint8_t *) output, merged); + + /* intrinsics used in hex_decode_sve */ + bytes = svget2(svld2(pred, (uint8_t *) output), 0); + bytes = svsub_x(pred, bytes, 48); + cmp1 = svcmplt(pred, bytes, 16); + cmp2 = svcmpgt(pred, bytes, 9); + if (svptest_any(pred, svnot_z(pred, svorr_z(pred, cmp1, cmp2)))) + return 0; + bytes = svsel(svand_z(pred, cmp1, cmp2), bytes, bytes); + bytes = svlsl_x(pred, bytes, svcntp_b8(pred, pred)); + svst1(pred, output, bytes); + + /* return computed value, to prevent the above being optimized away */ + return output[0] == 0; + } + + return 0; + } + int + main () + { + return hex_coding_test(); ++>>>>>>> theirs ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO"; then : ++<<<<<<< ours + pgac_cv_sve_popcnt_intrinsics=yes +else + pgac_cv_sve_popcnt_intrinsics=no ++======= + pgac_cv_arm_sve_hex_intrinsics=yes + else + pgac_cv_arm_sve_hex_intrinsics=no ++>>>>>>> theirs fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext fi ++<<<<<<< ours +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $pgac_cv_sve_popcnt_intrinsics" >&5 +$as_echo "$pgac_cv_sve_popcnt_intrinsics" >&6; } +if test x"$pgac_cv_sve_popcnt_intrinsics" = x"yes"; then + pgac_sve_popcnt_intrinsics=yes +fi + + if test x"$pgac_sve_popcnt_intrinsics" = x"yes"; then + +$as_echo "#define USE_SVE_POPCNT_WITH_RUNTIME_CHECK 1" >>confdefs.h ++======= + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $pgac_cv_arm_sve_hex_intrinsics" >&5 + $as_echo "$pgac_cv_arm_sve_hex_intrinsics" >&6; } + if test x"$pgac_cv_arm_sve_hex_intrinsics" = x"yes"; then + pgac_arm_sve_hex_intrinsics=yes + fi + + if test x"$pgac_arm_sve_hex_intrinsics" = x"yes"; then + + $as_echo "#define USE_SVE_WITH_RUNTIME_CHECK 1" >>confdefs.h ++>>>>>>> theirs fi fi diff --cc configure.ac index 2a78cddd825,2dbb678cae5..00000000000 --- a/configure.ac +++ b/configure.ac @@@ -2085,12 -2021,12 +2085,21 @@@ if test x"$host_cpu" = x"x86_64"; the fi fi ++<<<<<<< ours +# Check for SVE popcount intrinsics +# +if test x"$host_cpu" = x"aarch64"; then + PGAC_SVE_POPCNT_INTRINSICS() + if test x"$pgac_sve_popcnt_intrinsics" = x"yes"; then + AC_DEFINE(USE_SVE_POPCNT_WITH_RUNTIME_CHECK, 1, [Define to 1 to use SVE popcount instructions with a runtime check.]) ++======= + # Check for ARM SVE intrinsics for hex coding + # + if test x"$host_cpu" = x"aarch64"; then + PGAC_ARM_SVE_HEX_INTRINSICS() + if test x"$pgac_arm_sve_hex_intrinsics" = x"yes"; then + AC_DEFINE(USE_SVE_WITH_RUNTIME_CHECK, 1, [Define to 1 to use ARM SVE intrinsic for hex coding.]) ++>>>>>>> theirs fi fi diff --cc meson.build index a1516e54529,6a10331acf0..00000000000 --- a/meson.build +++ b/meson.build @@@ -2320,48 -2195,56 +2320,98 @@@ endi ############################################################### ++<<<<<<< ours +# Check for the availability of SVE popcount intrinsics. ++======= + # Check the availability of ARM SVE intrinsics for hex coding. ++>>>>>>> theirs ############################################################### if host_cpu == 'aarch64' prog = ''' #include ++<<<<<<< ours + +char buf[128]; + +#if defined(__has_attribute) && __has_attribute (target) +__attribute__((target("arch=armv8-a+sve"))) +#endif +int main(void) +{ + svbool_t pred = svptrue_b64(); + svuint8_t vec8; + svuint64_t accum1 = svdup_u64(0), + accum2 = svdup_u64(0), + vec64; + char *p = buf; + uint64_t popcnt, + mask = 0x5555555555555555; + + vec64 = svand_n_u64_x(pred, svld1_u64(pred, (const uint64_t *) p), mask); + accum1 = svadd_u64_x(pred, accum1, svcnt_u64_x(pred, vec64)); + p += svcntb(); + + vec64 = svand_n_u64_x(pred, svld1_u64(pred, (const uint64_t *) p), mask); + accum2 = svadd_u64_x(pred, accum2, svcnt_u64_x(pred, vec64)); + p += svcntb(); + + popcnt = svaddv_u64(pred, svadd_u64_x(pred, accum1, accum2)); + + pred = svwhilelt_b8_s32(0, sizeof(buf)); + vec8 = svand_n_u8_x(pred, svld1_u8(pred, (const uint8_t *) p), 0x55); + return (int) (popcnt + svaddv_u8(pred, svcnt_u8_x(pred, vec8))); +} +''' + + if cc.links(prog, name: 'SVE popcount', args: test_c_args) + cdata.set('USE_SVE_POPCNT_WITH_RUNTIME_CHECK', 1) ++======= + #if defined(__has_attribute) && __has_attribute (target) + __attribute__((target("arch=armv8-a+sve"))) + #endif + int main(void) + { + int vec_len = svcntb(); + char input[64] = {0}; + char output[64] = {0}; + svbool_t pred = svptrue_b8(), cmp1, cmp2; + svuint8_t bytes, hextbl_vec; + svuint8x2_t merged; + + if (vec_len >= 16) + { + /* intrinsics used in hex_encode_sve */ + hextbl_vec = svld1(svwhilelt_b8(0, 16), (uint8_t *) "0123456789ABCDEF"); + bytes = svld1(pred, (uint8_t *) input); + bytes = svlsr_x(pred, bytes, 4); + bytes = svand_x(pred, bytes, 0xF); + merged = svcreate2(svtbl(hextbl_vec, bytes), svtbl(hextbl_vec, bytes)); + svst2(pred, (uint8_t *) output, merged); + + /* intrinsics used in hex_decode_sve */ + bytes = svget2(svld2(pred, (uint8_t *) output), 0); + bytes = svsub_x(pred, bytes, 48); + cmp1 = svcmplt(pred, bytes, 16); + cmp2 = svcmpgt(pred, bytes, 9); + if (svptest_any(pred, svnot_z(pred, svorr_z(pred, cmp1, cmp2)))) + return 0; + bytes = svsel(svand_z(pred, cmp1, cmp2), bytes, bytes); + bytes = svlsl_x(pred, bytes, svcntp_b8(pred, pred)); + svst1(pred, output, bytes); + + /* return computed value, to prevent the above being optimized away */ + return output[0] == 0; + } + + return 0; + } + ''' + + if cc.links(prog, name: 'ARM SVE hex coding', args: test_c_args) + cdata.set('USE_SVE_WITH_RUNTIME_CHECK', 1) ++>>>>>>> theirs endif endif