我不确定我正在尝试做什么的确切术语。我在8x8中存储了bits 8 bytes块，每个字节存储一行。当我完成后，我希望每个字节存储一列。
例如，当我完成时：
Byte0out = Byte0inBit0 + Byte1inBit0 + Byte2inBit0 + Byte3inBit0 + ...
Byte1out = Byte0inBit1 + Byte1inBit1 + Byte2inBit1 + Byte3inBit1 + ...
在 C 中执行此操作的最简单方法有哪些？
答案 0 :(得分：15)
此代码直接来自"Hacker's Delight" - Figure 7-2 Transposing an 8x8-bit matrix，我不相信：
void transpose8(unsigned char A[8], int m, int n,
unsigned char B[8]) {
unsigned x, y, t;
// Load the array and pack it into x and y.
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;
}
我没有检查它是否按您所需的方向旋转，如果不是，您可能需要调整代码。
另外，请记住数据类型＆amp;尺寸 - int＆amp; unsigned (int)可能不是您平台上的32位。
答案 1 :(得分：5)
如果您正在寻找最简单的解决方案：
/* not tested, not even compiled */
char bytes_in[8];
char bytes_out[8];
/* please fill bytes_in[] here with some pixel-crap */
memset(bytes_out, 0, 8);
for(int i = 0; i < 8; i++) {
for(int j = 0; j < 8; j++) {
bytes_out[i] = (bytes_out[i] << 1) | ((bytes_in[j] >> (7 - i)) & 0x01);
}
}
如果您正在寻找最快的解决方案：
How to transpose a bit matrix in the assembly by utilizing SSE2.
答案 2 :(得分：3)
Lisp原型：
(declaim (optimize (speed 3) (safety 0)))
(defun bit-transpose (a)
(declare (type (simple-array unsigned-byte 1) a))
(let ((b (make-array 8 :element-type '(unsigned-byte 8))))
(dotimes (j 8)
(dotimes (i 8)
(setf (ldb (byte 1 i) (aref b j))
(ldb (byte 1 j) (aref a i)))))
b))
这是您运行代码的方法：
#+nil
(bit-transpose (make-array 8 :element-type 'unsigned-byte
:initial-contents '(1 2 3 4 5 6 7 8)))
;; => #(85 102 120 128 0 0 0 0)
偶尔我会反汇编代码以检查没有不必要的安全功能调用。
#+nil
(disassemble #'bit-transpose)
这是一个基准。经常运行该功能以处理（二进制）HDTV图像。
#+nil
(time
(let ((a (make-array 8 :element-type 'unsigned-byte
:initial-contents '(1 2 3 4 5 6 7 8)))
(b (make-array 8 :element-type 'unsigned-byte
:initial-contents '(1 2 3 4 5 6 7 8))))
(dotimes (i (* (/ 1920 8) (/ 1080 8)))
(bit-transpose a))))
这花了51毫秒。请注意，由于函数始终分配新的8字节数组，因此我需要花费很多时间。我确信C中的实现可以进行更多调整。
Evaluation took:
0.051 seconds of real time
0.052004 seconds of total run time (0.052004 user, 0.000000 system)
101.96% CPU
122,179,503 processor cycles
1,048,576 bytes consed
以下是一些测试案例：
#+nil
(loop for j below 12 collect
(let ((l (loop for i below 8 collect (random 255))))
(list l (bit-transpose (make-array 8 :element-type 'unsigned-byte
:initial-contents l)))))
;; => (((111 97 195 202 47 124 113 164) #(87 29 177 57 96 243 111 140))
;; ((180 192 70 173 167 41 30 127) #(184 212 221 232 193 185 134 27))
;; ((244 86 149 57 191 65 129 178) #(124 146 23 24 159 153 35 213))
;; ((227 244 139 35 38 65 214 64) #(45 93 82 4 66 27 227 71))
;; ((207 62 236 89 50 64 157 120) #(73 19 71 207 218 150 173 69))
;; ((89 211 149 140 233 72 193 192) #(87 2 12 57 7 16 243 222))
;; ((97 144 19 13 135 198 238 33) #(157 116 120 72 6 193 97 114))
;; ((145 119 3 85 41 202 79 134) #(95 230 202 112 11 18 106 161))
;; ((42 153 67 166 175 190 114 21) #(150 125 184 51 226 121 68 58))
;; ((58 232 38 210 137 254 19 112) #(80 109 36 51 233 167 170 58))
;; ((27 245 1 197 208 221 21 101) #(239 1 234 33 115 130 186 58))
;; ((66 204 110 232 46 67 37 34) #(96 181 86 30 0 220 47 10)))
现在我真的想看看我的代码与Andrejs Cainikovs的C解决方案相比如何 （编辑：我认为错误）：
#include <string.h>
unsigned char bytes_in[8]={1,2,3,4,5,6,7,8};
unsigned char bytes_out[8];
/* please fill bytes_in[] here with some pixel-crap */
void bit_transpose(){
memset(bytes_out, 0, 8);
int i,j;
for(i = 0; i < 8; i++)
for(j = 0; j < 8; j++)
bytes_out[i] = (bytes_out[i] << 1) | ((bytes_in[j] >> (7 - i)) & 0x01);
}
int
main()
{
int j,i;
for(j=0;j<100;j++)
for(i=0;i<(1920/8*1080/8);i++)
bit_transpose();
return 0;
}
并对其进行基准测试：
wg@hp:~/0803/so$ gcc -O3 trans.c
wg@hp:~/0803/so$ time ./a.out
real 0m0.249s
user 0m0.232s
sys 0m0.000s
HDTV图像上的每个循环需要2.5ms。这比我未经优化的Lisp快得多。
不幸的是，C代码没有像我的lisp那样给出相同的结果：
#include <stdio.h>
int
main()
{
int j,i;
bit_transpose();
for(i=0;i<8;i++)
printf("%d ",(int)bytes_out[i]);
return 0;
}
wg@hp:~/0803/so$ ./a.out
0 0 0 0 1 30 102 170
答案 3 :(得分：2)
这听起来很像在使用位平面的显示器上使用的所谓“Chunky to planar”例程。以下链接使用MC68K汇编程序作为其代码，但提供了一个很好的问题概述（假设我正确理解了问题）：
答案 4 :(得分：1)
你真的想用SIMD指令做类似的事情，比如GCC矢量矢量支持：http://ds9a.nl/gcc-simd/example.html
答案 5 :(得分：1)
如果您需要优化的解决方案，可以在x86中使用SSE扩展。 您需要使用其中4个SIMD操作码。 MOVQ - 移动8个字节 PSLLW - 打包移位留下逻辑词 PMOVMSKB - 打包移动掩码字节 和2个常规的x86操作码 LEA - 加载有效地址 MOV - 移动
byte[] m = byte[8]; //input
byte[] o = byte[8]; //output
LEA ecx, [o]
// ecx = the address of the output array/matrix
MOVQ xmm0, [m]
// xmm0 = 0|0|0|0|0|0|0|0|m[7]|m[6]|m[5]|m[4]|m[3]|m[2]|m[1]|m[0]
PMOVMSKB eax, xmm0
// eax = m[7][7]...m[0][7] the high bit of each byte
MOV [ecx+7], al
// o[7] is now the last column
PSLLW xmm0, 1
// shift 1 bit to the left
PMOVMSKB eax, xmm0
MOV [ecx+6], al
PSLLW xmm0, 1
PMOVMSKB eax, xmm0
MOV [ecx+5], al
PSLLW xmm0, 1
PMOVMSKB eax, xmm0
MOV [ecx+4], al
PSLLW xmm0, 1
PMOVMSKB eax, xmm0
MOV [ecx+3], al
PSLLW xmm0, 1
PMOVMSKB eax, xmm0
MOV [ecx+2], al
PSLLW xmm0, 1
PMOVMSKB eax, xmm0
MOV [ecx+1], al
PSLLW xmm0, 1
PMOVMSKB eax, xmm0
MOV [ecx], al
25 x86操作码/指令，而不是堆叠for ...循环解决方案，64次迭代。 抱歉，符号不是c / c ++编译器接受的ATT样式语法。
答案 6 :(得分：1)
这与get column in a bitboard problem相似，可以通过将这些输入字节视为64位整数的8个字节来有效地解决。如果位0是最低有效位，字节0是数组中的第一个字节，那么我假设您想执行以下操作
b07 b06 b05 b04 b03 b02 b01 b00 b70 b60 b50 b40 b30 b20 b10 b00
b17 b16 b15 b14 b13 b12 b11 b10 b71 b61 b51 b41 b31 b21 b11 b01
b27 b26 b25 b24 b23 b22 b21 b20 b72 b62 b52 b42 b32 b22 b12 b02
b37 b36 b35 b34 b33 b32 b31 b30 => b73 b63 b53 b43 b33 b23 b13 b03
b47 b46 b45 b44 b43 b42 b41 b40 => b74 b64 b54 b44 b34 b24 b14 b04
b57 b56 b55 b54 b53 b52 b51 b50 b75 b65 b55 b45 b35 b25 b15 b05
b67 b66 b65 b64 b63 b62 b61 b60 b76 b66 b56 b46 b36 b26 b16 b06
b77 b76 b75 b74 b73 b72 b71 b70 b77 b67 b57 b47 b37 b27 b17 b07
具有bXY的是字节X的位号Y。将所有前7列屏蔽掉，并以uint64_t的形式读取数组
0000000h 0000000g 0000000f 0000000e 0000000d 0000000c 0000000b 0000000a
在小尾数中，abcdefgh分别为b00至b70。现在，我们只需要将该值乘以幻数0x2040810204081即可在MSB中将hgfedcba的值乘以结果中的翻转形式
uint8_t get_byte(uint64_t matrix, unsigned col)
{
const uint64_t column_mask = 0x8080808080808080ull;
const uint64_t magic = 0x2040810204081ull;
return ((matrix << (7 - col)) & column_mask) * magic >> 56;
}
// You may need to change the endianness if you address the data in a different way
uint64_t block8x8 = ((uint64_t)byte[7] << 56) | ((uint64_t)byte[6] << 48)
| ((uint64_t)byte[5] << 40) | ((uint64_t)byte[4] << 32)
| ((uint64_t)byte[3] << 24) | ((uint64_t)byte[2] << 16)
| ((uint64_t)byte[1] << 8) | (uint64_t)byte[0];
for (int i = 0; i < 8; i++)
byte_out[i] = get_byte(block8x8, i);
实际上，您应该直接读入8字节数组，这样以后就不需要合并字节了，但是需要正确对齐数组
为此，在AVX2中，英特尔在PDEP指令集中引入了BMI2指令（可通过_pext_u64内部指令访问），因此该功能可以在一条指令中完成
data[i] = _pext_u64(matrix, column_mask << (7 - col));
更多的转置数组方法可以在chess programming wiki
中找到