SSE指令集优化学习：双线性插值

对SSE的学习总算迈出了第一步，用2天时间对双线性插值的代码进行了优化，现将实现的过程梳理以下，算是对这段学习的一个总结。

1. 什么是SSE

说到SSE，首先要弄清楚的一个概念是SIMD（单指令多数据流，Single Instruction Multiple Data），是一种数据并行技术，能够在一条指令中同时对多个数据执行运算操作，增加处理器的数据吞吐量。SIMD特别的适用于多媒体应用等数据密集型运算。

1.1 历史

1996年Intel首先推出了支持MMX的Pentium处理器，极大地提高了CPU处理多媒体数据的能力，被广泛地应用于语音合成、语音识别、音频视频编解码、图像处理和串流媒体等领域。但是MMX只支持整数运算，浮点数运算仍然要使用传统的x87协处理器指令。由于MMX与x87的寄存器相互重叠，在MMX代码中插入x87指令时必须先执行EMMS指令清除MMX状态，频繁地切换状态将严重影响性能。这限制了MMX指令在需要大量浮点运算的程序，如三维几何变换、裁剪和投影中的应用。
另一方面，由于x87古怪的堆栈式缓存器结构，使得硬件上将其流水线化和软件上合理调度指令都很困难，这成为提高x86架构浮点性能的一个瓶颈。为了解决以上这两个问题，AMD公司于1998年推出了包含21条指令的3DNow!指令集，并在其K6-2处理器中实现。K6-2是 第一个能执行浮点SIMD指令的x86处理器，也是第一个支持水平浮点寄存器模型的x86处理器。借助3DNow!，K6-2实现了x86处理器上最快的浮点单元，在每个时钟周期内最多可得到4个单精度浮点数结果，是传统x87协处理器的4倍。许多游戏厂商为3DNow!优化了程序，微软的DirectX 7也为3DNow!做了优化，AMD处理器的游戏性能第一次超过Intel，这大大提升了AMD在消费者心目中的地位。K6-2和随后的K6-III成为市场上的热门货。
1999年，随着Athlon处理器的推出，AMD为3DNow!增加了5条新的指令，用于增强其在DSP方面的性能，它们被称为“扩展3DNow!”（Extended 3DNow!）。
为了对抗3DNow!，Intel公司于1999年推出了SSE指令集。SSE几乎能提供3DNow!的所有功能，而且能在一条指令中处理两倍多的单精度浮点数；同时，SSE完全支持IEEE 754，在处理单精度浮点数时可以完全代替x87。这迅速瓦解了3DNow!的优势。
1999年后，随着主流操作系统和软件都开始支持SSE并为SSE优化，AMD在其2000年发布的代号为“Thunderbird”的Athlon处理器中添加了对SSE的完全支持（“经典”的Athlon或K7只支持SSE中与MMX有关的部分，AMD称之为“扩展MMX”即Extended MMX）。随后，AMD致力于AMD64架构的开发；在SIMD指令集方面，AMD跟随Intel，为自己的处理器添加SSE2和SSE3支持，而不再改进3DNow!。
2010年八月，AMD宣布将在新一代处理器中取消除了两条数据预取指令之外3DNow!指令的支持，并鼓励开发者将3DNow!代码重新用SSE实现。

1.2 MMX和SSE

