s390x/tcg: Vector Instruction Support Part 3
cover s390x/tcg: Vector Instruction Support Part 3
This is the third part of vector instruction support for s390x. It is based on part 2, which is will send a pull-request for to Conny soon.
Part 1: Vector Support Instructions
Part 2: Vector Integer Instructions
Part 3: Vector String Instructions
Part 4: Vector Floating-Point Instructions
The current state can be found at (kept updated):
https://github.com/davidhildenbrand/qemu/tree/vx
With the current state I can boot Linux kernel + user space compiled with SIMD support. This allows to boot distributions compiled exclusively for z13, requiring SIMD support. Also, it is now possible to build a complete kernel using rpmbuild as quite some issues have been sorted out.
In this part, all Vector String Instructions introduced with the "Vector Facility" are added.
David Hildenbrand (5):
s390x/tcg: Implement VECTOR FIND ANY ELEMENT EQUAL s390x/tcg: Implement VECTOR FIND ELEMENT EQUAL s390x/tcg: Implement VECTOR FIND ELEMENT NOT EQUAL s390x/tcg: Implement VECTOR ISOLATE STRING s390x/tcg: Implement VECTOR STRING RANGE COMPARE
target/s390x/Makefile.objs | 2 +- target/s390x/helper.h | 32 +++ target/s390x/insn-data.def | 13 ++ target/s390x/translate_vx.inc.c | 164 ++++++++++++++ target/s390x/vec_string_helper.c | 358 +++++++++++++++++++++++++++++++ 5 files changed, 568 insertions(+), 1 deletion(-) create mode 100644 target/s390x/vec_string_helper.c
Signature · 1 line
2.20.1
PATCH 1/5 s390x/tcg: Implement VECTOR FIND ANY ELEMENT EQUAL
Complicated stuff. Provide two variants, one for the CC and one without the CC. The CC is returned via cpu_env.
--- target/s390x/Makefile.objs | 2 +- target/s390x/helper.h | 8 +++ target/s390x/insn-data.def | 5 ++ target/s390x/translate_vx.inc.c | 31 ++++++++++ target/s390x/vec_string_helper.c | 97 ++++++++++++++++++++++++++++++++ 5 files changed, 142 insertions(+), 1 deletion(-) create mode 100644 target/s390x/vec_string_helper.c
target/s390x/Makefile.objs +1 -1
@@ -1,7 +1,7 @@ obj-y += cpu.o cpu_models.o cpu_features.o gdbstub.o interrupt.o helper.o obj-$(CONFIG_TCG) += translate.o cc_helper.o excp_helper.o fpu_helper.o obj-$(CONFIG_TCG) += int_helper.o mem_helper.o misc_helper.o crypto_helper.o -obj-$(CONFIG_TCG) += vec_helper.o vec_int_helper.o +obj-$(CONFIG_TCG) += vec_helper.o vec_int_helper.o vec_string_helper.o obj-$(CONFIG_SOFTMMU) += machine.o ioinst.o arch_dump.o mmu_helper.o diag.o obj-$(CONFIG_SOFTMMU) += sigp.o obj-$(CONFIG_KVM) += kvm.o
target/s390x/helper.h +8 -0
@@ -211,6 +211,14 @@ DEF_HELPER_FLAGS_4(gvec_vscbi8, TCG_CALL_NO_RWG, void, ptr, cptr, cptr, i32) DEF_HELPER_FLAGS_4(gvec_vscbi16, TCG_CALL_NO_RWG, void, ptr, cptr, cptr, i32)DEF_HELPER_4 (gvec_vtm, void, ptr, cptr, env, i32) +/* === Vector String Instructions === */ +DEF_HELPER_FLAGS_4(gvec_vfae8, TCG_CALL_NO_RWG, void, ptr, cptr, cptr, i32) +DEF_HELPER_FLAGS_4(gvec_vfae16, TCG_CALL_NO_RWG, void, ptr, cptr, cptr, i32) +DEF_HELPER_FLAGS_4(gvec_vfae32, TCG_CALL_NO_RWG, void, ptr, cptr, cptr, i32) +DEF_HELPER_5(gvec_vfae_cc8, void, ptr, cptr, cptr, env, i32) +DEF_HELPER_5(gvec_vfae_cc16, void, ptr, cptr, cptr, env, i32) +DEF_HELPER_5(gvec_vfae_cc32, void, ptr, cptr, cptr, env, i32) +#ifndef CONFIG_USER_ONLY DEF_HELPER_3(servc, i32, env, i64, i64)DEF_HELPER_4 (diag, void, env, i32, i32, i32)
target/s390x/insn-data.def +5 -0
@@ -1191,6 +1191,11 @@ /* VECTOR TEST UNDER MASK */ F(0xe7d8, VTM, VRR_a, V, 0, 0, 0, 0, vtm, 0, IF_VEC) +/* === Vector String Instructions === */ + +/* VECTOR FIND ANY ELEMENT EQUAL */ + F(0xe782, VFAE, VRR_b, V, 0, 0, 0, 0, vfae, 0, IF_VEC) + #ifndef CONFIG_USER_ONLY /* COMPARE AND SWAP AND PURGE */ E(0xb250, CSP, RRE, Z, r1_32u, ra2, r1_P, 0, csp, 0, MO_TEUL, IF_PRIV)
target/s390x/translate_vx.inc.c +31 -0
@@ -2353,3 +2353,34 @@ static DisasJumpType op_vtm(DisasContext *s, DisasOps *o)set_cc_static (s);return DISAS_NEXT ; } + +static DisasJumpType op_vfae (DisasContext *s,DisasOps *o) +{ +const uint8_t es =get_field (s->fields, m4); +const uint8_t m5 =get_field (s->fields, m5); +static gen_helper_gvec_3_ptr *const cc[3 ] = { + gen_helper_gvec_vfae_cc8, + gen_helper_gvec_vfae_cc16, + gen_helper_gvec_vfae_cc32, + }; +static gen_helper_gvec_3 *const nocc[3 ] = { + gen_helper_gvec_vfae8, + gen_helper_gvec_vfae16, + gen_helper_gvec_vfae32, + }; + +if (es >ES_32 ) { +gen_program_exception (s,PGM_SPECIFICATION ); +return DISAS_NORETURN ; + } + +if (m5 &1 ) { +gen_gvec_3_ptr (get_field (s->fields, v1),get_field (s->fields, v2), +get_field (s->fields, v3), cpu_env, m5, cc[es]); +set_cc_static (s); + }else { +gen_gvec_3_ool (get_field (s->fields, v1),get_field (s->fields, v2), +get_field (s->fields, v3), m5, nocc[es]); + } +return DISAS_NEXT ; +}
target/s390x/vec_string_helper.c new file +97 -0
97 lines not on this page · raw message
Signature · 1 line
2.20.1
Re: [Qemu-devel] [PATCH v1 1/5] s390x/tcg: Implement VECTOR FIND ANY ELEMENT EQUAL
Review
Quoted 2 lines · David Hildenbrand
(quoted diff) +2
-0+#define DEF_VFAE(BITS) \ +static int vfae##BITS(void *v1, const void *v2, const void *v3, uint8_t m5)
First, because this *is* complicated stuff, can we find a way to use inline functions instead of an undebuggable macro for this? Perhaps a different set of wrappers than s390_vec_read_element##BITS, which always return uint32_t, so that they have a constant signature?
Review
Quoted 11 lines
(quoted diff) +11
-0+ if (zs && !data) { + if (cc == 3) { + first_byte = i * (BITS / 8); + cc = 0; /* match for zero */ + } else if (cc != 0) { + cc = 2; /* matching elements before match for zero */ + } + if (!rt) { + break; + } + }
So here we are computing the second intermediate result.
Review
Quoted 7 lines
(quoted diff) +7
-0+ /* try to match with any other element from the other vector */ + for (j = 0; j < (128 / BITS); j++) { + if (data == s390_vec_read_element##BITS(v3, j)) { + any_equal = true; + break; + } + }
And here the first intermediate result,
Review
Quoted 2 lines
(quoted diff) +2
-0+ /* invert the result if requested */ + any_equal = in ^ any_equal;
... inverted, if requested,
Review
Quoted 12 lines
(quoted diff) +11
-0+ if (cc == 3 && any_equal) { + first_byte = i * (BITS / 8); + cc = 1; /* matching elements, no match for zero */ + if (!zs && !rt) { + break; + } + } + /* indicate bit vector if requested */ + if (rt && any_equal) { + s390_vec_write_element##BITS(&tmp, i, (uint##BITS##_t)-1ull); + }
... writing out (some of) the results of the first intermediate result.
target/s390x/translate_vx.inc.c static DisasJumpType op_vtm(DisasContext *s, DisasOps *o) · line 2384
Quoted 4 lines
target/s390x/translate_vx.inc.c +4
-0+ } +if (!rt) { +s390_vec_write_element8 (&tmp,7 , first_byte); + }
... writing out the rest of the first intermediate result.
I wonder if it wouldn't be clearer, within the loop, to do
if (any_equal) {
if (cc == 3) {
first_byte = ...;
cc = 1;
}
if (rt) {
write element -1;
} else if (!zs) {
break;
}
}I also think that, if we create a bunch more of these wrappers:
target/s390x/vec_string_helper.c line 87
Quoted 3 lines
target/s390x/vec_string_helper.c new file +3
-0+DEF_VFAE_HELPER(8) +DEF_VFAE_HELPER(16) +DEF_VFAE_HELPER (32 )
then RT and ZS can be passed in as constant parameters to the above, and then the compiler will fold away all of the stuff that's not needed for each different case. Which, I think, is significant. These are practically different instructions with the different modifiers.
r~
Re: [Qemu-devel] [PATCH v1 1/5] s390x/tcg: Implement VECTOR FIND ANY ELEMENT EQUAL
Quoted 9 lines · Richard Henderson
Review
Quoted 2 lines · David Hildenbrand
(quoted diff) +2
-0+#define DEF_VFAE(BITS) \ +static int vfae##BITS(void *v1, const void *v2, const void *v3, uint8_t m5)First, because this *is* complicated stuff, can we find a way to use inline functions instead of an undebuggable macro for this? Perhaps a different set of wrappers than s390_vec_read_element##BITS, which always return
uint32_t, so that they have a constant signature?
For vfene I have for now
+static inline uint64_t s390_vec_read_element(const S390Vector *v, uint8_t enr,
+ uint8_t es)
+{
+ switch (es) {
+ case MO_8:
+ return s390_vec_read_element8(v, enr);
+ case MO_16:
+ return s390_vec_read_element16(v, enr);
+ case MO_32:
+ return s390_vec_read_element32(v, enr);
+ case MO_64:
+ return s390_vec_read_element64(v, enr);
+ default:
+ g_assert_not_reached();
+ }
+}
+
Which we could reuse here.
I'll try to look into using a inline function instead, passing in the element size and other flags, so the compiler can specialize.
Thanks!
Quoted 80 lines
Review
Quoted 12 lines
(quoted diff) +11
-0+ if (zs && !data) { + if (cc == 3) { + first_byte = i * (BITS / 8); + cc = 0; /* match for zero */ + } else if (cc != 0) { + cc = 2; /* matching elements before match for zero */ + } + if (!rt) { + break; + } + }So here we are computing the second intermediate result.
Review
Quoted 7 lines
(quoted diff) +7
-0+ /* try to match with any other element from the other vector */ + for (j = 0; j < (128 / BITS); j++) { + if (data == s390_vec_read_element##BITS(v3, j)) { + any_equal = true; + break; + } + }And here the first intermediate result,
Review
Quoted 2 lines
(quoted diff) +2
-0+ /* invert the result if requested */ + any_equal = in ^ any_equal;... inverted, if requested,
Review
Quoted 12 lines
(quoted diff) +11
-0+ if (cc == 3 && any_equal) { + first_byte = i * (BITS / 8); + cc = 1; /* matching elements, no match for zero */ + if (!zs && !rt) { + break; + } + } + /* indicate bit vector if requested */ + if (rt && any_equal) { + s390_vec_write_element##BITS(&tmp, i, (uint##BITS##_t)-1ull); + }... writing out (some of) the results of the first intermediate result.
target/s390x/translate_vx.inc.c static DisasJumpType op_vtm(DisasContext *s, DisasOps *o) · line 2384
Quoted 4 lines
target/s390x/translate_vx.inc.c +4
-0+ } +if (!rt) { +s390_vec_write_element8 (&tmp,7 , first_byte); + }... writing out the rest of the first intermediate result.
I wonder if it wouldn't be clearer, within the loop, to do
if (any_equal) { if (cc == 3) { first_byte = ...; cc = 1; } if (rt) { write element -1; } else if (!zs) { break; } }I also think that, if we create a bunch more of these wrappers:
target/s390x/vec_string_helper.c line 87
Quoted 3 lines
target/s390x/vec_string_helper.c new file +3
-0+DEF_VFAE_HELPER(8) +DEF_VFAE_HELPER(16) +DEF_VFAE_HELPER (32 )then RT and ZS can be passed in as constant parameters to the above, and then the compiler will fold away all of the stuff that's not needed for each different case. Which, I think, is significant. These are practically different instructions with the different modifiers.
r~
Signature · 3 lines
Thanks, David / dhildenb
Re: [Qemu-devel] [PATCH v1 1/5] s390x/tcg: Implement VECTOR FIND ANY ELEMENT EQUAL
In reply to Richard HendersonQuoted 12 lines
I also think that, if we create a bunch more of these wrappers:
target/s390x/vec_string_helper.c line 87
Quoted 3 lines
target/s390x/vec_string_helper.c new file +3
-0+DEF_VFAE_HELPER(8) +DEF_VFAE_HELPER(16) +DEF_VFAE_HELPER (32 )then RT and ZS can be passed in as constant parameters to the above, and then the compiler will fold away all of the stuff that's not needed for each different case. Which, I think, is significant. These are practically different instructions with the different modifiers.
So, we have 4 flags, resulting in 16 variants. Times 3 element sizes ... 48 helpers in total. Do we really want to go down that path?
I can also go ahead any try to identify the most frequent users (in Linux) and only specialize that one.
Signature · 3 lines
Thanks, David / dhildenb
Re: [Qemu-devel] [PATCH v1 1/5] s390x/tcg: Implement VECTOR FIND ANY ELEMENT EQUAL
Quoted 13 lines · David Hildenbrand
Quoted 12 lines
I also think that, if we create a bunch more of these wrappers:
target/s390x/vec_string_helper.c line 87
Quoted 3 lines
target/s390x/vec_string_helper.c new file +3
-0+DEF_VFAE_HELPER(8) +DEF_VFAE_HELPER(16) +DEF_VFAE_HELPER (32 )then RT and ZS can be passed in as constant parameters to the above, and then the compiler will fold away all of the stuff that's not needed for each different case. Which, I think, is significant. These are practically different instructions with the different modifiers.
Quoted 2 lines
So, we have 4 flags, resulting in 16 variants. Times 3 element sizes ... 48 helpers in total. Do we really want to go down that path?
Maybe?
Quoted 2 lines
I can also go ahead any try to identify the most frequent users (in Linux) and only specialize that one.
Also plausible. I guess it would be good to know, anyway.
I think RT probably makes the largest difference to the layout of the function, so maybe that's the one we pick. We could also leave our options open and make the 3 non-CC flags be parameters to the inline function, just extract them from the M4 parameter at the one higher level.
r~
Re: [Qemu-devel] [PATCH v1 1/5] s390x/tcg: Implement VECTOR FIND ANY ELEMENT EQUAL
Quoted 14 lines · Richard Henderson
Quoted 13 lines · David Hildenbrand
Quoted 12 lines
I also think that, if we create a bunch more of these wrappers:
target/s390x/vec_string_helper.c line 87
Quoted 3 lines
target/s390x/vec_string_helper.c new file +3
-0+DEF_VFAE_HELPER(8) +DEF_VFAE_HELPER(16) +DEF_VFAE_HELPER (32 )then RT and ZS can be passed in as constant parameters to the above, and then the compiler will fold away all of the stuff that's not needed for each different case. Which, I think, is significant. These are practically different instructions with the different modifiers.
Quoted 4 lines
Quoted 2 lines
So, we have 4 flags, resulting in 16 variants. Times 3 element sizes ... 48 helpers in total. Do we really want to go down that path?
Maybe?
Hope my fingers won't bleed from all the copy-pasting ;)
Quoted 5 lines
Quoted 3 lines
I can also go ahead any try to identify the most frequent users (in Linux) and only specialize that one.
Also plausible. I guess it would be good to know, anyway.
I'll dump the parameters when booting Linux. My gut feeling is that the cc option is basically never used ...
Quoted 2 lines
I think RT probably makes the largest difference to the layout of the function,
Yes. I think the RT and ZS make the biggest difference. IN - not really that heavy.
Maybe use different variants for RT and ZS for the !CC casen only.
Quoted 3 lines
so maybe that's the one we pick. We could also leave our options open and make the 3 non-CC flags be parameters to the inline function, just extract them from the M4 parameter at the one higher level.
That one, I have already done :)
Signature · 3 lines
Thanks, David / dhildenb
Re: [Qemu-devel] [PATCH v1 1/5] s390x/tcg: Implement VECTOR FIND ANY ELEMENT EQUAL
Quoted 4 lines · David Hildenbrand
Quoted 1 line
Also plausible. I guess it would be good to know, anyway.
I'll dump the parameters when booting Linux. My gut feeling is that the cc option is basically never used ...
It looks like our intuition is wrong about that.
rth@cloudburst:~/glibc/src/sysdeps/s390$ grep -r vfaezbs * | wc -l 15
These set cc, use zs, and do not use rt.
rth@cloudburst:~/glibc/src/sysdeps/s390$ grep -r 'vfaeb' * | wc -l 3
These do not set cc, do not use zs, and do use rt.
Those are the only two VFAE forms used by glibc (note that the same variants as 'f' are used by the wide-character strings).
r~
Re: [Qemu-devel] [PATCH v1 1/5] s390x/tcg: Implement VECTOR FIND ANY ELEMENT EQUAL
Quoted 7 lines · Richard Henderson
Quoted 4 lines · David Hildenbrand
Quoted 1 line
Also plausible. I guess it would be good to know, anyway.
I'll dump the parameters when booting Linux. My gut feeling is that the cc option is basically never used ...
It looks like our intuition is wrong about that.
Thanks for checking!
Quoted 6 lines
rth@cloudburst:~/glibc/src/sysdeps/s390$ grep -r vfaezbs * | wc -l 15These set cc, use zs, and do not use rt.
Quoted 8 lines
rth@cloudburst:~/glibc/src/sysdeps/s390$ grep -r 'vfaeb' * | wc -l 3These do not set cc, do not use zs, and do use rt.
Those are the only two VFAE forms used by glibc (note that the same variants as 'f' are used by the wide-character strings).
I guess "rt" and "cc" make the biggest difference. Maybe special case these two, result in 4 variants for each of the 3 element sizes?
Quoted 3 lines
r~
Signature · 3 lines
Thanks, David / dhildenb
Re: [Qemu-devel] [PATCH v1 1/5] s390x/tcg: Implement VECTOR FIND ANY ELEMENT EQUAL
Quoted 20 lines · David Hildenbrand
Quoted 7 lines · Richard Henderson
Quoted 4 lines · David Hildenbrand
Quoted 1 line
Also plausible. I guess it would be good to know, anyway.
I'll dump the parameters when booting Linux. My gut feeling is that the cc option is basically never used ...
It looks like our intuition is wrong about that.
Thanks for checking!
Quoted 9 lines
rth@cloudburst:~/glibc/src/sysdeps/s390$ grep -r vfaezbs * | wc -l 15These set cc, use zs, and do not use rt.
rth@cloudburst:~/glibc/src/sysdeps/s390$ grep -r 'vfaeb' * | wc -l 3
Quoted 8 lines
Quoted 5 lines
These do not set cc, do not use zs, and do use rt.
Those are the only two VFAE forms used by glibc (note that the same variants as 'f' are used by the wide-character strings).
I guess "rt" and "cc" make the biggest difference. Maybe special case these two, result in 4 variants for each of the 3 element sizes?
Sounds good.
r~
Re: [Qemu-devel] [PATCH v1 1/5] s390x/tcg: Implement VECTOR FIND ANY ELEMENT EQUAL
Quoted 23 lines · Richard Henderson
Quoted 22 lines · David Hildenbrand
Quoted 7 lines · Richard Henderson
Quoted 4 lines · David Hildenbrand
Quoted 1 line
Also plausible. I guess it would be good to know, anyway.
I'll dump the parameters when booting Linux. My gut feeling is that the cc option is basically never used ...
It looks like our intuition is wrong about that.
Thanks for checking!
Quoted 11 lines
rth@cloudburst:~/glibc/src/sysdeps/s390$ grep -r vfaezbs * | wc -l 15These set cc, use zs, and do not use rt.
rth@cloudburst:~/glibc/src/sysdeps/s390$ grep -r 'vfaeb' * | wc -l 3These do not set cc, do not use zs, and do use rt.
Quoted 9 lines
Quoted 6 lines
Quoted 3 lines
Those are the only two VFAE forms used by glibc (note that the same variants as 'f' are used by the wide-character strings).
I guess "rt" and "cc" make the biggest difference. Maybe special case these two, result in 4 variants for each of the 3 element sizes?
Sounds good.
So .... after all it might not be necessary, at least not for this helper :) Using your crazy helper functions, I have this right now:
/*
* Returns the number of bits composing one element. */
static uint8_t get_element_bits(uint8_t es)
{
return (1 << es) * BITS_PER_BYTE;
}/*
* Returns the bitmask for a single element. */
static uint64_t get_single_element_mask(uint8_t es)
{
return -1ull >> (64 - get_element_bits(es));
}/*
* Returns the bitmask for a single element (excluding the MSB). */
static uint64_t get_single_element_lsbs_mask(uint8_t es)
{
return -1ull >> (65 - get_element_bits(es));
}/*
* Returns the bitmasks for multiple elements (excluding the MSBs). */
static uint64_t get_element_lsbs_mask(uint8_t es)
{
return dup_const(es, get_single_element_lsbs_mask(es));
}static int vfae(void *v1, const void *v2, const void *v3, bool in,
bool rt, bool zs, uint8_t es)
{
const uint64_t mask = get_element_lsbs_mask(es);
const int bits = get_element_bits(es);
uint64_t a0, a1, b0, b1, e0, e1, t0, t1, z0, z1;
uint64_t first_zero = 16;
uint64_t first_equal;
int i;
a0 = s390_vec_read_element64(v2, 0);
a1 = s390_vec_read_element64(v2, 1);
b0 = s390_vec_read_element64(v3, 0);
b1 = s390_vec_read_element64(v3, 1);
e0 = 0;
e1 = 0;
/* compare against equality with every other element */
for (i = 0; i < 64; i += bits) {
t0 = i ? rol64(b0, i) : b0;
t1 = i ? rol64(b1, i) : b1;
e0 |= zero_search(a0 ^ t0, mask);
e0 |= zero_search(a0 ^ t1, mask);
e1 |= zero_search(a1 ^ t0, mask);
e1 |= zero_search(a1 ^ t1, mask);
}
/* invert the result if requested - invert only the MSBs */
if (in) {
e0 = ~e0 & ~mask;
e1 = ~e1 & ~mask;
}
first_equal = match_index(e0, e1);
if (zs) {
z0 = zero_search(a0, mask);
z1 = zero_search(a1, mask);
first_zero = match_index(z0, z1);
}
if (rt) {
e0 = (e0 >> (bits - 1)) * get_single_element_mask(es);
e1 = (e1 >> (bits - 1)) * get_single_element_mask(es);
s390_vec_write_element64(v1, 0, e0);
s390_vec_write_element64(v1, 1, e1);
} else {
s390_vec_write_element64(v1, 0, MIN(first_equal, first_zero));
s390_vec_write_element64(v1, 1, 0);
}
if (first_zero == 16 && first_equal == 16) {
return 3; /* no match */
} else if (first_zero == 16) {
return 1; /* matching elements, no match for zero */
} else if (first_equal < first_zero) {
return 2; /* matching elements before match for zero */
}
return 0; /* match for zero */
}At least the kernel boots with it - am i missing something or does this indeed work?
Cheers!
Signature · 3 lines
Thanks, David / dhildenb
Re: [Qemu-devel] [PATCH v1 1/5] s390x/tcg: Implement VECTOR FIND ANY ELEMENT EQUAL
Quoted 49 lines · David Hildenbrand
/*
* Returns the number of bits composing one element. */
staticuint8_tget_element_bits(uint8_t es){ return (1 << es) * BITS_PER_BYTE; }/*
* Returns the bitmask for a single element. */
staticuint64_tget_single_element_mask(uint8_t es){ return -1ull >> (64 - get_element_bits(es)); }/*
* Returns the bitmask for a single element (excluding the MSB). */
staticuint64_tget_single_element_lsbs_mask(uint8_t es){ return -1ull >> (65 - get_element_bits(es)); }/*
* Returns the bitmasks for multiple elements (excluding the MSBs). */
staticuint64_tget_element_lsbs_mask(uint8_t es){ return dup_const(es, get_single_element_lsbs_mask(es)); }static int vfae(void *v1, const void *v2, const void *v3, bool in,
bool rt, bool zs,uint8_tes){ const uint64_t mask = get_element_lsbs_mask(es); const int bits = get_element_bits(es); uint64_t a0, a1, b0, b1, e0, e1, t0, t1, z0, z1; uint64_t first_zero = 16; uint64_t first_equal; int i; a0 = s390_vec_read_element64(v2, 0); a1 = s390_vec_read_element64(v2, 1); b0 = s390_vec_read_element64(v3, 0); b1 = s390_vec_read_element64(v3, 1); e0 = 0; e1 = 0; /* compare against equality with every other element */
Quoted 8 lines
for (i = 0; i < 64; i += bits) {
t0 = i ? rol64(b0, i) : b0;
t1 = i ? rol64(b1, i) : b1;
e0 |= zero_search(a0 ^ t0, mask);
e0 |= zero_search(a0 ^ t1, mask);
e1 |= zero_search(a1 ^ t0, mask);
e1 |= zero_search(a1 ^ t1, mask);
}I don't see that this is doing what you want. You're shifting one element of B down, but not broadcasting it so that it is compared against every element of A.
I'd expect something like
t0 = dup_const(es, b0 >> i); t1 = dup_const(es, b1 >> i);
(I also don't see what rol is getting you that shift doesn't.)
Quoted 24 lines
/* invert the result if requested - invert only the MSBs */
if (in) {
e0 = ~e0 & ~mask;
e1 = ~e1 & ~mask;
}
first_equal = match_index(e0, e1);
if (zs) {
z0 = zero_search(a0, mask);
z1 = zero_search(a1, mask);
first_zero = match_index(z0, z1);
}
if (rt) {
e0 = (e0 >> (bits - 1)) * get_single_element_mask(es);
e1 = (e1 >> (bits - 1)) * get_single_element_mask(es);
s390_vec_write_element64(v1, 0, e0);
s390_vec_write_element64(v1, 1, e1);
} else {
s390_vec_write_element64(v1, 0, MIN(first_equal, first_zero));
s390_vec_write_element64(v1, 1, 0);
}
if (first_zero == 16 && first_equal == 16) {Quoted 8 lines
return 3; /* no match */
} else if (first_zero == 16) {
return 1; /* matching elements, no match for zero */
} else if (first_equal < first_zero) {
return 2; /* matching elements before match for zero */
}
return 0; /* match for zero */
}The rest of this looks good.
r~
Re: [Qemu-devel] [PATCH v1 1/5] s390x/tcg: Implement VECTOR FIND ANY ELEMENT EQUAL
Quoted 62 lines · Richard Henderson
Quoted 49 lines · David Hildenbrand
/*
* Returns the number of bits composing one element. */
staticuint8_tget_element_bits(uint8_t es){ return (1 << es) * BITS_PER_BYTE; }/*
* Returns the bitmask for a single element. */
staticuint64_tget_single_element_mask(uint8_t es){ return -1ull >> (64 - get_element_bits(es)); }/*
* Returns the bitmask for a single element (excluding the MSB). */
staticuint64_tget_single_element_lsbs_mask(uint8_t es){ return -1ull >> (65 - get_element_bits(es)); }/*
* Returns the bitmasks for multiple elements (excluding the MSBs). */
staticuint64_tget_element_lsbs_mask(uint8_t es){ return dup_const(es, get_single_element_lsbs_mask(es)); }static int vfae(void *v1, const void *v2, const void *v3, bool in,
bool rt, bool zs,uint8_tes){ const uint64_t mask = get_element_lsbs_mask(es); const int bits = get_element_bits(es); uint64_t a0, a1, b0, b1, e0, e1, t0, t1, z0, z1; uint64_t first_zero = 16; uint64_t first_equal; int i; a0 = s390_vec_read_element64(v2, 0); a1 = s390_vec_read_element64(v2, 1); b0 = s390_vec_read_element64(v3, 0); b1 = s390_vec_read_element64(v3, 1); e0 = 0; e1 = 0; /* compare against equality with every other element */Quoted 8 lines
for (i = 0; i < 64; i += bits) { t0 = i ? rol64(b0, i) : b0; t1 = i ? rol64(b1, i) : b1; e0 |= zero_search(a0 ^ t0, mask); e0 |= zero_search(a0 ^ t1, mask); e1 |= zero_search(a1 ^ t0, mask); e1 |= zero_search(a1 ^ t1, mask); }I don't see that this is doing what you want. You're shifting one element of B down, but not broadcasting it so that it is compared against every element of A.
Quoted 6 lines
I'd expect something like
t0 = dup_const(es, b0 >> i); t1 = dup_const(es, b1 >> i);(I also don't see what rol is getting you that shift doesn't.)
Let's assume
a0 = [0, 1, 2, 3]
a1 = [4, 5, 6, 7]
b0 = [8, 8, 8, 4]
b1 = [8, 8, 8, 8]
What I would check is
First iteration
a0 == [8, 8, 8, 4] -> no match a0 == [8, 8, 8, 8] -> no match a1 == [8, 8, 8, 4] -> no match a1 == [8, 8, 8, 8] -> no match
Second iteration
a0 == [8, 8, 4, 8] -> no match a0 == [8, 8, 8, 8] -> no match a1 == [8, 8, 4, 8]
a1 == [8, 8, 8, 8] -> no match
...
Last iteration
a0 == [4, 8, 8, 8] -> no match
a0 == [8, 8, 8, 8] -> no match
a1 == [4, 8, 8, 8] -> match in first element a1 == [8, 8, 8, 8] -> no match
What am i missing?
Signature · 3 lines
Thanks, David / dhildenb
Re: [Qemu-devel] [PATCH v1 1/5] s390x/tcg: Implement VECTOR FIND ANY ELEMENT EQUAL
Quoted 96 lines · David Hildenbrand
Quoted 62 lines · Richard Henderson
Quoted 49 lines · David Hildenbrand
/*
* Returns the number of bits composing one element. */
staticuint8_tget_element_bits(uint8_t es){ return (1 << es) * BITS_PER_BYTE; }/*
* Returns the bitmask for a single element. */
staticuint64_tget_single_element_mask(uint8_t es){ return -1ull >> (64 - get_element_bits(es)); }/*
* Returns the bitmask for a single element (excluding the MSB). */
staticuint64_tget_single_element_lsbs_mask(uint8_t es){ return -1ull >> (65 - get_element_bits(es)); }/*
* Returns the bitmasks for multiple elements (excluding the MSBs). */
staticuint64_tget_element_lsbs_mask(uint8_t es){ return dup_const(es, get_single_element_lsbs_mask(es)); }static int vfae(void *v1, const void *v2, const void *v3, bool in,
bool rt, bool zs,uint8_tes){ const uint64_t mask = get_element_lsbs_mask(es); const int bits = get_element_bits(es); uint64_t a0, a1, b0, b1, e0, e1, t0, t1, z0, z1; uint64_t first_zero = 16; uint64_t first_equal; int i; a0 = s390_vec_read_element64(v2, 0); a1 = s390_vec_read_element64(v2, 1); b0 = s390_vec_read_element64(v3, 0); b1 = s390_vec_read_element64(v3, 1); e0 = 0; e1 = 0; /* compare against equality with every other element */Quoted 8 lines
for (i = 0; i < 64; i += bits) { t0 = i ? rol64(b0, i) : b0; t1 = i ? rol64(b1, i) : b1; e0 |= zero_search(a0 ^ t0, mask); e0 |= zero_search(a0 ^ t1, mask); e1 |= zero_search(a1 ^ t0, mask); e1 |= zero_search(a1 ^ t1, mask); }I don't see that this is doing what you want. You're shifting one element of B down, but not broadcasting it so that it is compared against every element of A.
Quoted 6 lines
I'd expect something like
t0 = dup_const(es, b0 >> i); t1 = dup_const(es, b1 >> i);(I also don't see what rol is getting you that shift doesn't.)
Let's assume
a0 = [0, 1, 2, 3]
a1 = [4, 5, 6, 7]b0 = [8, 8, 8, 4]
b1 = [8, 8, 8, 8]What I would check is
First iteration
a0 == [8, 8, 8, 4] -> no match a0 == [8, 8, 8, 8] -> no match a1 == [8, 8, 8, 4] -> no match a1 == [8, 8, 8, 8] -> no match
Second iteration
a0 == [8, 8, 4, 8] -> no match a0 == [8, 8, 8, 8] -> no match a1 == [8, 8, 4, 8]
a1 == [8, 8, 8, 8] -> no match...
Quoted 10 lines
Last iteration
a0 == [4, 8, 8, 8] -> no match
a0 == [8, 8, 8, 8] -> no match
a1 == [4, 8, 8, 8] -> match in first element a1 == [8, 8, 8, 8] -> no matchWhat am i missing?
I guess I can simplify to
t0 = rol64(b0, i);
t1 = rol64(b1, i);
My approach: Compare all elements of B at a time Your approach: Compare a single element of B at a time
If I'm not wrong, it boils down to to whether
rol64() or dup_const(es, b0 >> i) is faster ;)
Signature · 3 lines
Thanks, David / dhildenb
Re: [Qemu-devel] [PATCH v1 1/5] s390x/tcg: Implement VECTOR FIND ANY ELEMENT EQUAL
Quoted 4 lines · David Hildenbrand
I guess I can simplify to
t0 =
rol64(b0, i);
t1 =rol64(b1, i);
Yes.
Quoted 2 lines
My approach: Compare all elements of B at a time Your approach: Compare a single element of B at a time
Ah, I get it now. This makes total sense, and does make the broadcast unnecessary.
r~
Re: [Qemu-devel] [PATCH v1 1/5] s390x/tcg: Implement VECTOR FIND ANY ELEMENT EQUAL
In reply to David HildenbrandQuoted 15 lines · David Hildenbrand
Quoted 14 lines · Richard Henderson
Quoted 13 lines · David Hildenbrand
Quoted 12 lines
I also think that, if we create a bunch more of these wrappers:
target/s390x/vec_string_helper.c line 87
Quoted 3 lines
target/s390x/vec_string_helper.c new file +3
-0+DEF_VFAE_HELPER(8) +DEF_VFAE_HELPER(16) +DEF_VFAE_HELPER (32 )then RT and ZS can be passed in as constant parameters to the above, and then the compiler will fold away all of the stuff that's not needed for each different case. Which, I think, is significant. These are practically different instructions with the different modifiers.
Quoted 6 lines
Quoted 4 lines
Quoted 2 lines
So, we have 4 flags, resulting in 16 variants. Times 3 element sizes ... 48 helpers in total. Do we really want to go down that path?
Maybe?
Hope my fingers won't bleed from all the copy-pasting ;)
An alternative is to generalise the code into a helper and then just use macros to instantiate a series of calls to it (c.f. softfloat). The idea is you can use flatten/inline to keep it efficient but you don't have a bunch of logic obscured by macro stuff.
--
Alex Bennée
PATCH 2/5 s390x/tcg: Implement VECTOR FIND ELEMENT EQUAL
In reply to David HildenbrandImplement it similar to VECTOR FIND ANY ELEMENT EQUAL.
The zero-check seems to have precedence in case we have "data1 == data2 == 0". The description in the PoP is a little bi confusing.
--- target/s390x/helper.h | 6 ++++ target/s390x/insn-data.def | 2 ++ target/s390x/translate_vx.inc.c | 31 +++++++++++++++++ target/s390x/vec_string_helper.c | 59 ++++++++++++++++++++++++++++++++ 4 files changed, 98 insertions(+)
target/s390x/helper.h +6 -0
@@ -218,6 +218,12 @@ DEF_HELPER_FLAGS_4(gvec_vfae32, TCG_CALL_NO_RWG, void, ptr, cptr, cptr, i32) DEF_HELPER_5(gvec_vfae_cc8, void, ptr, cptr, cptr, env, i32) DEF_HELPER_5(gvec_vfae_cc16, void, ptr, cptr, cptr, env, i32) DEF_HELPER_5(gvec_vfae_cc32, void, ptr, cptr, cptr, env, i32) +DEF_HELPER_FLAGS_4(gvec_vfee8, TCG_CALL_NO_RWG, void, ptr, cptr, cptr, i32) +DEF_HELPER_FLAGS_4(gvec_vfee16, TCG_CALL_NO_RWG, void, ptr, cptr, cptr, i32) +DEF_HELPER_FLAGS_4(gvec_vfee32, TCG_CALL_NO_RWG, void, ptr, cptr, cptr, i32) +DEF_HELPER_5(gvec_vfee_cc8, void, ptr, cptr, cptr, env, i32) +DEF_HELPER_5(gvec_vfee_cc16, void, ptr, cptr, cptr, env, i32) +DEF_HELPER_5(gvec_vfee_cc32, void, ptr, cptr, cptr, env, i32)#ifndef CONFIG_USER_ONLY DEF_HELPER_3 (servc, i32, env, i64, i64)
target/s390x/insn-data.def +2 -0
@@ -1195,6 +1195,8 @@ /* VECTOR FIND ANY ELEMENT EQUAL */ F(0xe782, VFAE, VRR_b, V, 0, 0, 0, 0, vfae, 0, IF_VEC) +/* VECTOR FIND ELEMENT EQUAL */ + F(0xe780, VFEE, VRR_b, V, 0, 0, 0, 0, vfee, 0, IF_VEC) #ifndef CONFIG_USER_ONLY /* COMPARE AND SWAP AND PURGE */
target/s390x/translate_vx.inc.c +31 -0
@@ -2384,3 +2384,34 @@ static DisasJumpType op_vfae(DisasContext *s, DisasOps *o) }return DISAS_NEXT ; } + +static DisasJumpType op_vfee (DisasContext *s,DisasOps *o) +{ +const uint8_t es =get_field (s->fields, m4); +const uint8_t m5 =get_field (s->fields, m5); +static gen_helper_gvec_3_ptr *const cc[3 ] = { + gen_helper_gvec_vfee_cc8, + gen_helper_gvec_vfee_cc16, + gen_helper_gvec_vfee_cc32, + }; +static gen_helper_gvec_3 *const nocc[3 ] = { + gen_helper_gvec_vfee8, + gen_helper_gvec_vfee16, + gen_helper_gvec_vfee32, + }; + +if (es >ES_32 || m5 & ~0x3 ) { +gen_program_exception (s,PGM_SPECIFICATION ); +return DISAS_NORETURN ; + } + +if (m5 &1 ) { +gen_gvec_3_ptr (get_field (s->fields, v1),get_field (s->fields, v2), +get_field (s->fields, v3), cpu_env, m5, cc[es]); +set_cc_static (s); + }else { +gen_gvec_3_ool (get_field (s->fields, v1),get_field (s->fields, v2), +get_field (s->fields, v3), m5, nocc[es]); + } +return DISAS_NEXT ; +}
target/s390x/vec_string_helper.c +59 -0
62 lines not on this page · raw message
Signature · 1 line
2.20.1
Re: [Qemu-devel] [PATCH v1 2/5] s390x/tcg: Implement VECTOR FIND ELEMENT EQUAL
Quoted 1 line · David Hildenbrand
+#define
DEF_VFEE(BITS)
Same comment wrt inline functions applies.
Here, because there's one result, writing to byte 7, I wonder if it isn't clearer to write the loop
first_equal = n;
first_zero = n;
for (i = n - 1; i >= 0; --i) {
if (data1 == data2) {
first_equal = i;
}
if (data1 == 0) {
first_zero = i;
}
}// As an aside, there are bit tricks for the above, // but let's stay simple(r) for now.
if (zs) {
if (first_equal < first_zero) {
cc = (first_zero < n ? 2 : 1);
} else {
first_equal = first_zero;
cc = (first_zero < n ? 0 : 3);
}
} else {
cc = (first_equal < n ? 1 : 3);
}
s390_vec_write_element64(v1, 0, first_equal);
s390_vec_write_element64(v1, 1, 0);Note that you don't need S390Vector tmp, since the result is written after all of the inputs are consumed.
r~
Re: [Qemu-devel] [PATCH v1 2/5] s390x/tcg: Implement VECTOR FIND ELEMENT EQUAL
Quoted 11 lines · Richard Henderson
first_equal = n;
first_zero = n;
for (i = n - 1; i >= 0; --i) {
if (data1 == data2) {
first_equal = i;
}
if (data1 == 0) {
first_zero = i;
}
}Quoted 2 lines
// As an aside, there are bit tricks for the above, // but let's stay simple(r) for now.
What the hell, it's not /that/ tricky.
/*
* Returns a bit set in the MSB of each element that is zero,
* as defined by the mask M.
*/
static inline uint64_t zero_search(uint64_t a, uint64_t m)
{
return ~(((a & m) + m) | a | m);
}/*
* Returns the byte offset for the first match, or 16 for no match. */
static inline int match_index(uint64_t c0, uint64_t c1)
{
return (c0 ? clz64(c0) : clz64(c1) + 64) >> 3;
}Use
dup_const(MO_8, 0x7f)
dup_const(MO_16, 0x7fff)
dup_const(MO_32, 0x7fffffff)
for the M parameter for the different element sizes.
uint64_t a0, a1, b0, b1, e0, e1, z0, z1;
a0 = s390_vec_read_element64(v2, 0);
a1 = s390_vec_read_element64(v2, 1);
b0 = s390_vec_read_element64(v3, 0);
b1 = s390_vec_read_element64(v3, 1);
e0 = zero_search(a0 ^ b0, m);
e1 = zero_search(a1 ^ b1, m);
first_equal = match_index(e0, e1);
if (zs) {
z0 = zero_search(a0, m);
z1 = zero_search(a1, m);
first_zero = match_index(z0, z1);
...r~
Re: [Qemu-devel] [PATCH v1 2/5] s390x/tcg: Implement VECTOR FIND ELEMENT EQUAL
Quoted 60 lines · Richard Henderson
Quoted 11 lines · Richard Henderson
first_equal = n; first_zero = n; for (i = n - 1; i >= 0; --i) { if (data1 == data2) { first_equal = i; } if (data1 == 0) { first_zero = i; } }Quoted 2 lines
// As an aside, there are bit tricks for the above, // but let's stay simple(r) for now.
What the hell, it's not /that/ tricky.
/*
* Returns a bit set in the MSB of each element that is zero,
* as defined by the mask M.
*/
static inlineuint64_tzero_search(uint64_t a, uint64_t m){ return ~(((a & m) + m) | a | m); }/*
* Returns the byte offset for the first match, or 16 for no match. */
static inline intmatch_index(uint64_t c0, uint64_t c1){ return (c0 ? clz64(c0) : clz64(c1) + 64) >> 3; }Use
dup_const(MO_8, 0x7f)
dup_const(MO_16, 0x7fff)
dup_const(MO_32, 0x7fffffff)for the M parameter for the different element sizes.
uint64_t a0, a1, b0, b1, e0, e1, z0, z1; a0 = s390_vec_read_element64(v2, 0); a1 = s390_vec_read_element64(v2, 1); b0 = s390_vec_read_element64(v3, 0); b1 = s390_vec_read_element64(v3, 1); e0 = zero_search(a0 ^ b0, m); e1 = zero_search(a1 ^ b1, m); first_equal = match_index(e0, e1); if (zs) { z0 = zero_search(a0, m); z1 = zero_search(a1, m); first_zero = match_index(z0, z1); ...
Quoted 2 lines
r~
Crazy stuff, seems to work (not that I am surprised :D )
I now have:
+static int vfee(void *v1, const void *v2, const void *v3, bool zs, uint8_t es)
+{
+ const uint64_t mask = dup_const(es, -1ull >> (65 - (1 << es) * 8));
+ uint64_t a0, a1, b0, b1, e0, e1, z0, z1;
+ uint64_t first_zero = 16;
+ uint64_t first_equal;
+
+ a0 = s390_vec_read_element64(v2, 0);
+ a1 = s390_vec_read_element64(v2, 1);
+ b0 = s390_vec_read_element64(v3, 0);
+ b1 = s390_vec_read_element64(v3, 1);
+ e0 = zero_search(a0 ^ b0, mask);
+ e1 = zero_search(a1 ^ b1, mask);
+ first_equal = match_index(e0, e1);
+
+ if (zs) {
+ z0 = zero_search(a0, mask);
+ z1 = zero_search(a1, mask);
+ first_zero = match_index(z0, z1);
+ }
+
+ /* zero out the destination vector */
+ s390_vec_write_element64(v1, 0, 0);
+ s390_vec_write_element64(v1, 1, 0);+
+ if (first_zero == 16 && first_equal == 16) {
+ s390_vec_write_element8(v1, 7, 16);
+ return 3; /* no match */
+ } else if (first_zero == 16) {
+ s390_vec_write_element8(v1, 7, first_equal);
+ return 1; /* matching elements, no match for zero */
+ } else if (first_equal < first_zero) {
+ s390_vec_write_element8(v1, 7, first_equal);
+ return 2; /* matching elements before match for zero */
+ } + s390_vec_write_element8(v1, 7, first_zero); + return 0; /* match for zero */
+}
Signature · 3 lines
Thanks, David / dhildenb
PATCH 3/5 s390x/tcg: Implement VECTOR FIND ELEMENT NOT EQUAL
In reply to David HildenbrandSimilar to VECTOR FIND ELEMENT EQUAL, however the search also stops on any inequality. A match for inequality seems to have precedence over a match for zero, because both elements have to be zero.
--- target/s390x/helper.h | 6 ++++ target/s390x/insn-data.def | 2 ++ target/s390x/translate_vx.inc.c | 31 +++++++++++++++++++ target/s390x/vec_string_helper.c | 53 ++++++++++++++++++++++++++++++++ 4 files changed, 92 insertions(+)
target/s390x/helper.h +6 -0
@@ -224,6 +224,12 @@ DEF_HELPER_FLAGS_4(gvec_vfee32, TCG_CALL_NO_RWG, void, ptr, cptr, cptr, i32) DEF_HELPER_5(gvec_vfee_cc8, void, ptr, cptr, cptr, env, i32) DEF_HELPER_5(gvec_vfee_cc16, void, ptr, cptr, cptr, env, i32) DEF_HELPER_5(gvec_vfee_cc32, void, ptr, cptr, cptr, env, i32) +DEF_HELPER_FLAGS_4(gvec_vfene8, TCG_CALL_NO_RWG, void, ptr, cptr, cptr, i32) +DEF_HELPER_FLAGS_4(gvec_vfene16, TCG_CALL_NO_RWG, void, ptr, cptr, cptr, i32) +DEF_HELPER_FLAGS_4(gvec_vfene32, TCG_CALL_NO_RWG, void, ptr, cptr, cptr, i32) +DEF_HELPER_5(gvec_vfene_cc8, void, ptr, cptr, cptr, env, i32) +DEF_HELPER_5(gvec_vfene_cc16, void, ptr, cptr, cptr, env, i32) +DEF_HELPER_5(gvec_vfene_cc32, void, ptr, cptr, cptr, env, i32)#ifndef CONFIG_USER_ONLY DEF_HELPER_3 (servc, i32, env, i64, i64)
target/s390x/insn-data.def +2 -0
@@ -1197,6 +1197,8 @@ F(0xe782, VFAE, VRR_b, V, 0, 0, 0, 0, vfae, 0, IF_VEC) /* VECTOR FIND ELEMENT EQUAL */ F(0xe780, VFEE, VRR_b, V, 0, 0, 0, 0, vfee, 0, IF_VEC) +/* VECTOR FIND ELEMENT NOT EQUAL */ + F(0xe781, VFENE, VRR_b, V, 0, 0, 0, 0, vfene, 0, IF_VEC) #ifndef CONFIG_USER_ONLY /* COMPARE AND SWAP AND PURGE */
target/s390x/translate_vx.inc.c +31 -0
@@ -2415,3 +2415,34 @@ static DisasJumpType op_vfee(DisasContext *s, DisasOps *o) }return DISAS_NEXT ; } + +static DisasJumpType op_vfene (DisasContext *s,DisasOps *o) +{ +const uint8_t es =get_field (s->fields, m4); +const uint8_t m5 =get_field (s->fields, m5); +static gen_helper_gvec_3_ptr *const cc[3 ] = { + gen_helper_gvec_vfene_cc8, + gen_helper_gvec_vfene_cc16, + gen_helper_gvec_vfene_cc32, + }; +static gen_helper_gvec_3 *const nocc[3 ] = { + gen_helper_gvec_vfene8, + gen_helper_gvec_vfene16, + gen_helper_gvec_vfene32, + }; + +if (es >ES_32 || m5 & ~0x3 ) { +gen_program_exception (s,PGM_SPECIFICATION ); +return DISAS_NORETURN ; + } + +if (m5 &1 ) { +gen_gvec_3_ptr (get_field (s->fields, v1),get_field (s->fields, v2), +get_field (s->fields, v3), cpu_env, m5, cc[es]); +set_cc_static (s); + }else { +gen_gvec_3_ool (get_field (s->fields, v1),get_field (s->fields, v2), +get_field (s->fields, v3), m5, nocc[es]); + } +return DISAS_NEXT ; +}
target/s390x/vec_string_helper.c +53 -0
56 lines not on this page · raw message
Signature · 1 line
2.20.1
Re: [Qemu-devel] [PATCH v1 3/5] s390x/tcg: Implement VECTOR FIND ELEMENT NOT EQUAL
Quoted 11 lines · David Hildenbrand
Similar to VECTOR FIND ELEMENT EQUAL, however the search also stops on any inequality. A match for inequality seems to have precedence over a match for zero, because both elements have to be zero.
Signed-off-by David Hildenbrand <[email protected]>--- target/s390x/helper.h | 6 ++++ target/s390x/insn-data.def | 2 ++ target/s390x/translate_vx.inc.c | 31 +++++++++++++++++++ target/s390x/vec_string_helper.c | 53 ++++++++++++++++++++++++++++++++ 4 files changed, 92 insertions(+)
Like the previous, only with
static inline uint64_t nonzero_search(uint64_t a, uint64_t m)
{
return (((a & m) + m) | a) & ~m;
}for the inequality.
r~
Re: [Qemu-devel] [PATCH v1 3/5] s390x/tcg: Implement VECTOR FIND ELEMENT NOT EQUAL
Quoted 16 lines · Richard Henderson
Quoted 11 lines · David Hildenbrand
Similar to VECTOR FIND ELEMENT EQUAL, however the search also stops on any inequality. A match for inequality seems to have precedence over a match for zero, because both elements have to be zero.
Signed-off-by David Hildenbrand <[email protected]>--- target/s390x/helper.h | 6 ++++ target/s390x/insn-data.def | 2 ++ target/s390x/translate_vx.inc.c | 31 +++++++++++++++++++ target/s390x/vec_string_helper.c | 53 ++++++++++++++++++++++++++++++++ 4 files changed, 92 insertions(+)Like the previous, only with
static inline
uint64_tnonzero_search(uint64_t a, uint64_t m)
Quoted 9 lines
{ return (((a & m) + m) | a) & ~m; }for the inequality.
r~
It's a little bit more tricky. because we have to identify the smaller element. Right now I have this
+static int vfene(void *v1, const void *v2, const void *v3, bool zs, uint8_t es)
+{
+ const uint64_t mask = dup_const(es, -1ull >> (65 - (1 << es) * 8));
+ uint64_t a0, a1, b0, b1, e0, e1, z0, z1;
+ uint64_t first_zero = 16;
+ uint64_t first_inequal;
+ bool smaller = false;
+
+ a0 = s390_vec_read_element64(v2, 0);
+ a1 = s390_vec_read_element64(v2, 1);
+ b0 = s390_vec_read_element64(v3, 0);
+ b1 = s390_vec_read_element64(v3, 1);
+ e0 = nonzero_search(a0 ^ b0, mask);
+ e1 = nonzero_search(a1 ^ b1, mask);
+ first_inequal = match_index(e0, e1);
+
+ /* identify the smaller element */
+ if (first_inequal < 16) {
+ uint8_t enr = first_inequal / (1 << es);
+ uint32_t a = s390_vec_read_element(v2, enr, es);
+ uint32_t b = s390_vec_read_element(v3, enr, es);
+ smaller = a < b;
+ }
+
+ if (zs) {
+ z0 = zero_search(a0, mask);
+ z1 = zero_search(a1, mask);
+ first_zero = match_index(z0, z1);
+ }
+
+ /* zero out the destination vector */
+ s390_vec_write_element64(v1, 0, 0);
+ s390_vec_write_element64(v1, 1, 0);+
+ if (first_zero == 16 && first_inequal == 16) {
+ s390_vec_write_element8(v1, 7, 16);
+ return 3;
+ } else if (first_zero < first_inequal) {
+ s390_vec_write_element8(v1, 7, first_zero);
+ return 0;
+ } + s390_vec_write_element8(v1, 7, first_inequal); + return smaller ? 1 : 2;
+}
Signature · 3 lines
Thanks, David / dhildenb
PATCH 4/5 s390x/tcg: Implement VECTOR ISOLATE STRING
In reply to David Hildenbrand--- target/s390x/helper.h | 6 +++++ target/s390x/insn-data.def | 2 ++ target/s390x/translate_vx.inc.c | 34 ++++++++++++++++++++++++++ target/s390x/vec_string_helper.c | 41 ++++++++++++++++++++++++++++++++ 4 files changed, 83 insertions(+)
target/s390x/helper.h +6 -0
@@ -230,6 +230,12 @@ DEF_HELPER_FLAGS_4(gvec_vfene32, TCG_CALL_NO_RWG, void, ptr, cptr, cptr, i32) DEF_HELPER_5(gvec_vfene_cc8, void, ptr, cptr, cptr, env, i32) DEF_HELPER_5(gvec_vfene_cc16, void, ptr, cptr, cptr, env, i32) DEF_HELPER_5(gvec_vfene_cc32, void, ptr, cptr, cptr, env, i32) +DEF_HELPER_FLAGS_3(gvec_vistr8, TCG_CALL_NO_RWG, void, ptr, cptr, i32) +DEF_HELPER_FLAGS_3(gvec_vistr16, TCG_CALL_NO_RWG, void, ptr, cptr, i32) +DEF_HELPER_FLAGS_3(gvec_vistr32, TCG_CALL_NO_RWG, void, ptr, cptr, i32) +DEF_HELPER_4(gvec_vistr_cc8, void, ptr, cptr, env, i32) +DEF_HELPER_4(gvec_vistr_cc16, void, ptr, cptr, env, i32) +DEF_HELPER_4(gvec_vistr_cc32, void, ptr, cptr, env, i32)#ifndef CONFIG_USER_ONLY DEF_HELPER_3 (servc, i32, env, i64, i64)
target/s390x/insn-data.def +2 -0
@@ -1199,6 +1199,8 @@ F(0xe780, VFEE, VRR_b, V, 0, 0, 0, 0, vfee, 0, IF_VEC) /* VECTOR FIND ELEMENT NOT EQUAL */ F(0xe781, VFENE, VRR_b, V, 0, 0, 0, 0, vfene, 0, IF_VEC) +/* VECTOR ISOLATE STRING */ + F(0xe75c, VISTR, VRR_a, V, 0, 0, 0, 0, vistr, 0, IF_VEC) #ifndef CONFIG_USER_ONLY /* COMPARE AND SWAP AND PURGE */
target/s390x/translate_vx.inc.c +34 -0
@@ -188,6 +188,9 @@ static void get_vec_element_ptr_i64(TCGv_ptr ptr, uint8_t reg, TCGv_i64 enr,#define gen_gvec_2s (v1, v2, c, gen) \ tcg_gen_gvec_2s(vec_full_reg_offset(v1), vec_full_reg_offset(v2), \ 16, 16, c, gen) +#define gen_gvec_2_ool (v1, v2, data, fn) \ + tcg_gen_gvec_2_ool(vec_full_reg_offset(v1), vec_full_reg_offset(v2), \ + 16, 16, data, fn)#define gen_gvec_2i_ool (v1, v2, c, data, fn) \ tcg_gen_gvec_2i_ool(vec_full_reg_offset(v1), vec_full_reg_offset(v2), \ c, 16, 16, data, fn)
@@ -2446,3 +2449,34 @@ static DisasJumpType op_vfene(DisasContext *s, DisasOps *o) }return DISAS_NEXT ; } + +static DisasJumpType op_vistr (DisasContext *s,DisasOps *o) +{ +const uint8_t es =get_field (s->fields, m4); +const uint8_t m5 =get_field (s->fields, m5); +static gen_helper_gvec_2_ptr *const cc[3 ] = { + gen_helper_gvec_vistr_cc8, + gen_helper_gvec_vistr_cc16, + gen_helper_gvec_vistr_cc32, + }; +static gen_helper_gvec_2 *const nocc[3 ] = { + gen_helper_gvec_vistr8, + gen_helper_gvec_vistr16, + gen_helper_gvec_vistr32, + }; + +if (es >ES_32 || m5 & ~0x1 ) { +gen_program_exception (s,PGM_SPECIFICATION ); +return DISAS_NORETURN ; + } + +if (m5 &1 ) { +gen_gvec_2_ptr (get_field (s->fields, v1),get_field (s->fields, v2), + cpu_env,0 , cc[es]); +set_cc_static (s); + }else { +gen_gvec_2_ool (get_field (s->fields, v1),get_field (s->fields, v2),0 , + nocc[es]); + } +return DISAS_NEXT ; +}
target/s390x/vec_string_helper.c +41 -0
44 lines not on this page · raw message
Signature · 1 line
2.20.1
Re: [Qemu-devel] [PATCH v1 4/5] s390x/tcg: Implement VECTOR ISOLATE STRING
Quoted 11 lines · David Hildenbrand
(quoted diff) +11
-0+#define DEF_VISTR(BITS) \ +static int vistr##BITS(void *v1, const void *v2) +{ + S390Vector tmp = {}; + int i, cc = 3; + + for (i = 0; i < (128 / BITS); i++) { + const uint##BITS##_t data = s390_vec_read_element##BITS(v2, i); + + if (!data) { + cc = 0;
Review
Quoted 10 lines
(quoted diff) +10
-0+ break; + } + s390_vec_write_element##BITS(&tmp, i, data); + } + *(S390Vector *)v1 = tmp; + return cc; +} +DEF_VISTR(8) +DEF_VISTR(16) +DEF_VISTR(32)
Based on previous, this becomes
cc = 3;
a0 = s390_vec_read_element64(v2, 0);
a1 = s390_vec_read_element64(v2, 1);
z0 = zero_search(a0, m);
if (z0) {
i = clz64(z0);
a0 &= ~(UINT64_MAX >> i);
a1 = 0;
cc = 0;
} else {
z1 = zero_search(a1, m);
if (z1) {
i = clz64(z1);
a1 &= ~(UINT64_MAX >> i);
cc = 0;
}
}
s390_vec_write_element64(v1, 0, a0);
s390_vec_write_element64(v1, 1, a1);
return cc;r~
PATCH 5/5 s390x/tcg: Implement VECTOR STRING RANGE COMPARE
In reply to David HildenbrandCrazy stuff. Implement it similar to VECTOR FIND ANY ELEMENT EQUAL.
--- target/s390x/helper.h | 6 ++ target/s390x/insn-data.def | 2 + target/s390x/translate_vx.inc.c | 37 +++++++++++ target/s390x/vec_string_helper.c | 108 +++++++++++++++++++++++++++++++ 4 files changed, 153 insertions(+)
target/s390x/helper.h +6 -0
@@ -236,6 +236,12 @@ DEF_HELPER_FLAGS_3(gvec_vistr32, TCG_CALL_NO_RWG, void, ptr, cptr, i32) DEF_HELPER_4(gvec_vistr_cc8, void, ptr, cptr, env, i32) DEF_HELPER_4(gvec_vistr_cc16, void, ptr, cptr, env, i32) DEF_HELPER_4(gvec_vistr_cc32, void, ptr, cptr, env, i32) +DEF_HELPER_FLAGS_5(gvec_vstrc8, TCG_CALL_NO_RWG, void, ptr, cptr, cptr, cptr, i32) +DEF_HELPER_FLAGS_5(gvec_vstrc16, TCG_CALL_NO_RWG, void, ptr, cptr, cptr, cptr, i32) +DEF_HELPER_FLAGS_5(gvec_vstrc32, TCG_CALL_NO_RWG, void, ptr, cptr, cptr, cptr, i32) +DEF_HELPER_6(gvec_vstrc_cc8, void, ptr, cptr, cptr, cptr, env, i32) +DEF_HELPER_6(gvec_vstrc_cc16, void, ptr, cptr, cptr, cptr, env, i32) +DEF_HELPER_6(gvec_vstrc_cc32, void, ptr, cptr, cptr, cptr, env, i32)#ifndef CONFIG_USER_ONLY DEF_HELPER_3 (servc, i32, env, i64, i64)
target/s390x/insn-data.def +2 -0
@@ -1201,6 +1201,8 @@ F(0xe781, VFENE, VRR_b, V, 0, 0, 0, 0, vfene, 0, IF_VEC) /* VECTOR ISOLATE STRING */ F(0xe75c, VISTR, VRR_a, V, 0, 0, 0, 0, vistr, 0, IF_VEC) +/* VECTOR STRING RANGE COMPARE */ + F(0xe78a, VSTRC, VRR_d, V, 0, 0, 0, 0, vstrc, 0, IF_VEC) #ifndef CONFIG_USER_ONLY /* COMPARE AND SWAP AND PURGE */
target/s390x/translate_vx.inc.c +37 -0
@@ -217,6 +217,10 @@ static void get_vec_element_ptr_i64(TCGv_ptr ptr, uint8_t reg, TCGv_i64 enr,tcg_gen_gvec_4_ool (vec_full_reg_offset (v1),vec_full_reg_offset (v2), \vec_full_reg_offset (v3),vec_full_reg_offset (v4), \ 16, 16, data, fn) +#define gen_gvec_4_ptr (v1, v2, v3, v4, ptr, data, fn) \ + tcg_gen_gvec_4_ptr(vec_full_reg_offset(v1), vec_full_reg_offset(v2), \ + vec_full_reg_offset(v3), vec_full_reg_offset(v4), \ + ptr, 16, 16, data, fn)#define gen_gvec_dup_i64 (es, v1, c) \ tcg_gen_gvec_dup_i64(es, vec_full_reg_offset(v1), 16, 16, c)#define gen_gvec_mov (v1, v2) \
@@ -2480,3 +2484,36 @@ static DisasJumpType op_vistr(DisasContext *s, DisasOps *o) }return DISAS_NEXT ; } + +static DisasJumpType op_vstrc (DisasContext *s,DisasOps *o) +{ +const uint8_t es =get_field (s->fields, m5); +const uint8_t m6 =get_field (s->fields, m6); +static gen_helper_gvec_4_ptr *const cc[3 ] = { + gen_helper_gvec_vstrc_cc8, + gen_helper_gvec_vstrc_cc16, + gen_helper_gvec_vstrc_cc32, + }; +static gen_helper_gvec_4 *const nocc[3 ] = { + gen_helper_gvec_vstrc8, + gen_helper_gvec_vstrc16, + gen_helper_gvec_vstrc32, + }; + +if (es >ES_32 ) { +gen_program_exception (s,PGM_SPECIFICATION ); +return DISAS_NORETURN ; + } + +if (m6 &1 ) { +gen_gvec_4_ptr (get_field (s->fields, v1),get_field (s->fields, v2), +get_field (s->fields, v3),get_field (s->fields, v4), + cpu_env, m6, cc[es]); +set_cc_static (s); + }else { +gen_gvec_4_ool (get_field (s->fields, v1),get_field (s->fields, v2), +get_field (s->fields, v3),get_field (s->fields, v4), m6, + nocc[es]); + } +return DISAS_NEXT ; +}
target/s390x/vec_string_helper.c +108 -0
111 lines not on this page · raw message
Signature · 1 line
2.20.1
Re: [Qemu-devel] [PATCH v1 5/5] s390x/tcg: Implement VECTOR STRING RANGE COMPARE
On 5/15/19 1:31 PM, David Hildenbrand wrote:> + const bool equal =extract32(c, BITS - 1, 1);> + const bool lower = extract32(c, BITS - 2, 1);>
+ const bool higher = extract32(c, BITS - 3, 1);> +> + if (equal && data
== l) {> + return true;> + } else if (lower && data < l) {> +
return true;> + } else if (higher && data > l) {> + return true;> +
}> + return false;
Only one of the data comparisons can be true. Better as
if (data < l) {
return lower;
} else if (data > l) {
return higher;
} else {
return equal;
}Otherwise, again, let's see if we can turn these into inlines.
r~