Bytes parallel ausgeben - Bitmatrix drehen.

[Gnom67]

Hab nach einigem Googeln was Gutes dazu gefunden...
Beispielcode wesentlich aus dem Kapitel "Transposing a Bit Matrix"
Warren Jr., Henry S. (2013). Hacker's Delight (2 ed.).
Addison Wesley - Pearson Education, Inc. ISBN 978-0-321-84268-8

#include <stdio.h>

#define BYTE_TO_BINARY_PATTERN "%c%c%c%c%c%c%c%c"
#define BYTE_TO_BINARY(byte)  \
  (byte & 0x80 ? '1' : '0'), \
  (byte & 0x40 ? '1' : '0'), \
  (byte & 0x20 ? '1' : '0'), \
  (byte & 0x10 ? '1' : '0'), \
  (byte & 0x08 ? '1' : '0'), \
  (byte & 0x04 ? '1' : '0'), \
  (byte & 0x02 ? '1' : '0'), \
  (byte & 0x01 ? '1' : '0') 

int main(void)
{
    unsigned char A[8] = {0xf8, 0xf8, 0x07, 0x07, 0x00, 0x01, 0x02, 0x03};  //Array mit Ausgangsbytes
    int m = 1;
    int n = 1;
    unsigned char B[8] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};  //Array für Ergebnisbytes
    unsigned x, y, t;

    for (int i = 0; i < 8; i++) {
        printf("Ausgangsbytes "BYTE_TO_BINARY_PATTERN"\n", BYTE_TO_BINARY(A[i]));
    }
    printf("\n");
    
    // ********* Hier der eigenliche Code **********

    x = (A[0]<<24)   | (A[m]<<16)   | (A[2*m]<<8) | A[3*m];
    y = (A[4*m]<<24) | (A[5*m]<<16) | (A[6*m]<<8) | A[7*m];

    t = (x ^ (x >> 7)) & 0x00AA00AA; x = x ^ t ^ (t << 7);
    t = (y ^ (y >> 7)) & 0x00AA00AA; y = y ^ t ^ (t << 7);

    t = (x ^ (x >>14)) & 0x0000CCCC; x = x ^ t ^ (t <<14);
    t = (y ^ (y >>14)) & 0x0000CCCC; y = y ^ t ^ (t <<14);

    t = (x & 0xF0F0F0F0) | ((y >> 4) & 0x0F0F0F0F);
    y = ((x << 4) & 0xF0F0F0F0) | (y & 0x0F0F0F0F);
    x = t; 

    B[0]=x>>24;   B[n]=x>>16;   B[2*n]=x>>8; B[3*n]=x;
    B[4*n]=y>>24; B[5*n]=y>>16; B[6*n]=y>>8; B[7*n]=y;    
    
    // *********           Ende           **********

    for (int i = 0; i < 8; i++) {
        printf("Ergebnisbytes "BYTE_TO_BINARY_PATTERN"\n", BYTE_TO_BINARY(B[i])); 
    }  
    
    return 0;
}

Wird auf einem RISC-Prozessor laut der Quelle in 101 Prozessorinstruktionen ausgeführt.

Trotzdem stell ich mir vor, dass sowas nicht selten gebraucht wird. Mit ein paar zusammengeschalteten Latches könnte man das doch wahrscheinlich in wenigen, vielleicht sogar in einem Taktzyklus erledigen. Kennt jemand Prozessoren, die sowas machen?