}
type templateData struct {
- Vec string // the type of the vector, e.g. Float32x4
+ VType string // the type of the vector, e.g. Float32x4
AOrAn string // for documentation, the article "a" or "an"
- Width int // the bit width of the element type, e.g. 32
+ EWidth int // the bit width of the element type, e.g. 32
Vwidth int // the width of the vector type, e.g. 128
Count int // the number of elements, e.g. 4
WxC string // the width-by-type string, e.g., "32x4"
BxC string // as if bytes, in the proper count, e.g., "8x16" (W==8)
- Base string // the capitalized Base Type of the vector, e.g., "Float"
- Type string // the element type, e.g. "float32"
+ Base string // the title-case Base Type of the vector, e.g., "Float"
+ Etype string // the element type, e.g. "float32"
OxFF string // a mask for the lowest 'count' bits
- Ovec string
- Otype string
- OType string
- Ocount int
+ OVType string // type of output vector
+ OEtype string // output element type
+ OEType string // output element type, title-case
+ OCount int // output element count
}
func (t templateData) As128BitVec() string {
- return fmt.Sprintf("%s%dx%d", t.Base, t.Width, 128/t.Width)
+ return fmt.Sprintf("%s%dx%d", t.Base, t.EWidth, 128/t.EWidth)
}
func oneTemplate(t *template.Template, baseType string, width, count int, out io.Writer, rtf resultTypeFunc) {
}
oxFF := fmt.Sprintf("0x%x", uint64((1<<count)-1))
t.Execute(out, templateData{
- Vec: vType,
+ VType: vType,
AOrAn: aOrAn,
- Width: width,
+ EWidth: width,
Vwidth: b,
Count: count,
WxC: wxc,
BxC: bxc,
Base: BaseType,
- Type: eType,
+ Etype: eType,
OxFF: oxFF,
- Ovec: ovType,
- Otype: oeType,
- Ocount: oc,
- OType: oEType,
+ OVType: ovType,
+ OEtype: oeType,
+ OCount: oc,
+ OEType: oEType,
})
}
}
var sliceTemplate = templateOf("slice", `
-// Load{{.Vec}}Slice loads {{.AOrAn}} {{.Vec}} from a slice of at least {{.Count}} {{.Type}}s
-func Load{{.Vec}}Slice(s []{{.Type}}) {{.Vec}} {
- return Load{{.Vec}}((*[{{.Count}}]{{.Type}})(s))
+// Load{{.VType}}Slice loads {{.AOrAn}} {{.VType}} from a slice of at least {{.Count}} {{.Etype}}s
+func Load{{.VType}}Slice(s []{{.Etype}}) {{.VType}} {
+ return Load{{.VType}}((*[{{.Count}}]{{.Etype}})(s))
}
-// StoreSlice stores x into a slice of at least {{.Count}} {{.Type}}s
-func (x {{.Vec}}) StoreSlice(s []{{.Type}}) {
- x.Store((*[{{.Count}}]{{.Type}})(s))
+// StoreSlice stores x into a slice of at least {{.Count}} {{.Etype}}s
+func (x {{.VType}}) StoreSlice(s []{{.Etype}}) {
+ x.Store((*[{{.Count}}]{{.Etype}})(s))
}
`)
var unaryTemplate = templateOf("unary_helpers", `
-// test{{.Vec}}Unary tests the simd unary method f against the expected behavior generated by want
-func test{{.Vec}}Unary(t *testing.T, f func(_ simd.{{.Vec}}) simd.{{.Vec}}, want func(_ []{{.Type}}) []{{.Type}}) {
+// test{{.VType}}Unary tests the simd unary method f against the expected behavior generated by want
+func test{{.VType}}Unary(t *testing.T, f func(_ simd.{{.VType}}) simd.{{.VType}}, want func(_ []{{.Etype}}) []{{.Etype}}) {
n := {{.Count}}
t.Helper()
- forSlice(t, {{.Type}}s, n, func(x []{{.Type}}) bool {
+ forSlice(t, {{.Etype}}s, n, func(x []{{.Etype}}) bool {
t.Helper()
- a := simd.Load{{.Vec}}Slice(x)
- g := make([]{{.Type}}, n)
+ a := simd.Load{{.VType}}Slice(x)
+ g := make([]{{.Etype}}, n)
f(a).StoreSlice(g)
w := want(x)
return checkSlicesLogInput(t, g, w, 0.0, func() {t.Helper(); t.Logf("x=%v", x)})
`)
var unaryFlakyTemplate = shapedTemplateOf(unaryFlaky, "unary_flaky_helpers", `
-// test{{.Vec}}UnaryFlaky tests the simd unary method f against the expected behavior generated by want,
+// test{{.VType}}UnaryFlaky tests the simd unary method f against the expected behavior generated by want,
// but using a flakiness parameter because we haven't exactly figured out how simd floating point works
-func test{{.Vec}}UnaryFlaky(t *testing.T, f func(x simd.{{.Vec}}) simd.{{.Vec}}, want func(x []{{.Type}}) []{{.Type}}, flakiness float64) {
+func test{{.VType}}UnaryFlaky(t *testing.T, f func(x simd.{{.VType}}) simd.{{.VType}}, want func(x []{{.Etype}}) []{{.Etype}}, flakiness float64) {
n := {{.Count}}
t.Helper()
- forSlice(t, {{.Type}}s, n, func(x []{{.Type}}) bool {
+ forSlice(t, {{.Etype}}s, n, func(x []{{.Etype}}) bool {
t.Helper()
- a := simd.Load{{.Vec}}Slice(x)
- g := make([]{{.Type}}, n)
+ a := simd.Load{{.VType}}Slice(x)
+ g := make([]{{.Etype}}, n)
f(a).StoreSlice(g)
w := want(x)
return checkSlicesLogInput(t, g, w, flakiness, func() {t.Helper(); t.Logf("x=%v", x)})
`)
var convertTemplate = templateOf("convert_helpers", `
-// test{{.Vec}}ConvertTo{{.OType}} tests the simd conversion method f against the expected behavior generated by want
+// test{{.VType}}ConvertTo{{.OEType}} tests the simd conversion method f against the expected behavior generated by want
// This is for count-preserving conversions, so if there is a change in size, then there is a change in vector width.
-func test{{.Vec}}ConvertTo{{.OType}}(t *testing.T, f func(x simd.{{.Vec}}) simd.{{.Ovec}}, want func(x []{{.Type}}) []{{.Otype}}) {
+func test{{.VType}}ConvertTo{{.OEType}}(t *testing.T, f func(x simd.{{.VType}}) simd.{{.OVType}}, want func(x []{{.Etype}}) []{{.OEtype}}) {
n := {{.Count}}
t.Helper()
- forSlice(t, {{.Type}}s, n, func(x []{{.Type}}) bool {
+ forSlice(t, {{.Etype}}s, n, func(x []{{.Etype}}) bool {
t.Helper()
- a := simd.Load{{.Vec}}Slice(x)
- g := make([]{{.Otype}}, n)
+ a := simd.Load{{.VType}}Slice(x)
+ g := make([]{{.OEtype}}, n)
f(a).StoreSlice(g)
w := want(x)
return checkSlicesLogInput(t, g, w, 0.0, func() {t.Helper(); t.Logf("x=%v", x)})
var unaryToUint16 = convertTemplate.target("uint", 16)
var binaryTemplate = templateOf("binary_helpers", `
-// test{{.Vec}}Binary tests the simd binary method f against the expected behavior generated by want
-func test{{.Vec}}Binary(t *testing.T, f func(_, _ simd.{{.Vec}}) simd.{{.Vec}}, want func(_, _ []{{.Type}}) []{{.Type}}) {
+// test{{.VType}}Binary tests the simd binary method f against the expected behavior generated by want
+func test{{.VType}}Binary(t *testing.T, f func(_, _ simd.{{.VType}}) simd.{{.VType}}, want func(_, _ []{{.Etype}}) []{{.Etype}}) {
n := {{.Count}}
t.Helper()
- forSlicePair(t, {{.Type}}s, n, func(x, y []{{.Type}}) bool {
+ forSlicePair(t, {{.Etype}}s, n, func(x, y []{{.Etype}}) bool {
t.Helper()
- a := simd.Load{{.Vec}}Slice(x)
- b := simd.Load{{.Vec}}Slice(y)
- g := make([]{{.Type}}, n)
+ a := simd.Load{{.VType}}Slice(x)
+ b := simd.Load{{.VType}}Slice(y)
+ g := make([]{{.Etype}}, n)
f(a, b).StoreSlice(g)
w := want(x, y)
return checkSlicesLogInput(t, g, w, 0.0, func() {t.Helper(); t.Logf("x=%v", x); t.Logf("y=%v", y); })
`)
var ternaryTemplate = templateOf("ternary_helpers", `
-// test{{.Vec}}Ternary tests the simd ternary method f against the expected behavior generated by want
-func test{{.Vec}}Ternary(t *testing.T, f func(_, _, _ simd.{{.Vec}}) simd.{{.Vec}}, want func(_, _, _ []{{.Type}}) []{{.Type}}) {
+// test{{.VType}}Ternary tests the simd ternary method f against the expected behavior generated by want
+func test{{.VType}}Ternary(t *testing.T, f func(_, _, _ simd.{{.VType}}) simd.{{.VType}}, want func(_, _, _ []{{.Etype}}) []{{.Etype}}) {
n := {{.Count}}
t.Helper()
- forSliceTriple(t, {{.Type}}s, n, func(x, y, z []{{.Type}}) bool {
+ forSliceTriple(t, {{.Etype}}s, n, func(x, y, z []{{.Etype}}) bool {
t.Helper()
- a := simd.Load{{.Vec}}Slice(x)
- b := simd.Load{{.Vec}}Slice(y)
- c := simd.Load{{.Vec}}Slice(z)
- g := make([]{{.Type}}, n)
+ a := simd.Load{{.VType}}Slice(x)
+ b := simd.Load{{.VType}}Slice(y)
+ c := simd.Load{{.VType}}Slice(z)
+ g := make([]{{.Etype}}, n)
f(a, b, c).StoreSlice(g)
w := want(x, y, z)
return checkSlicesLogInput(t, g, w, 0.0, func() {t.Helper(); t.Logf("x=%v", x); t.Logf("y=%v", y); t.Logf("z=%v", z); })
`)
var ternaryFlakyTemplate = shapedTemplateOf(ternaryFlaky, "ternary_helpers", `
-// test{{.Vec}}TernaryFlaky tests the simd ternary method f against the expected behavior generated by want,
+// test{{.VType}}TernaryFlaky tests the simd ternary method f against the expected behavior generated by want,
// but using a flakiness parameter because we haven't exactly figured out how simd floating point works
-func test{{.Vec}}TernaryFlaky(t *testing.T, f func(x, y, z simd.{{.Vec}}) simd.{{.Vec}}, want func(x, y, z []{{.Type}}) []{{.Type}}, flakiness float64) {
+func test{{.VType}}TernaryFlaky(t *testing.T, f func(x, y, z simd.{{.VType}}) simd.{{.VType}}, want func(x, y, z []{{.Etype}}) []{{.Etype}}, flakiness float64) {
n := {{.Count}}
t.Helper()
- forSliceTriple(t, {{.Type}}s, n, func(x, y, z []{{.Type}}) bool {
+ forSliceTriple(t, {{.Etype}}s, n, func(x, y, z []{{.Etype}}) bool {
t.Helper()
- a := simd.Load{{.Vec}}Slice(x)
- b := simd.Load{{.Vec}}Slice(y)
- c := simd.Load{{.Vec}}Slice(z)
- g := make([]{{.Type}}, n)
+ a := simd.Load{{.VType}}Slice(x)
+ b := simd.Load{{.VType}}Slice(y)
+ c := simd.Load{{.VType}}Slice(z)
+ g := make([]{{.Etype}}, n)
f(a, b, c).StoreSlice(g)
w := want(x, y, z)
return checkSlicesLogInput(t, g, w, flakiness, func() {t.Helper(); t.Logf("x=%v", x); t.Logf("y=%v", y); t.Logf("z=%v", z); })
`)
var compareTemplate = templateOf("compare_helpers", `
-// test{{.Vec}}Compare tests the simd comparison method f against the expected behavior generated by want
-func test{{.Vec}}Compare(t *testing.T, f func(_, _ simd.{{.Vec}}) simd.Mask{{.WxC}}, want func(_, _ []{{.Type}}) []int64) {
+// test{{.VType}}Compare tests the simd comparison method f against the expected behavior generated by want
+func test{{.VType}}Compare(t *testing.T, f func(_, _ simd.{{.VType}}) simd.Mask{{.WxC}}, want func(_, _ []{{.Etype}}) []int64) {
n := {{.Count}}
t.Helper()
- forSlicePair(t, {{.Type}}s, n, func(x, y []{{.Type}}) bool {
+ forSlicePair(t, {{.Etype}}s, n, func(x, y []{{.Etype}}) bool {
t.Helper()
- a := simd.Load{{.Vec}}Slice(x)
- b := simd.Load{{.Vec}}Slice(y)
- g := make([]int{{.Width}}, n)
+ a := simd.Load{{.VType}}Slice(x)
+ b := simd.Load{{.VType}}Slice(y)
+ g := make([]int{{.EWidth}}, n)
f(a, b).AsInt{{.WxC}}().StoreSlice(g)
w := want(x, y)
return checkSlicesLogInput(t, s64(g), w, 0.0, func() {t.Helper(); t.Logf("x=%v", x); t.Logf("y=%v", y); })
// TODO this has not been tested yet.
var compareMaskedTemplate = templateOf("comparemasked_helpers", `
-// test{{.Vec}}CompareMasked tests the simd masked comparison method f against the expected behavior generated by want
+// test{{.VType}}CompareMasked tests the simd masked comparison method f against the expected behavior generated by want
// The mask is applied to the output of want; anything not in the mask, is zeroed.
-func test{{.Vec}}CompareMasked(t *testing.T,
- f func(_, _ simd.{{.Vec}}, m simd.Mask{{.WxC}}) simd.Mask{{.WxC}},
- want func(_, _ []{{.Type}}) []int64) {
+func test{{.VType}}CompareMasked(t *testing.T,
+ f func(_, _ simd.{{.VType}}, m simd.Mask{{.WxC}}) simd.Mask{{.WxC}},
+ want func(_, _ []{{.Etype}}) []int64) {
n := {{.Count}}
t.Helper()
- forSlicePairMasked(t, {{.Type}}s, n, func(x, y []{{.Type}}, m []bool) bool {
+ forSlicePairMasked(t, {{.Etype}}s, n, func(x, y []{{.Etype}}, m []bool) bool {
t.Helper()
- a := simd.Load{{.Vec}}Slice(x)
- b := simd.Load{{.Vec}}Slice(y)
- k := simd.LoadInt{{.WxC}}Slice(toVect[int{{.Width}}](m)).ToMask()
- g := make([]int{{.Width}}, n)
+ a := simd.Load{{.VType}}Slice(x)
+ b := simd.Load{{.VType}}Slice(y)
+ k := simd.LoadInt{{.WxC}}Slice(toVect[int{{.EWidth}}](m)).ToMask()
+ g := make([]int{{.EWidth}}, n)
f(a, b, k).AsInt{{.WxC}}().StoreSlice(g)
w := want(x, y)
for i := range m {
`)
var avx512MaskedLoadSlicePartTemplate = shapedTemplateOf(avx512Shapes, "avx 512 load slice part", `
-// Load{{.Vec}}SlicePart loads a {{.Vec}} from the slice s.
+// Load{{.VType}}SlicePart loads a {{.VType}} from the slice s.
// If s has fewer than {{.Count}} elements, the remaining elements of the vector are filled with zeroes.
-// If s has {{.Count}} or more elements, the function is equivalent to Load{{.Vec}}Slice.
-func Load{{.Vec}}SlicePart(s []{{.Type}}) {{.Vec}} {
+// If s has {{.Count}} or more elements, the function is equivalent to Load{{.VType}}Slice.
+func Load{{.VType}}SlicePart(s []{{.Etype}}) {{.VType}} {
l := len(s)
if l >= {{.Count}} {
- return Load{{.Vec}}Slice(s)
+ return Load{{.VType}}Slice(s)
}
if l == 0 {
- var x {{.Vec}}
+ var x {{.VType}}
return x
}
mask := Mask{{.WxC}}FromBits({{.OxFF}} >> ({{.Count}} - l))
- return LoadMasked{{.Vec}}(pa{{.Vec}}(s), mask)
+ return LoadMasked{{.VType}}(pa{{.VType}}(s), mask)
}
// StoreSlicePart stores the {{.Count}} elements of x into the slice s.
// It stores as many elements as will fit in s.
// If s has {{.Count}} or more elements, the method is equivalent to x.StoreSlice.
-func (x {{.Vec}}) StoreSlicePart(s []{{.Type}}) {
+func (x {{.VType}}) StoreSlicePart(s []{{.Etype}}) {
l := len(s)
if l >= {{.Count}} {
x.StoreSlice(s)
return
}
mask := Mask{{.WxC}}FromBits({{.OxFF}} >> ({{.Count}} - l))
- x.StoreMasked(pa{{.Vec}}(s), mask)
+ x.StoreMasked(pa{{.VType}}(s), mask)
}
`)
var avx2MaskedLoadSlicePartTemplate = shapedTemplateOf(avx2MaskedLoadShapes, "avx 2 load slice part", `
-// Load{{.Vec}}SlicePart loads a {{.Vec}} from the slice s.
+// Load{{.VType}}SlicePart loads a {{.VType}} from the slice s.
// If s has fewer than {{.Count}} elements, the remaining elements of the vector are filled with zeroes.
-// If s has {{.Count}} or more elements, the function is equivalent to Load{{.Vec}}Slice.
-func Load{{.Vec}}SlicePart(s []{{.Type}}) {{.Vec}} {
+// If s has {{.Count}} or more elements, the function is equivalent to Load{{.VType}}Slice.
+func Load{{.VType}}SlicePart(s []{{.Etype}}) {{.VType}} {
l := len(s)
if l >= {{.Count}} {
- return Load{{.Vec}}Slice(s)
+ return Load{{.VType}}Slice(s)
}
if l == 0 {
- var x {{.Vec}}
+ var x {{.VType}}
return x
}
- mask := vecMask{{.Width}}[len(vecMask{{.Width}})/2-l:]
- return LoadMasked{{.Vec}}(pa{{.Vec}}(s), LoadInt{{.WxC}}Slice(mask).asMask())
+ mask := vecMask{{.EWidth}}[len(vecMask{{.EWidth}})/2-l:]
+ return LoadMasked{{.VType}}(pa{{.VType}}(s), LoadInt{{.WxC}}Slice(mask).asMask())
}
// StoreSlicePart stores the {{.Count}} elements of x into the slice s.
// It stores as many elements as will fit in s.
// If s has {{.Count}} or more elements, the method is equivalent to x.StoreSlice.
-func (x {{.Vec}}) StoreSlicePart(s []{{.Type}}) {
+func (x {{.VType}}) StoreSlicePart(s []{{.Etype}}) {
l := len(s)
if l >= {{.Count}} {
x.StoreSlice(s)
if l == 0 {
return
}
- mask := vecMask{{.Width}}[len(vecMask{{.Width}})/2-l:]
- x.StoreMasked(pa{{.Vec}}(s), LoadInt{{.WxC}}Slice(mask).asMask())
+ mask := vecMask{{.EWidth}}[len(vecMask{{.EWidth}})/2-l:]
+ x.StoreMasked(pa{{.VType}}(s), LoadInt{{.WxC}}Slice(mask).asMask())
}
`)
var avx2SmallLoadSlicePartTemplate = shapedTemplateOf(avx2SmallLoadPunShapes, "avx 2 small load slice part", `
-// Load{{.Vec}}SlicePart loads a {{.Vec}} from the slice s.
+// Load{{.VType}}SlicePart loads a {{.VType}} from the slice s.
// If s has fewer than {{.Count}} elements, the remaining elements of the vector are filled with zeroes.
-// If s has {{.Count}} or more elements, the function is equivalent to Load{{.Vec}}Slice.
-func Load{{.Vec}}SlicePart(s []{{.Type}}) {{.Vec}} {
+// If s has {{.Count}} or more elements, the function is equivalent to Load{{.VType}}Slice.
+func Load{{.VType}}SlicePart(s []{{.Etype}}) {{.VType}} {
if len(s) == 0 {
- var zero {{.Vec}}
+ var zero {{.VType}}
return zero
}
- t := unsafe.Slice((*int{{.Width}})(unsafe.Pointer(&s[0])), len(s))
- return LoadInt{{.WxC}}SlicePart(t).As{{.Vec}}()
+ t := unsafe.Slice((*int{{.EWidth}})(unsafe.Pointer(&s[0])), len(s))
+ return LoadInt{{.WxC}}SlicePart(t).As{{.VType}}()
}
// StoreSlicePart stores the {{.Count}} elements of x into the slice s.
// It stores as many elements as will fit in s.
// If s has {{.Count}} or more elements, the method is equivalent to x.StoreSlice.
-func (x {{.Vec}}) StoreSlicePart(s []{{.Type}}) {
+func (x {{.VType}}) StoreSlicePart(s []{{.Etype}}) {
if len(s) == 0 {
return
}
- t := unsafe.Slice((*int{{.Width}})(unsafe.Pointer(&s[0])), len(s))
+ t := unsafe.Slice((*int{{.EWidth}})(unsafe.Pointer(&s[0])), len(s))
x.AsInt{{.WxC}}().StoreSlicePart(t)
}
`)
// Less returns a mask whose elements indicate whether x < y
//
// Emulated, CPU Feature {{.CPUfeature}}
-func (x {{.Vec}}) Less(y {{.Vec}}) Mask{{.WxC}} {
+func (x {{.VType}}) Less(y {{.VType}}) Mask{{.WxC}} {
return y.Greater(x)
}
// GreaterEqual returns a mask whose elements indicate whether x >= y
//
// Emulated, CPU Feature {{.CPUfeature}}
-func (x {{.Vec}}) GreaterEqual(y {{.Vec}}) Mask{{.WxC}} {
+func (x {{.VType}}) GreaterEqual(y {{.VType}}) Mask{{.WxC}} {
ones := x.Equal(x).AsInt{{.WxC}}()
return y.Greater(x).AsInt{{.WxC}}().Xor(ones).asMask()
}
// LessEqual returns a mask whose elements indicate whether x <= y
//
// Emulated, CPU Feature {{.CPUfeature}}
-func (x {{.Vec}}) LessEqual(y {{.Vec}}) Mask{{.WxC}} {
+func (x {{.VType}}) LessEqual(y {{.VType}}) Mask{{.WxC}} {
ones := x.Equal(x).AsInt{{.WxC}}()
return x.Greater(y).AsInt{{.WxC}}().Xor(ones).asMask()
}
// NotEqual returns a mask whose elements indicate whether x != y
//
// Emulated, CPU Feature {{.CPUfeature}}
-func (x {{.Vec}}) NotEqual(y {{.Vec}}) Mask{{.WxC}} {
+func (x {{.VType}}) NotEqual(y {{.VType}}) Mask{{.WxC}} {
ones := x.Equal(x).AsInt{{.WxC}}()
return x.Equal(y).AsInt{{.WxC}}().Xor(ones).asMask()
}
// the sizes > 8 (shifts are AVX) but must use broadcast (AVX2)
// for bytes.
func (t templateData) CPUfeatureAVX2if8() string {
- if t.Width == 8 {
+ if t.EWidth == 8 {
return "AVX2"
}
return t.CPUfeature()
// Greater returns a mask whose elements indicate whether x > y
//
// Emulated, CPU Feature {{.CPUfeatureAVX2if8}}
-func (x {{.Vec}}) Greater(y {{.Vec}}) Mask{{.WxC}} {
+func (x {{.VType}}) Greater(y {{.VType}}) Mask{{.WxC}} {
a, b := x.AsInt{{.WxC}}(), y.AsInt{{.WxC}}()
-{{- if eq .Width 8}}
- signs := BroadcastInt{{.WxC}}(-1 << ({{.Width}}-1))
+{{- if eq .EWidth 8}}
+ signs := BroadcastInt{{.WxC}}(-1 << ({{.EWidth}}-1))
{{- else}}
ones := x.Equal(x).AsInt{{.WxC}}()
- signs := ones.ShiftAllLeft({{.Width}}-1)
+ signs := ones.ShiftAllLeft({{.EWidth}}-1)
{{- end }}
return a.Xor(signs).Greater(b.Xor(signs))
}
// Less returns a mask whose elements indicate whether x < y
//
// Emulated, CPU Feature {{.CPUfeatureAVX2if8}}
-func (x {{.Vec}}) Less(y {{.Vec}}) Mask{{.WxC}} {
+func (x {{.VType}}) Less(y {{.VType}}) Mask{{.WxC}} {
a, b := x.AsInt{{.WxC}}(), y.AsInt{{.WxC}}()
-{{- if eq .Width 8}}
- signs := BroadcastInt{{.WxC}}(-1 << ({{.Width}}-1))
+{{- if eq .EWidth 8}}
+ signs := BroadcastInt{{.WxC}}(-1 << ({{.EWidth}}-1))
{{- else}}
ones := x.Equal(x).AsInt{{.WxC}}()
- signs := ones.ShiftAllLeft({{.Width}}-1)
+ signs := ones.ShiftAllLeft({{.EWidth}}-1)
{{- end }}
return b.Xor(signs).Greater(a.Xor(signs))
}
// GreaterEqual returns a mask whose elements indicate whether x >= y
//
// Emulated, CPU Feature {{.CPUfeatureAVX2if8}}
-func (x {{.Vec}}) GreaterEqual(y {{.Vec}}) Mask{{.WxC}} {
+func (x {{.VType}}) GreaterEqual(y {{.VType}}) Mask{{.WxC}} {
a, b := x.AsInt{{.WxC}}(), y.AsInt{{.WxC}}()
ones := x.Equal(x).AsInt{{.WxC}}()
-{{- if eq .Width 8}}
- signs := BroadcastInt{{.WxC}}(-1 << ({{.Width}}-1))
+{{- if eq .EWidth 8}}
+ signs := BroadcastInt{{.WxC}}(-1 << ({{.EWidth}}-1))
{{- else}}
- signs := ones.ShiftAllLeft({{.Width}}-1)
+ signs := ones.ShiftAllLeft({{.EWidth}}-1)
{{- end }}
return b.Xor(signs).Greater(a.Xor(signs)).AsInt{{.WxC}}().Xor(ones).asMask()
}
// LessEqual returns a mask whose elements indicate whether x <= y
//
// Emulated, CPU Feature {{.CPUfeatureAVX2if8}}
-func (x {{.Vec}}) LessEqual(y {{.Vec}}) Mask{{.WxC}} {
+func (x {{.VType}}) LessEqual(y {{.VType}}) Mask{{.WxC}} {
a, b := x.AsInt{{.WxC}}(), y.AsInt{{.WxC}}()
ones := x.Equal(x).AsInt{{.WxC}}()
-{{- if eq .Width 8}}
- signs := BroadcastInt{{.WxC}}(-1 << ({{.Width}}-1))
+{{- if eq .EWidth 8}}
+ signs := BroadcastInt{{.WxC}}(-1 << ({{.EWidth}}-1))
{{- else}}
- signs := ones.ShiftAllLeft({{.Width}}-1)
+ signs := ones.ShiftAllLeft({{.EWidth}}-1)
{{- end }}
return a.Xor(signs).Greater(b.Xor(signs)).AsInt{{.WxC}}().Xor(ones).asMask()
}
// NotEqual returns a mask whose elements indicate whether x != y
//
// Emulated, CPU Feature {{.CPUfeature}}
-func (x {{.Vec}}) NotEqual(y {{.Vec}}) Mask{{.WxC}} {
+func (x {{.VType}}) NotEqual(y {{.VType}}) Mask{{.WxC}} {
a, b := x.AsInt{{.WxC}}(), y.AsInt{{.WxC}}()
ones := x.Equal(x).AsInt{{.WxC}}()
return a.Equal(b).AsInt{{.WxC}}().Xor(ones).asMask()
`)
var unsafePATemplate = templateOf("unsafe PA helper", `
-// pa{{.Vec}} returns a type-unsafe pointer to array that can
+// pa{{.VType}} returns a type-unsafe pointer to array that can
// only be used with partial load/store operations that only
// access the known-safe portions of the array.
-func pa{{.Vec}}(s []{{.Type}}) *[{{.Count}}]{{.Type}} {
- return (*[{{.Count}}]{{.Type}})(unsafe.Pointer(&s[0]))
+func pa{{.VType}}(s []{{.Etype}}) *[{{.Count}}]{{.Etype}} {
+ return (*[{{.Count}}]{{.Etype}})(unsafe.Pointer(&s[0]))
}
`)
var avx2MaskedTemplate = shapedTemplateOf(avx2Shapes, "avx2 .Masked methods", `
// Masked returns x but with elements zeroed where mask is false.
-func (x {{.Vec}}) Masked(mask Mask{{.WxC}}) {{.Vec}} {
+func (x {{.VType}}) Masked(mask Mask{{.WxC}}) {{.VType}} {
im := mask.AsInt{{.WxC}}()
{{- if eq .Base "Int" }}
return im.And(x)
{{- else}}
- return x.AsInt{{.WxC}}().And(im).As{{.Vec}}()
+ return x.AsInt{{.WxC}}().And(im).As{{.VType}}()
{{- end -}}
}
// Merge returns x but with elements set to y where mask is false.
-func (x {{.Vec}}) Merge(y {{.Vec}}, mask Mask{{.WxC}}) {{.Vec}} {
+func (x {{.VType}}) Merge(y {{.VType}}, mask Mask{{.WxC}}) {{.VType}} {
{{- if eq .BxC .WxC -}}
im := mask.AsInt{{.BxC}}()
{{- else}}
{{- else}}
ix := x.AsInt{{.BxC}}()
iy := y.AsInt{{.BxC}}()
- return iy.blend(ix, im).As{{.Vec}}()
+ return iy.blend(ix, im).As{{.VType}}()
{{- end -}}
}
`)
// TODO perhaps write these in ways that work better on AVX512
var avx512MaskedTemplate = shapedTemplateOf(avx512Shapes, "avx512 .Masked methods", `
// Masked returns x but with elements zeroed where mask is false.
-func (x {{.Vec}}) Masked(mask Mask{{.WxC}}) {{.Vec}} {
+func (x {{.VType}}) Masked(mask Mask{{.WxC}}) {{.VType}} {
im := mask.AsInt{{.WxC}}()
{{- if eq .Base "Int" }}
return im.And(x)
{{- else}}
- return x.AsInt{{.WxC}}().And(im).As{{.Vec}}()
+ return x.AsInt{{.WxC}}().And(im).As{{.VType}}()
{{- end -}}
}
// Merge returns x but with elements set to y where m is false.
-func (x {{.Vec}}) Merge(y {{.Vec}}, mask Mask{{.WxC}}) {{.Vec}} {
+func (x {{.VType}}) Merge(y {{.VType}}, mask Mask{{.WxC}}) {{.VType}} {
{{- if eq .Base "Int" }}
return y.blendMasked(x, mask)
{{- else}}
ix := x.AsInt{{.WxC}}()
iy := y.AsInt{{.WxC}}()
- return iy.blendMasked(ix, mask).As{{.Vec}}()
+ return iy.blendMasked(ix, mask).As{{.VType}}()
{{- end -}}
}
`)
case 256:
return "AVX2"
case 512:
- if t.Width <= 16 {
+ if t.EWidth <= 16 {
return "AVX512BW"
}
return "AVX512F"
}
var broadcastTemplate = templateOf("Broadcast functions", `
-// Broadcast{{.Vec}} returns a vector with the input
+// Broadcast{{.VType}} returns a vector with the input
// x assigned to all elements of the output.
//
// Emulated, CPU Feature {{.CPUfeatureBC}}
-func Broadcast{{.Vec}}(x {{.Type}}) {{.Vec}} {
+func Broadcast{{.VType}}(x {{.Etype}}) {{.VType}} {
var z {{.As128BitVec }}
return z.SetElem(0, x).Broadcast{{.Vwidth}}()
}