AVX or other's set instruction that can extract a specific bit, given an index from multiple integers in parrallel? - bit-manipulation

Question

Example: a=11010001 , b=0001001, c=11010000, d = 11111111
extract(a,b,c,d,2) == 0001

Answer 1

There are two cases: 1. The position of interest is a compile-time constant, and 2.
The position of interest is not a compile-time constant. Both cases are answered
in the code below.
Note that if a, b, c, d, are consecutive in memory, then you can simply move them to an xmm
register by x = _mm_load_si128((_m128i*) &d);, which is much more efficient than
_mm_set_epi32() used here.
The code:
/* gcc -O3 -m64 -Wall -march=broadwell extract_2nd_bit.c */
#include <immintrin.h>
#include <stdio.h>
/* If position i = 2 (for axample) is known at compile time: */
int extract_2nd_bit(int a, int b, int c, int d){
__m128i x = _mm_set_epi32(a, b, c, d);
x = _mm_slli_epi32(x, 31 - 2); /* shift bit 2 to the highest position */
return _mm_movemask_ps(_mm_castsi128_ps(x)); /* extract the MSB of the 4 elements */
}
/* If position i is unknown at compile time: */
int extract_var(int a, int b, int c, int d, int i){
__m128i x = _mm_set_epi32(a, b, c, d);
x = _mm_sll_epi32(x, _mm_cvtsi32_si128(31 - i)); /* shift bit i to the highest position */
return _mm_movemask_ps(_mm_castsi128_ps(x)); /* extract the MSB of the 4 elements */
}
int print_32_bin(unsigned int x);
int main(){
int a = 0b11010001;
int b = 0b0001001;
int c = 0b11010000;
int d = 0b11111111;
int pos = 2;
print_32_bin(extract_2nd_bit(a, b, c, d));
print_32_bin(extract_var(a, b, c, d, pos));
return 0;
}
int print_32_bin(unsigned int x){
for (int i=31;i>=0;i--){
printf("%1u",((x>>i)&1));
}
printf("\n");
return 0;
}
The output is:
$ ./a.out
00000000000000000000000000000001
00000000000000000000000000000001
By the way, why didn't you set the avx or sse tag in the question?

Answer 2

Try using the
unsigned __int64 _pext_u64 (unsigned __int64 a, unsigned __int64 mask)
command, though it doesn't use multiple integers.
There are other ways using ANDs and variable SHIFTs (and other commands).

Answer 3

This algorithm is not optimal, because the filling of the 32-bit register is done serially. But you should get the gist. It is the PEXT instruction from the BMI2 instruction set that can do this efficiently.
This is a solution in MASM x86 assembly (a, b, c, d are BYTE values in memory):
mov ah, a
mov al, b
shl eax, 16
mov ah, c
mov al, d
; Now EAX = aaaaaaaabbbbbbbbccccccccdddddddd
mov ecx, 0b00000100000001000000010000000100 ; MASK value
pext eax, eax, ecx
; Now EAX = 00000000000000000000000000000001 ; result
For practical use, optimize the filling of the 32-bit source register (here: EAX).
Now the lowest 4 bits of EAX should contain 0001.