MMX 是Intel在Pentium MMX中引入的指令集。其缺点是占用浮点数寄存器进行运算（64位MMX寄存器实际上就是浮点数寄存器的别名）以至于MMX指令和浮点数操作不能同时工作。为了减少在MMX和浮点数模式切换之间所消耗的时间，程序员们尽可能减少模式切换的次数，也就是说，这两种操作在应用上是互斥的。后来Intel在此基础上发展出SSE指令集；AMD在此基础上发展出3D Now指令集。
SSE(Streaming SIMD Extensions)是Intel在3D Now!发布一年之后，在PIII中引入的指令集，是MMX的超集。AMD后来在Athlon XP中加入了对这个指令集的支持。这个指令集增加了对8个128位寄存器XMM0-XMM7的支持，每个寄存器可以存储4个单精度浮点数。使用这些寄存器的程序必须使用FXSAVE和FXRSTR指令来保持和恢复状态。但是在PIII对SSE的实现中，浮点数寄存器又一次被新的指令集占用了，但是这一次切换运算模式不是必要的了，只是SSE和浮点数指令不能同时进入CPU的处理线而已。
SSE2是Intel在P4的最初版本中引入的，但是AMD后来在Opteron 和Athlon 64中也加入了对它的支持。这个指令集添加了对64位双精度浮点数的支持，以及对整型数据的支持，也就是说这个指令集中所有的MMX指令都是多余的了，同时也避免了占用浮点数寄存器。这个指令集还增加了对CPU的缓存的控制指令。AMD对它的扩展增加了8个XMM寄存器，但是需要切换到64位模式(AMD64)才可以使用这些寄存器。Intel后来在其EM64T架构中也增加了对AMD64的支持。
SSE3是Intel在P4的Prescott版中引入的指令集，AMD在Athlon 64的第五个版本中也添加了对它的支持。这个指令集扩展的指令包含寄存器的局部位之间的运算，例如高位和低位之间的加减运算；浮点数到整数的转换，以及对超线程技术的支持。

2 双线性差值的优化

上面的多半是粘贴的，是前期学习SSE的资料搜集，算是对SSE的由来有一个大致的了解。下面介绍对双线性插值的优化的学习过程。

2.1 双线性插值

在图像变换时，变换后图像的像素映射到源图像上的坐标有可能是一个浮点坐标，插值算法就是要计算出浮点坐标像素近似值。那么要如何计算浮点坐标的近似值呢。一个浮点坐标必定会被四个整数坐标所包围，将这个四个整数坐标的像素值按照一定的比例混合就可以求出浮点坐标的像素值。混合比例为距离浮点坐标的距离，这就是双线性插值的基本思想。关于双线性插值的更多信息可以参见WIKI和 本人博文
要优化的双线性插值的C++实现

	//计算缩放后的图像大小
	dstWidth = static_cast<int>(width * fx);
	dstHeight = static_cast<int>(height * fy);

	depth /= 8;
	int dstSize = dstWidth * dstHeight * depth;
	dst = new byte[dstSize];
	memset(dst, 255, dstSize);

	byte* dstPixel = nullptr;

	double x = 0.0f; //缩放后图像在映射到原图像的横坐标
	double y = 0.0f; //映射到原图像的横坐标

	for (int j = 0; j < dstHeight; j++)
	{
		y = j / fy;

		for (int i = 0; i < dstWidth; i++)
		{
			x = i / fx;

			dstPixel = dst + (j * dstWidth + i) * depth;

			//计算距离当前映射点(x,y)最近的4个点
			int x1, y1, x2, y2;
			x1 = static_cast<int>(x);
			x2 = x1 + 1;
			y1 = static_cast<int>(y);
			y2 = y1 + 1;

			double u = x - x1; //映射点和最左边横坐标的差值
			double v = y - y1; //映射点和最下边纵坐标的差值

			byte cltr1, cltr2, cltr3, cltr4;
			//分别计算各个通道的分量
			for (int k = 0; k < depth; k++)
			{
					cltr1 = src[(y1 * width + x1) * depth + k]; // x1,y1
					cltr2 = src[(y1 * width + x2) * depth + k]; // x2,y1
					cltr3 = src[(y2 * width + x1) * depth + k]; // x1,y2
					cltr4 = src[(y2 * width + x2) * depth + k]; // x2,y2

					double f1, f2;
					f1 = u * cltr1 + (1-u) * cltr2;
					f2 = u * cltr3 + (1-u) * cltr4;
					dstPixel[k] = static_cast<byte>(v * f1 + (1-v) * f2); 
			}
		}
	}

