Skip to contentSkip to conversation

s390x/tcg: Vector Instruction Support Part 3

PATCH Superseded David Hildenbrand 4 participants 27 messages May 15, 2019 – May 23, 2019

v1 of 2 Superseded Latest is v2 →

lore
Share & tools
lore
#0 lore raw

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
#1 lore raw

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
index 993ac93ed6..0a38281a14 100644
@@ -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
index 7755a96c33..c45328cf73 100644
@@ -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
index e61475bdc4..070ce2a471 100644
@@ -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
index 7e0bfcb190..022990dda3 100644
@@ -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
#2 lore raw

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~

#3 lore raw

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
#4 lore raw

Re: [Qemu-devel] [PATCH v1 1/5] s390x/tcg: Implement VECTOR FIND ANY ELEMENT EQUAL

In reply to Richard Henderson
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.

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
#5 lore raw

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~

#6 lore raw

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
#7 lore raw

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~

#8 lore raw

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
15

These set cc, use zs, and do not use rt.

Quoted 8 lines
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).

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
#9 lore raw

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
15

These 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~

#10 lore raw

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
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.

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
#11 lore raw

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. */
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 */
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~

#12 lore raw

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. */
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 */
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
#13 lore raw

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. */
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 */
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 match

What 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
#14 lore raw

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~

#15 lore raw

Re: [Qemu-devel] [PATCH v1 1/5] s390x/tcg: Implement VECTOR FIND ANY ELEMENT EQUAL

In reply to David Hildenbrand
Quoted 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

#16 lore raw

PATCH 2/5 s390x/tcg: Implement VECTOR FIND ELEMENT EQUAL

In reply to David Hildenbrand

Implement 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
index c45328cf73..a1b169b666 100644
@@ -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
index 070ce2a471..d8907ef6a5 100644
@@ -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
index 022990dda3..848f6d7163 100644
@@ -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
#17 lore raw

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~

#18 lore raw

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~

#19 lore raw

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 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);
    ...
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
#20 lore raw

PATCH 3/5 s390x/tcg: Implement VECTOR FIND ELEMENT NOT EQUAL

In reply to 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.

---
 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
index a1b169b666..fb50b404db 100644
@@ -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
index d8907ef6a5..d03c1ee0b3 100644
@@ -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
index 848f6d7163..e36cc5c401 100644
@@ -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
#21 lore raw

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.

---
 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~

#22 lore raw

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.

---
 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)

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
#23 lore raw

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
index fb50b404db..1f9f0b463b 100644
@@ -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
index d03c1ee0b3..b4a6b59608 100644
@@ -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
index e36cc5c401..437b416b4a 100644
@@ -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
#24 lore raw

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~

#25 lore raw

PATCH 5/5 s390x/tcg: Implement VECTOR STRING RANGE COMPARE

In reply to David Hildenbrand

Crazy 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
index 1f9f0b463b..f2743ccd97 100644
@@ -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
index b4a6b59608..a2969fab58 100644
@@ -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
index 437b416b4a..62a8d4d738 100644
@@ -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
#26 lore raw

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~