mpldr
commented
2 years ago As for what the API might look like, the following yenc encoder may provide some insight.
Rust
fn yenc(input: [u8;64]) -> [u8;128] {
use core::simd::*;
let mut indata = u8x64::from_array(input); //u8x64::from_array(input);
indata += u8x64::splat(42);
// mark special characters
let mut mask = indata.lanes_eq(u8x64::splat(0));
mask |= indata.lanes_eq(u8x64::splat(10));
mask |= indata.lanes_eq(u8x64::splat(13));
mask |= indata.lanes_eq(u8x64::splat(61));
indata += mask.select(
u8x64::splat(64), // add 64 where the mask is set to true
u8x64::splat(0) // and don't do anything where it isn't
);
let escape = mask.select(
u8x64::splat(61), // add '=' (ASCII 61) where the mask is set to true
u8x64::splat(0) // and don't do anything where it isn't
);
let mut result: [u8;128] = [0;128];
for i in 0..64 {
result[i*2] = escape[i];
result[i*2+1] = indata[i];
}
return result;
}Go
package simd
*This is only supposed to be a **very** rough draft*
```go
package simd
type Uint8x64 [64]uint8
func Add[T SIMD128|SIMD256|SIMD512](x, y T) T {
// call appropriate add function based on required instruction set
}
func Uint8x64Splat(value uint8) T {
// create Uint8x64
}
```
package simd/mask
*This is only supposed to be a **very** rough draft*
```go
package mask
type Maskx64 [64]bool
// 64 lane equality opereator
func Equals64(x, y simd.Uint8x64) *Maskx64 {
// call appropriate comparison function based on required instruction set
}
func (m1 *Maskx64) Or(m2 *Maskx64) {
// perform logical or for all lanes
}
func (m *Mask) Select(onTrue, onFalse simd.Uint8x64) simd.Uint8x64 {
// generate from mask
}
```
package simd/{sse2,sse3,…}
Specific implementations. Potentially including a fallback if the instruction set is not supported.
Equivalent Go-Code would look something like this (assuming abovementioned API design)
package yenc
import (
"simd"
"simd/mask"
)
func yenc(input [64]byte) [128]byte {
indata := simd.Uint8x64(input)
indata += Uint8x64Splat(42)
// mark special characters
escapeMask := mask.Equals(indata, Uint8x64Splat(0))
escapeMask.Or(mask.Equals(indata, Uint8x64Splat(10)))
escapeMask.Or(mask.Equals(indata, Uint8x64Splat(13)))
escapeMask.Or(mask.Equals(indata, Uint8x64Splat(61)))
indata += escapeMask.Select(
Uint8x64Splat(64), // add 64 where the mask is set to true
Uint8x64Splat(0) // and don't do anything where it isn't
)
let escape = escapeMask.Select(
Uint8x64Splat(61), // add '=' (ASCII 61) where the mask is set to true
Uint8x64Splat(0) // and don't do anything where it isn't
)
var result [128]byte
for i := 0; i < 64; i++ {
result[i*2] = escape[i]
result[i*2+1] = indata[i]
}
return result
}I think this should be part of the standard library mainly for two reasons:
- This would allow to write performant SIMD code without using assembler within the standard library (making code more readable)
- Lowers the barrier of entry for using SIMD by providing a reliable API
ianlancetaylor
Zheng-Xu
qiulaidongfeng
inkeliz
beoran
rsc
klauspost
Robert-M-Muench
ghost
josharian
balasanjay
CAFxX
Bluebugs
HarikrishnanBalagopal
SIMD has the potential to greatly increase performance of a lot of data processing applications. Since #35307 was closed with the remark
Generics are now available, so I want to use this opportunity to necrobump and suggest a
simdpackage, which allows using SIMD instructions via a highlevel API. I think a simple API like Rust's experimental SIMD support, or the previously linked WebAssembly and Dart would help a lot of developers in improving their data processing performance in a simple and easy way.