优化的思路，使用128位的xmm寄存器，可以同时对4个32位的数据进行运算，选择同时对一个像素的所有通道进行处理（3通道和4通道）。优化后的运行速度，因为主要是用来学习SSE指令的，没有很做很严谨的对比，在debug下大致是3倍速（实验用的图像是24位3通道），在release下优化和优化的速度没有明显的提升，编译器的优化就是牛哇...。
下面就开始介绍用SSE实现双线性插值的过程，主要分为以下几个步骤：

  1. 数据的移动
  2. 数据的组织：pack,unpck,shuffle
  3. 运算

2.2 数据的移动

使用SSE的第一步就是需要将要处理的数据从内存复制到xmm寄存器中。SSE的mov指令可谓无花八门，可以mov不同长度的数据到xmm寄存器，另外有的mov指令需要内存16位对齐，有的则不需要。SSEmov指令可以将数据在xmm寄存器和内存之间进行移动，也可以用于xmm寄存器之间。下面列举几个常用mov指令：

  1. movd 移动双字到xmm寄存器
  2. movq 移动四字到xmm寄存器
  3. movapd / movaps 移动对齐的pack的双精度浮点数/单精度浮点数
  4. movupd / movups 移动未对齐的pack的双精度浮点数/单精度浮点数
  5. movdqa 移动对齐的双四字
  6. movdqu 移动未对齐的双四字
    SSE的数据移动指令很多，这里只列举一些，具体的可以参考Intel开发者手册。
    在双线性插值中，由于一个浮点坐标要使用其附近的4个像素近似得到，利用SSE指令同时计算这个4个像素的坐标，计算公式如下：

[(y_i * width + x_i) * depth,i = 1,2 j = 1,2 ]

首先将这需要用到的数据移动到xmm寄存器中

movd xm0,width
movd xmm1,y1
movd xmm2,y2

width和y1,y2都是32位的整型，所以使用movd将其移动到xmm中。

2.3 数据的组织

数据的组织可以说是使用SSE指令的第一个难点，因为128位寄存器可以同时对4个32位数据进行运算，就需要按照该一定的顺序将数据放在寄存器中。SSE中提供了两种指令来调整数据在xmm寄存器中的顺序

  1. unpck 交叉组合。
  2. shuffle 乱序
2.3.1 unpck

unpck是将源操作数和目的操作中字（双字，四字具体的交叉单位依赖于不同的指令）重新组合。
unpcklps32位单精度浮点数低位交叉 (unpckhps 32位浮点数高位交叉)

unpckhpd 64位浮点数高位交叉 (unpcklpd 64位浮点数低位交叉)

低位的unpck是按照一定的长度（根据指令的不同，一般有字/双字/四字,字长为16）取两操作数的低位数据进行重组，重组后的数据的高位是源操作数的低位，低位是目的操作数的低位。重组的结果保存在目的操作数中。
除了上述的unpck指令外，常用的交叉指令还有

  1. punpcklbw 交叉组合低位4字中的字节
  2. punpcklwd 交叉组合低位双字中字
  3. punpckldq 交叉组合低位四字中的双字
  4. punpcklqdq 交叉组合低位四字
    利用上面提到的交叉指令，可以将byte变成16位的整型，16位的整型变成32为整型，32位整型变成64位整型，后面有用到再详述。
2.3.2 shuffle

shuffle 指令功能更赞，它能够将xmm寄存器中的位调整为我们需要的顺序。这里以pshufd为例进行介绍。
pshufd xmm1,xmm2,imm8
pshufd有三个操作数，从左往右，第一个操作数是目的操作数保存结果，第二个操作数是源操作数，第三个操作数是一个8位立即数，指定以怎样的顺序将源操作数中数据保存到目的操作数。
imm8中每2位选择源操作数的一个双字(共4个)，00选择第一个，01选择第二个，10选择第三个，11选择第四个。利用imm8位模式选择好源操作数的双字后，其每2位的位段决定着这些双字如何在目的操作数中排列。[0-1]位选择的双字放在目的操作数的[0-31]，[2-3]选择的放在[32-63]，[4-5]选择的放在[64,95]，[6-7]选择的放在[96-127]中。
具体如下图

