{"id":678,"date":"2018-07-02T11:05:17","date_gmt":"2018-07-02T11:05:17","guid":{"rendered":"http:\/\/blogs.gentoo.org\/lu_zero\/?p=678"},"modified":"2018-07-03T11:08:59","modified_gmt":"2018-07-03T11:08:59","slug":"altivec-and-vsx-in-rust-part-1","status":"publish","type":"post","link":"https:\/\/blogs.gentoo.org\/lu_zero\/2018\/07\/02\/altivec-and-vsx-in-rust-part-1\/","title":{"rendered":"Altivec and VSX in Rust (part 1)"},"content":{"rendered":"

I’m involved in implementing the Altivec and VSX support on rust<\/a> stdsimd<\/a>.<\/p>\n

Supporting all the instructions in this language is a HUGE endeavor since for each instruction at least 2 tests have to be written and making functions type-generic gets you to the point of having few pages of implementation (that luckily desugars to the single right instruction and nothing else).<\/p>\n

Since I’m doing this mainly<\/em> for my multimedia needs I have a short list of instructions I find handy to get some code written immediately and today I’ll talk a bit about some of them.<\/p>\n

This post is inspired by what Luc<\/a> did for neon<\/a>, but I’m using rust instead.<\/p>\n

If other people find it useful, I’ll try to write down the remaining istructions.<\/p>\n

Permutations<\/h2>\n

Most if not all the SIMD ISAs have at least one or multiple instructions to shuffle vector elements within a vector or among two.<\/p>\n

It is quite common to use those instructions to implement matrix transposes, but it isn’t its only use.<\/p>\n

In my toolbox I put vec_perm<\/code> and vec_xxpermdi<\/code> since even if the portable<\/em> stdsimd provides some shuffle support it is quite unwieldy compared to the Altivec native offering.<\/p>\n

vec_perm<\/code>: Vector Permute<\/h3>\n

Since it first iteration Altivec had a quite amazing instruction called vec_perm<\/code> or vperm<\/code>:<\/p>\n

\n
<\/span>    <\/span>fn<\/span> vec_perm<\/span>(<\/span>a<\/span>: i8x16<\/span>,<\/span> <\/span>b<\/span>: i8x16<\/span>,<\/span> <\/span>c<\/span>: i8x16<\/span>)<\/span> <\/span>-> i8x16<\/span> <\/span>{<\/span><\/span>\n        <\/span>let<\/span> <\/span>mut<\/span> <\/span>d<\/span>;<\/span><\/span>\n        <\/span>for<\/span> <\/span>i<\/span> <\/span>in<\/span> <\/span>0<\/span>..<\/span>16<\/span> <\/span>{<\/span><\/span>\n            <\/span>let<\/span> <\/span>idx<\/span> <\/span>=<\/span> <\/span>c<\/span>[<\/span>i<\/span>]<\/span> <\/span>&<\/span> <\/span>0xf<\/span>;<\/span><\/span>\n            <\/span>d<\/span>[<\/span>i<\/span>]<\/span> <\/span>=<\/span> <\/span>if<\/span> <\/span>(<\/span>c<\/span>[<\/span>i<\/span>]<\/span> <\/span>&<\/span> <\/span>0x10<\/span>)<\/span> <\/span>==<\/span> <\/span>0<\/span> <\/span>{<\/span><\/span>\n                <\/span>a<\/span>[<\/span>idx<\/span>]<\/span><\/span>\n            <\/span>}<\/span> <\/span>else<\/span> <\/span>{<\/span><\/span>\n                <\/span>b<\/span>[<\/span>idx<\/span>]<\/span><\/span>\n            <\/span>};<\/span><\/span>\n        <\/span>}<\/span><\/span>\n        <\/span>d<\/span><\/span>\n    <\/span>}<\/span><\/span>\n<\/pre>\n<\/div>\n
It is important to notice that the displacement map c<\/code> is a vector and not a constant. That gives you quite a bit of flexibility in a number of situations.<\/p>\n
This instruction is the building block you can use to implement a large deal of common patterns, including some that are also covered by stand-alone instructions e.g.:
\n– packing\/unpacking across lanes as long you do not have to saturate: vec_pack<\/code>, vec_unpackh\/vec_unpackl<\/code>
\n– interleave\/merge two vectors: vec_mergel<\/code>, vec_mergeh<\/code>
\n– shift N bytes in a vector from another: vec_sld<\/code><\/p>\n
It can be important to recall this since you could always take two permutations and make one, vec_perm<\/code> itself is pretty fast and replacing two or more instructions with a single permute can get you a pretty neat speed boost.<\/p>\n
vec_xxpermdi<\/code> Vector Permute Doubleword Immediate<\/h3>\n
Among a good deal of improvements VSX introduced a number of instructions that work on 64bit-elements vectors, among those we have a permute instruction and I found myself using it a lot.<\/p>\n
\n
<\/span>    <\/span>#[rustc_args_required_const(2)]<\/span><\/span>\n    <\/span>fn<\/span> vec_xxpermdi<\/span>(<\/span>a<\/span>: i64x2<\/span>,<\/span> <\/span>b<\/span>: i64x2<\/span>,<\/span> <\/span>c<\/span>: u8<\/span>)<\/span> <\/span>-> i64x2<\/span> <\/span>{<\/span><\/span>\n        <\/span>match<\/span> <\/span>c<\/span> <\/span>&<\/span> <\/span>0b11<\/span> <\/span>{<\/span><\/span>\n            <\/span>0b00<\/span> <\/span>=><\/span> <\/span>i64x2<\/span>::new<\/span>(<\/span>a<\/span>[<\/span>0<\/span>],<\/span> <\/span>b<\/span>[<\/span>0<\/span>]);<\/span><\/span>\n            <\/span>0b01<\/span> <\/span>=><\/span> <\/span>i64x2<\/span>::new<\/span>(<\/span>a<\/span>[<\/span>1<\/span>],<\/span> <\/span>b<\/span>[<\/span>0<\/span>]);<\/span><\/span>\n            <\/span>0b10<\/span> <\/span>=><\/span> <\/span>i64x2<\/span>::new<\/span>(<\/span>a<\/span>[<\/span>0<\/span>],<\/span> <\/span>b<\/span>[<\/span>1<\/span>]);<\/span><\/span>\n            <\/span>0b11<\/span> <\/span>=><\/span> <\/span>i64x2<\/span>::new<\/span>(<\/span>a<\/span>[<\/span>1<\/span>],<\/span> <\/span>b<\/span>[<\/span>1<\/span>]);<\/span><\/span>\n        <\/span>}<\/span><\/span>\n    <\/span>}<\/span><\/span>\n<\/pre>\n<\/div>\n
This instruction is surely less flexible than the previous permute but it does not require an additional load.<\/p>\n
When working on video codecs is quite common to deal with blocks of pixels that go from 4×4 up to 64×64, before vec_xxpermdi<\/code> the common pattern was:<\/p>\n
\n
<\/span>    <\/span>#[inline(always)]<\/span><\/span>\n    <\/span>fn<\/span> store8<\/span>(<\/span>dst<\/span>: &<\/span>mut<\/span> <\/span>[<\/span>u8x16<\/span>],<\/span> <\/span>v<\/span>: &<\/span>[<\/span>u8x16<\/span>])<\/span> <\/span>{<\/span><\/span>\n        <\/span>let<\/span> <\/span>data<\/span> <\/span>=<\/span> <\/span>dst<\/span>[<\/span>i<\/span>];<\/span><\/span>\n        <\/span>dst<\/span>[<\/span>i<\/span>]<\/span> <\/span>=<\/span> <\/span>vec_perm<\/span>(<\/span>v<\/span>,<\/span> <\/span>data<\/span>,<\/span> <\/span>TAKE_THE_FIRST_8<\/span>);<\/span><\/span>\n    <\/span>}<\/span><\/span>\n<\/pre>\n<\/div>\n
That implies to load the mask as often as needed as long as the destination.<\/p>\n
Using vec_xxpermdi<\/code> avoids the mask load and that usually leads to a quite significative speedup when the actual function is tiny.<\/p>\n
Mixed Arithmetics<\/h2>\n
With mixed arithmetics I consider all the instructions that do in a single step multiple vector arithmetics.<\/p>\n
The original altivec has the following operations available for the integer types:
\n– vec_madds<\/code>
\n– vec_mladd<\/code>
\n– vec_mradds<\/code>
\n– vec_msum<\/code>
\n– vec_msums<\/code>
\n– vec_sum2s<\/code>
\n– vec_sum4s<\/code>
\n– vec_sums<\/code><\/p>\n
And the following two for the float type:
\n– vec_madd<\/code>
\n– vec_nmsub<\/code><\/p>\n
All of them are quite useful and they will all find their way in stdsimd<\/strong> pretty soon.<\/p>\n
I’m describing today vec_sums<\/code>, vec_msums<\/code> and vec_madds<\/code>.<\/p>\n
They are quite representative and the other instructions are similar in spirit:
\n– vec_madds<\/code>, vec_mladd<\/code> and vec_mradds<\/code> all compute a lane-wise product, take either the high-order or the low-order part of it
\nand add a third vector returning a vector of the same element size.
\n– vec_sums<\/code>, vec_sum2s<\/code> and vec_sum4s<\/code> all combine an in-vector sum operation with a sum with another vector.
\n– vec_msum<\/code> and vec_msums<\/code> both compute a sum of products, the intermediates are added together and then added to a wider-element
\nvector.<\/p>\n
\nIf there is enough interest and time I can extend this post to cover all of them, for today we’ll go with this approximation.\n<\/p><\/blockquote>\n
vec_sums<\/code>: Vector Sum Saturated<\/h3>\n
Usually SIMD instruction work with two (or 3) vectors and execute the same operation for each vector element.
\nSometimes you want to just do operations within the single vector and vec_sums<\/code> is one of the few instructions that let you do that:<\/p>\n
\n
<\/span>    <\/span>fn<\/span> vec_sums<\/span>(<\/span>a<\/span>: i32x4<\/span>,<\/span> <\/span>b<\/span>: i32x4<\/span>)<\/span> <\/span>-> i32x4<\/span> <\/span>{<\/span><\/span>\n        <\/span>let<\/span> <\/span>d<\/span> <\/span>=<\/span> <\/span>i32x4<\/span>::new<\/span>(<\/span>0<\/span>,<\/span> <\/span>0<\/span>,<\/span> <\/span>0<\/span>,<\/span> <\/span>0<\/span>);<\/span><\/span>\n\n        <\/span>d<\/span>[<\/span>3<\/span>]<\/span> <\/span>=<\/span> <\/span>b<\/span>[<\/span>3<\/span>].<\/span>saturating_add<\/span>(<\/span>a<\/span>[<\/span>0<\/span>]).<\/span>saturating_add<\/span>(<\/span>a<\/span>[<\/span>1<\/span>]).<\/span>saturating_add<\/span>(<\/span>a<\/span>[<\/span>2<\/span>]).<\/span>saturating_add<\/span>(<\/span>a<\/span>[<\/span>3<\/span>]);<\/span><\/span>\n\n        <\/span>d<\/span><\/span>\n    <\/span>}<\/span><\/span>\n<\/pre>\n<\/div>\n
It returns in the last element of the vector the sum of the vector elements of a<\/code> and the last element of b<\/code>.
\nIt is pretty handy when you need to compute an average or similar operations.<\/p>\n
It works only<\/em> with 32bit signed<\/code> element vectors.<\/p>\n
vec_msums<\/code>: Vector Multiply Sum Saturated<\/h3>\n
This instruction sums the 32bit element of the third vector with the two products of the respective 16bit
\nelements of the first two vectors overlapping the element.<\/p>\n
It does quite a bit:<\/p>\n
\n
<\/span>    <\/span>fn<\/span> vmsumshs<\/span>(<\/span>a<\/span>: i16x8<\/span>,<\/span> <\/span>b<\/span>: i16x8<\/span>,<\/span> <\/span>c<\/span>: i32x4<\/span>)<\/span> <\/span>-> i32x4<\/span> <\/span>{<\/span><\/span>\n        <\/span>let<\/span> <\/span>d<\/span>;<\/span><\/span>\n        <\/span>for<\/span> <\/span>i<\/span> <\/span>in<\/span> <\/span>0<\/span>..<\/span>4<\/span> <\/span>{<\/span><\/span>\n            <\/span>let<\/span> <\/span>idx<\/span> <\/span>=<\/span> <\/span>2<\/span> <\/span>*<\/span> <\/span>i<\/span>;<\/span><\/span>\n            <\/span>let<\/span> <\/span>m0<\/span> <\/span>=<\/span> <\/span>a<\/span>[<\/span>idx<\/span>]<\/span> <\/span>as<\/span> <\/span>i32<\/span> <\/span>*<\/span> <\/span>b<\/span>[<\/span>idx<\/span>]<\/span> <\/span>as<\/span> <\/span>i32<\/span>;<\/span><\/span>\n            <\/span>let<\/span> <\/span>m1<\/span> <\/span>=<\/span> <\/span>a<\/span>[<\/span>idx<\/span> <\/span>+<\/span> <\/span>1<\/span>]<\/span> <\/span>as<\/span> <\/span>i32<\/span> <\/span>*<\/span> <\/span>b<\/span>[<\/span>idx<\/span> <\/span>+<\/span> <\/span>1<\/span>]<\/span> <\/span>as<\/span> <\/span>i32<\/span>;<\/span><\/span>\n            <\/span>d<\/span>[<\/span>i<\/span>]<\/span> <\/span>=<\/span> <\/span>c<\/span>[<\/span>i<\/span>].<\/span>saturating_add<\/span>(<\/span>m0<\/span>).<\/span>saturating_add<\/span>(<\/span>m1<\/span>);<\/span><\/span>\n        <\/span>}<\/span><\/span>\n        <\/span>d<\/span><\/span>\n    <\/span>}<\/span><\/span>\n\n    <\/span>fn<\/span> vmsumuhs<\/span>(<\/span>a<\/span>: u16x8<\/span>,<\/span> <\/span>b<\/span>: u16x8<\/span>,<\/span> <\/span>c<\/span>: u32x4<\/span>)<\/span> <\/span>-> u32x4<\/span> <\/span>{<\/span><\/span>\n        <\/span>let<\/span> <\/span>d<\/span>;<\/span><\/span>\n        <\/span>for<\/span> <\/span>i<\/span> <\/span>in<\/span> <\/span>0<\/span>..<\/span>4<\/span> <\/span>{<\/span><\/span>\n            <\/span>let<\/span> <\/span>idx<\/span> <\/span>=<\/span> <\/span>2<\/span> <\/span>*<\/span> <\/span>i<\/span>;<\/span><\/span>\n            <\/span>let<\/span> <\/span>m0<\/span> <\/span>=<\/span> <\/span>a<\/span>[<\/span>idx<\/span>]<\/span> <\/span>as<\/span> <\/span>u32<\/span> <\/span>*<\/span> <\/span>b<\/span>[<\/span>idx<\/span>]<\/span> <\/span>as<\/span> <\/span>u32<\/span>;<\/span><\/span>\n            <\/span>let<\/span> <\/span>m1<\/span> <\/span>=<\/span> <\/span>a<\/span>[<\/span>idx<\/span> <\/span>+<\/span> <\/span>1<\/span>]<\/span> <\/span>as<\/span> <\/span>u32<\/span> <\/span>*<\/span> <\/span>b<\/span>[<\/span>idx<\/span> <\/span>+<\/span> <\/span>1<\/span>]<\/span> <\/span>as<\/span> <\/span>u32<\/span>;<\/span><\/span>\n            <\/span>d<\/span>[<\/span>i<\/span>]<\/span> <\/span>=<\/span> <\/span>c<\/span>[<\/span>i<\/span>].<\/span>saturating_add<\/span>(<\/span>m0<\/span>).<\/span>saturating_add<\/span>(<\/span>m1<\/span>);<\/span><\/span>\n        <\/span>}<\/span><\/span>\n        <\/span>d<\/span><\/span>\n    <\/span>}<\/span><\/span>\n\n    <\/span>...<\/span><\/span>\n\n    <\/span>fn<\/span> vec_msums<\/span><<\/span>T<\/span>,<\/span> <\/span>U<\/span>><\/span>(<\/span>a<\/span>: T<\/span>,<\/span> <\/span>b<\/span>: T<\/span>,<\/span> <\/span>c<\/span>: U<\/span>)<\/span> <\/span>-> U<\/span><\/span>\n    <\/span>where<\/span> <\/span>T<\/span>: sealed<\/span>::VectorMultiplySumSaturate<\/span><<\/span>U<\/span>><\/span> <\/span>{<\/span><\/span>\n        <\/span>a<\/span>.<\/span>msums<\/span>(<\/span>b<\/span>,<\/span> <\/span>c<\/span>)<\/span><\/span>\n    <\/span>}<\/span><\/span>\n<\/pre>\n<\/div>\n
It works only with 16bit elements, signed or unsigned. In order to support that on rust we have to use some creative trait.
\nIt is quite neat if you have to implement some filters.<\/p>\n
vec_madds<\/code>: Vector Multiply Add Saturated<\/h3>\n
\n
<\/span>    <\/span>fn<\/span> vec_madds<\/span>(<\/span>a<\/span>: i16x8<\/span>,<\/span> <\/span>b<\/span>: i16x8<\/span>,<\/span> <\/span>c<\/span>: i16x8<\/span>)<\/span> <\/span>-> i16x8<\/span> <\/span>{<\/span><\/span>\n        <\/span>let<\/span> <\/span>d<\/span>;<\/span><\/span>\n        <\/span>for<\/span> <\/span>i<\/span> <\/span>in<\/span> <\/span>0<\/span>..<\/span>8<\/span> <\/span>{<\/span><\/span>\n            <\/span>let<\/span> <\/span>v<\/span> <\/span>=<\/span> <\/span>(<\/span>a<\/span>[<\/span>i<\/span>]<\/span> <\/span>as<\/span> <\/span>i32<\/span> <\/span>*<\/span> <\/span>b<\/span>[<\/span>i<\/span>]<\/span> <\/span>as<\/span> <\/span>i32<\/span>)<\/span> <\/span>>><\/span> <\/span>15<\/span>;<\/span><\/span>\n            <\/span>d<\/span>[<\/span>i<\/span>]<\/span> <\/span>=<\/span> <\/span>(<\/span>v<\/span> <\/span>as<\/span> <\/span>i16<\/span>).<\/span>saturating_add<\/span>(<\/span>c<\/span>[<\/span>i<\/span>]);<\/span><\/span>\n        <\/span>}<\/span><\/span>\n        <\/span>d<\/span><\/span>\n    <\/span>}<\/span><\/span>\n<\/pre>\n<\/div>\n
Takes the high-order 17bit of the lane-wise product of the first two vectors and adds it to a third one.<\/p>\n
Coming next<\/h2>\n
Raptor Enginering<\/a> kindly gave me access to a Power 9<\/strong> through their Integricloud<\/a> hosting.<\/p>\n
We could run some extensive benchmarks and we found some peculiar behaviour with the C compilers available on the machine and that got me, Luc<\/a> and Alexandra<\/a> a little puzzled.<\/p>\n
Next time I’ll try to collect in a little more organic way what I randomly put on my twitter<\/a> as I noticed it.<\/p>\n","protected":false},"excerpt":{"rendered":"
I’m involved in implementing the Altivec and VSX support on rust stdsimd. Supporting all the instructions in this language is a HUGE endeavor since for each instruction at least 2 tests have to be written and making functions type-generic gets you to the point of having few pages of implementation (that luckily desugars to the … Continue reading Altivec and VSX in Rust (part 1)<\/span><\/a><\/p>\n","protected":false},"author":10,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"spay_email":"","jetpack_publicize_message":"","jetpack_is_tweetstorm":false,"jetpack_publicize_feature_enabled":true},"categories":[24],"tags":[30,31,29],"jetpack_publicize_connections":[],"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"jetpack_shortlink":"https:\/\/wp.me\/p1aGWH-aW","_links":{"self":[{"href":"https:\/\/blogs.gentoo.org\/lu_zero\/wp-json\/wp\/v2\/posts\/678"}],"collection":[{"href":"https:\/\/blogs.gentoo.org\/lu_zero\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/blogs.gentoo.org\/lu_zero\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/blogs.gentoo.org\/lu_zero\/wp-json\/wp\/v2\/users\/10"}],"replies":[{"embeddable":true,"href":"https:\/\/blogs.gentoo.org\/lu_zero\/wp-json\/wp\/v2\/comments?post=678"}],"version-history":[{"count":2,"href":"https:\/\/blogs.gentoo.org\/lu_zero\/wp-json\/wp\/v2\/posts\/678\/revisions"}],"predecessor-version":[{"id":680,"href":"https:\/\/blogs.gentoo.org\/lu_zero\/wp-json\/wp\/v2\/posts\/678\/revisions\/680"}],"wp:attachment":[{"href":"https:\/\/blogs.gentoo.org\/lu_zero\/wp-json\/wp\/v2\/media?parent=678"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blogs.gentoo.org\/lu_zero\/wp-json\/wp\/v2\/categories?post=678"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blogs.gentoo.org\/lu_zero\/wp-json\/wp\/v2\/tags?post=678"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}