例如：

_MM_ALIGN16 int a[4] = {1,2,3,4}; //要变成2,4,3,1的顺序

_asm
{
	movdqa xmm0,[a];
	pshufd xmm0,xmm0,0x2D; // 0010 1101   
}

0x2d 就是0010 1101
将从源操作数选择的双字 从左到右，由高到底依次存放在目的操作数
00 选择 1，放在[96-127]
10 选择 3, 放在[64-95]
11 选择 4, 放在[32-63]
01 选择 2, 放在[0-31]

2.3.3 同时计算 y1 * width 和 y2 * width

上面说128位的寄存器可以同时进行4个32位数据的计算，这里要将乘法排除在外，因为32位 *32位需要64位空间才能结果不溢出。当然在保证结果不溢出的前提下，也可以使用32位存放相乘的结果。（一定要在保证结果不溢出的前提下，才能如此处理。我在写这段程序时，开始用16位保存的相乘结果，最后产生了溢出，调试了好久才找到错误所在。）
要同时运算y1 * width 和 y2 * width，就需要将一个寄存器中存放width ,width，一个寄存器存放y1,y2

                    punpckldq xmm0, xmm0; // xmm0 => width,width 低64位
                    movd xmm1, y1;
                    movd xmm2, y2;
                    punpckldq xmm1, xmm2; // xmm1 =>y1,y2 低64位

执行上面指令后，还是不能进行计算。这是因为 32位的乘法产生64位的结果，也就是
src[0-31] * dst[0-31] => src[0-64]
src[64-95] * dst[64-95] => src[64-127]
所以要调整顺序 xmm0中数据的顺序为 width 0 width 0 ,xmm1中顺序为 y1 0 y2 0 这就要用到上面提到的shuffle指令

                    pshufd xmm1, xmm1, 0xd8; // 0x1101 1000
                    pshufd xmm0, xmm0, 0xd8;
                    pmuludq xmm0, xmm1;

pmuludq 是乘法指令。xmm0得到的是两个64位的数据，这里是做图像缩放用32位存放结果也就足够了。（因为 这里计算的是图像中某个像素的通道的索引，即使是4k * 4k * 4 = 0x400 0000，32位足够保存了）。
得到y1 * width 和 y2 * width后，进行交叉后可以4个一起同时和x1，x2相加

					unpcklpd xmm0, xmm0; // xmm0 y1*width y2*width y1*width y2*width
					movd xmm1, x1;
					punpckldq xmm1, xmm1; // xmm1 => x1,x1
					movd xmm2, x2;
					punpckldq xmm2, xmm2; // xmm2 => x2,x2
					unpcklpd xmm1, xmm2; // xmm1 => x1,x1,x2,x2
					paddd xmm0, xmm1; // xmm0 => y1*width + x1,y2*width + x1,y1*width+x2,y2*width+x2

下面需要计算 $ (y * width + x) * depth$ ,128位寄存器只能同时计算2个32位的乘法，所以讲xmm0中的数据拆分放在两个xmm寄存器中

					pshufd xmm1, xmm0, 0x50; // xmm1 => (x1,y1) (x1,y2)
					pshufd xmm2, xmm0, 0xfa; // xmm2 => (x2,y1) (x2,y2)

然后就和上面的类似过程，将得到的64位结果只取低32位，然后在一起放在同一个xmm寄存器中

					movd xmm3, depth;
					punpckldq xmm3, xmm3;
					unpcklpd xmm3, xmm3;

					pmuludq xmm1, xmm3;
					pmuludq xmm2, xmm3;

					pshufd xmm1, xmm1, 0xd8;
					pshufd xmm2, xmm2, 0xd8;
					punpcklqdq xmm1, xmm2;

到这里 xmm1中就存放着要求的浮点坐标周围的4个像素的位置，依次为(x1,y1) (x1,y2) (x2,y1) (x2,y2)。将这四个值放在数组中，在后面取像素值时会用到

	//像素的地址偏移量
	__declspec(align(16)) int bitOffset[] = { 0,0,0,0 };
	movdqa[bitOffset], xmm1;//(x1,y1) (x1,y2) (x2,y1) (x2,y2)
2.3.4 位扩展

在对像素的通道进行处理时，读取的数据是8位，而通常在处理时需要运算是32位的或者64位的（本文中和通道数据做运算的是32位浮点数），这就需要将8位的通道数据进行扩展。
在上面也提到可以利用punpcklbw punpcklwd punpckldq对8位字节进行扩展。下面的SSE指令将8位的通道数据转换为32位的整型

                    // 取出像素依次存放在xmm0,xmm1,xmm2,xmm3
                    lea eax, bitOffset; // 取出数组地址
                    mov edx, [eax];
                    mov ecx, src;
                    movd xmm0, [ecx + edx]; //三通道像素，读取了32位，只需要处理24位
                    //将xxm0中的低位4个字节扩展为32位整数（只处理低3个32位整数）
                    psllw xmm1, 16;  //将xxm1置为0
                    punpcklbw xmm0, xmm1;
                    punpcklwd xmm0, xmm1; // 扩展为32位整数

punpcklbw 交叉组合低位四字中的字节，如果源操作数为0，则可以将低位的8位字节扩展为16位整型。
psllw 是以字为单位（16位）的逻辑左移指令，立即数16是左移的位数，由于是以字为单位左移16位，所以该指令可以将xmm1清0。
'punpcklwd' 交叉组合低位四字中的字，如果源操作数为0，则可以将低位的16位整型扩展为32位整型。

2.3.5 数据类型转换

数据类型的转换主要在双精度64位浮点数和单精度32位浮点，64位浮点数和32位整型以及32位浮点数和32位整型之间，具体的转换指令如下图

指令前缀为CVTT的表示带截断的类型转换。
在上面，已将三通道的24为像素数据转换为3个32位的整型数据存放在xmm寄存器中，但是下面要做的运算是浮点型的，还需要将32位整型转换为32位的浮点数

cvtdq2ps xmm0, xmm0; //32位整型转换为单精度浮点数

2.4 运算

SSE指令集能够同时在多个数据上执行同一个操作，上面做了那么多操作，就是要将参与运算的数据以需要的格式存放到xmm寄存器中，然后对这些数据同时执行相同的操作。SSE指令集对下面三类常用的运算都有提供

  1. 算术运算
    为了适应各种样的运算环境，SSE也提供了多种样的算术运算。
    pmuludq无符号双字乘法，源操作数和目的操作数的第一个和第三个32位无符号整型参与运算，结果为2个64位整型，存放在目的操作数。这条指令是将乘法的结果依次给出了，但是只能同时进行2个32位的运算（结果为64位）。而有可能我们只关系乘法结果的某一部分（例如高位，判断两个有符号数的符号是否相同）。
    pmullw pack有符号字乘法取低位，16位的乘法运算，将32位结果的低16位保存到目的操作数。

pmulhw pack有符号字乘法取高位，16位的乘法运算，将32位结果的高16位保存到目的操作数。
2. 逻辑
3. 位移
4. 比较
具体的指令这里就不再赘述了，可以参考Intel开发者手册。

3 小结

初次的学习总结就到这里了。使用SSE指令集可以总结为三步：

  1. 将数据从内存移动到xmm寄存器，这里注意指令是否要求16或者32位对齐。
  2. 利用各种unpck和shuffle指令，对xmm寄存器中的数据进行操作，将其组织成后面运算需要的格式。
  3. 对组织好的数据执行运算，注意数据的溢出以及计算的数据类型（浮点、整型、有符号还是无符号），数据的长度（字，双字，四字，双四字）以及指令操作的是高位还是低位等。总之运算时要特别小心，不像在高级语言中那么的省心。
    SSE指令集提供了很丰富的操作，但是Intel的手册查阅却不是很方便....。另外，直接在C/C++中内嵌汇编代码，感觉也很拖沓，下一步准备学习下编译器提供的Intrinsics。
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/wangguchangqing/p/5445652.html