这几天在做学校的一个学习小项目，需要用到SIMD指令计算提速。也是第一次碰这个，看了一些资料和代码，模仿着写了两个函数。

void sse_mul_float(float *A, float *B, int  cnt)：两段内存float数据点乘，结果覆盖第一组内存。

float sse_acc_float(float *A, int cnt)：一组内存float值累加。

注：

1. 没有考虑中间的精确问题，结果会有误差。

2. 每个函数包括指令操作部分和C++语句计算部分。本文附的代码注释介绍指令部分思路。

**3. 关于内存对齐，我不是很懂，所以下面的代码中判断是否对齐的相关语句我写的也不是很正确，所有后面都补上了一点C++的明白操作。

因此，有些指令操作也许没用上。

头文件

  1. #include "time.h"
  2. #include "stdafx.h"
  3. #include<iostream>
  4. #include <stdlib.h>
  5. #include <stdio.h>
  6. #include <tchar.h>
  7. #include <math.h>
  8. #include <time.h>
  9. #include <windows.h>
  10. #include <iomanip>
  11. #include <sys/timeb.h>
  12. using namespace std;

sse_mul_float asm部分

  1.  //MOV EAX,1               ;request CPU feature flags
  2.      //CPUID                   ;0Fh, 0A2h CPUID instruction
  3.      //TEST EDX,4000000h       ;test bit 26 (SSE2)
  4.      //JNZ >L18                ;SSE2 available
  5.  
  6.      int cnt1;
  7.      int cnt2;
  8.      int cnt3;
  9.  
  10.      //we process  the majority by using SSE instructions
  11.      if (((int)A % ) || ((int)B % ))      //如果内存不对齐
  12.      {
  13.  
  14.          cnt1 = cnt / ;                         //该loop一轮处理16个float*float
  15.          cnt2 = (cnt - ( * cnt1)) / ;          //该loop一轮处理4个float*float
  16.          cnt3 = (cnt - ( * cnt1) - ( * cnt2)); //该loop一轮处理1个float*float
  17.  
  18.          _asm
  19.          {
  20.  
  21.              mov edi, A;                      //先将内存地址放入指针寄存器
  22.              mov esi, B;
  23.              mov ecx, cnt1;                  //循环寄存器置值
  24.              jecxz ZERO;                   //如果数据量不超过16个，则跳过L1
  25.  
  26.          L1:
  27.  
  28.              //xmm 寄存器有128bit
  29.              //movups  XMM,XMM/m128
  30.              //传128bit数据,不必对齐内存16字节.
  31.              movups xmm0, [edi];
  32.              movups xmm1, [edi + ];
  33.              movups xmm2, [edi + ];
  34.              movups xmm3, [edi + ];
  35.              //为什么只载入4*4个float?  到上面看看这一轮需要处理多少数据
  36.  
  37.              movups xmm4, [esi];
  38.              movups xmm5, [esi + ];
  39.              movups xmm6, [esi + ];
  40.              movups xmm7, [esi + ];        
  41.  
  42.              //mulps XMM,XMM/m128
  43.              //寄存器按双字对齐,
  44.              //共4个单精度浮点数与目的寄存器里的4个对应相乘,
  45.              //结果送入目的寄存器, 内存变量必须对齐内存16字节.
  46.              mulps xmm0, xmm4;
  47.              mulps xmm1, xmm5;
  48.              mulps xmm2, xmm6;
  49.              mulps xmm3, xmm7;            
  50.  
  51.              //（一个float占4字节，也就是32bit）
  52.              //到这里，xmm0-3寄存器里都有了4个float的乘积结果
  53.              //然后回载到相应内存
  54.              movups[edi], xmm0;
  55.              movups[edi + ], xmm1;
  56.              movups[edi + ], xmm2;
  57.              movups[edi + ], xmm3;        
  58.  
  59.              //记得给指针移位
  60.              //64=16 * 4
  61.              //每一轮处理了16次float * float,每一个float占4字节
  62.              //所以移位应该加64
  63.              add edi, ;
  64.              add esi, ;
  65.  
  66.              loop L1;                            
  67.  
  68.          ZERO:
  69.              mov ecx, cnt2;
  70.              jecxz ZERO1;
  71.  
  72.          L2:
  73.  
  74.              movups xmm0, [edi];           //对于4个float，一个xmm寄存器正好够用
  75.              movups xmm1, [esi];
  76.              mulps xmm0, xmm1;           //对应相乘，结果在xmm0
  77.              movups[edi], xmm0;           //由xmm0回载内存
  78.              add edi, ;               //指针移位
  79.              add esi, ;
  80.  
  81.              loop L2;
  82.  
  83.          ZERO1:
  84.  
  85.              mov ecx, cnt3;
  86.              jecxz ZERO2;
  87.  
  88.              mov eax, ;
  89.  
  90.          L3:                                
  91.  
  92.              movd eax, [edi];            //对于单个float * float，无需sse指令
  93.              imul eax, [esi];
  94.              movd[edi], eax;
  95.              add esi, ;
  96.              add edi, ;
  97.  
  98.              loop L3;
  99.  
  100.          ZERO2:
  101.  
  102.              EMMS;                       //清空
  103.  
  104.          }
  105.  
  106.      }
  107.      else
  108.      {
  109.  
  110.          cnt1 = cnt / ;                          //该loop一轮处理28个float*float
  111.          cnt2 = (cnt - ( * cnt1)) / ;           //该loop一轮处理4个float*float
  112.          cnt3 = (cnt - ( * cnt1) - ( * cnt2));  //该loop一轮处理1个float*float
  113.  
  114.          _asm
  115.          {
  116.  
  117.              mov edi, A;
  118.              mov esi, B;
  119.              mov ecx, cnt1;
  120.              jecxz AZERO;
  121.  
  122.          AL1:
  123.  
  124.              //movaps XMM, XMM / m128
  125.              //把源存储器内容值送入目的寄存器, 当有m128时, 必须对齐内存16字节, 也就是内存地址低4位为0.
  126.              movaps xmm0, [edi];
  127.              movaps xmm1, [edi + ];
  128.              movaps xmm2, [edi + ];
  129.              movaps xmm3, [edi + ];
  130.              movaps xmm4, [edi + ];
  131.              movaps xmm5, [edi + ];
  132.              movaps xmm6, [edi + ];
  133.              //7*4=28，处理28个float*float
  134.  
  135.              mulps xmm0, [esi];            //对应点乘
  136.              mulps xmm1, [esi + ];
  137.              mulps xmm2, [esi + ];
  138.              mulps xmm3, [esi + ];
  139.              mulps xmm4, [esi + ];
  140.              mulps xmm5, [esi + ];
  141.              mulps xmm6, [esi + ];        
  142.  
  143.              movaps[edi], xmm0;            //回载
  144.              movaps[edi + ], xmm1;
  145.              movaps[edi + ], xmm2;
  146.              movaps[edi + ], xmm3;
  147.              movaps[edi + ], xmm4;
  148.              movaps[edi + ], xmm5;
  149.              movaps[edi + ], xmm6;        
  150.  
  151.              add edi, ;
  152.              add esi, ;
  153.  
  154.              loop AL1;                            
  155.  
  156.          AZERO:
  157.              mov ecx, cnt2;
  158.              jecxz AZERO1;
  159.  
  160.          AL2:
  161.  
  162.              movaps xmm0, [edi];
  163.              mulps xmm0, [esi];
  164.              movaps[edi], xmm0;
  165.              add edi, ;
  166.              add esi, ;
  167.  
  168.              loop AL2;
  169.  
  170.          AZERO1:
  171.  
  172.              mov ecx, cnt3;
  173.              jecxz AZERO2;
  174.  
  175.              mov eax, ;
  176.  
  177.          AL3:                                
  178.  
  179.              movd eax, [edi];
  180.              imul eax, [esi];
  181.              movd[edi], eax;
  182.              add esi, ;
  183.              add edi, ;
  184.  
  185.              loop AL3;
  186.  
  187.          AZERO2:
  188.  
  189.              EMMS;
  190.  
  191.          }
  192.  
  193.      }

由于内存对齐的问题，导致末尾有部分数据不正常，特添加C++部分修复。
sse_mul_float c++部分

  1.  int start;
  2.      start = cnt - (cnt % );
  3.      for (int i = start; i < cnt; i++)
  4.      {
  5.          A[i] *= B[i];
  6.      }

用于累加的这个函数，分两块。一块是用指令把大部分数据处理掉，而极少部分数据使用C++语句，这样能各取所长。

sse_acc_float asm部分

  1.  float temp = ;
  2.  
  3.      int cnt1;
  4.      int cnt2;
  5.      int cnt3;
  6.      int select = ;
  7.  
  8.      //we process  the majority by using SSE instructions
  9.      if (((int)A % ))      //unaligned 如果这次调用，内存数据不对齐
  10.      {
  11.          select = ;
  12.  
  13.          cnt1 = cnt / ;
  14.          cnt2 = (cnt - ( * cnt1)) / ;
  15.          cnt3 = (cnt - ( * cnt1) - ( * cnt2));
  16.  
  17.          __asm
  18.          {
  19.  
  20.              mov edi, A;
  21.              mov ecx, cnt1;
  22.              pxor xmm0, xmm0;
  23.              jecxz ZERO;
  24.  
  25.          L1:
  26.  
  27.              movups xmm1, [edi];
  28.              movups xmm2, [edi + ];
  29.              movups xmm3, [edi + ];
  30.              movups xmm4, [edi + ];
  31.              movups xmm5, [edi + ];
  32.              movups xmm6, [edi + ];
  33.  
  34.              //addps 对应相加
  35.              //结果返回目的寄存器
  36.              addps xmm1, xmm2;
  37.              addps xmm3, xmm4;
  38.              addps xmm5, xmm6;
  39.  
  40.              addps xmm1, xmm5;
  41.              addps xmm0, xmm3;
  42.  
  43.              addps xmm0, xmm1;
  44.              //至此，xmm0内4个float的和就是24个float的和
  45.  
  46.              add edi, ;
  47.  
  48.              loop L1;                        
  49.  
  50.          ZERO:
  51.  
  52.              movd ebx, xmm0;      //低4个字节(第一个float)传入ebx
  53.              psrldq xmm0, ;      //xmm0右移4字节
  54.              movd eax, xmm0;      //右移后，低4个字节(第二个float)传入eax
  55.  
  56.              movd xmm1, eax;      //第一个float传入xmm1低32bit
  57.              movd xmm2, ebx;      //第二个float传入xmm2低32bit
  58.              addps xmm1, xmm2;    //两个寄存器内4个float对应相加
  59.              movd eax, xmm1;      //只取我们要的低位float,传入eax
  60.              movd xmm3, eax;      //第一和第二个float的和存在xmm3低32位
  61.              psrldq xmm0, ;      //又截掉一个float
  62.  
  63.              movd ebx, xmm0;      //第三个float进ebx
  64.              psrldq xmm0, ;      //截掉第三个float
  65.              movd eax, xmm0;      //第四个float进eax 
  66.  
  67.              movd xmm1, eax;
  68.              movd xmm2, ebx;
  69.              addps xmm1, xmm2;    //第三和第四个float的和存在xmm1低32位
  70.              movd eax, xmm1;
  71.              movd xmm4, eax;
  72.              addps xmm3, xmm4;    //4个float的和存在xmm3低32位
  73.  
  74.              movd eax, xmm3;
  75.              mov temp, eax;       //这部分求和存在temp地址区
  76.  
  77.              EMMS;                            
  78.  
  79.          }
  80.      }
  81.      else              // aligned   如果这次调用，内存数据对齐
  82.      {
  83.          select = ;
  84.  
  85.          cnt1 = cnt / ;
  86.          cnt2 = (cnt - ( * cnt1)) / ;
  87.          cnt3 = (cnt - ( * cnt1) - ( * cnt2)); 
  88.  
  89.          __asm
  90.          {
  91.  
  92.              mov edi, A;
  93.              mov ecx, cnt1;
  94.              pxor xmm0, xmm0;
  95.              jecxz ZZERO;
  96.  
  97.          LL1:
  98.  
  99.              movups xmm1, [edi];
  100.              movups xmm2, [edi + ];
  101.              movups xmm3, [edi + ];
  102.              movups xmm4, [edi + ];
  103.              movups xmm5, [edi + ];
  104.              movups xmm6, [edi + ];
  105.  
  106.              addps xmm1, xmm2;
  107.              addps xmm3, xmm4;
  108.              addps xmm5, xmm6;
  109.              addps xmm1, xmm5;
  110.              addps xmm0, xmm3;
  111.              addps xmm0, xmm1;
  112.  
  113.              add edi, ;
  114.  
  115.              movups xmm1, [edi];
  116.              movups xmm2, [edi + ];
  117.              movups xmm3, [edi + ];
  118.              movups xmm4, [edi + ];
  119.              movups xmm5, [edi + ];
  120.              movups xmm6, [edi + ];
  121.  
  122.              addps xmm1, xmm2;
  123.              addps xmm3, xmm4;
  124.              addps xmm5, xmm6;
  125.              addps xmm1, xmm5;
  126.              addps xmm0, xmm3;
  127.              addps xmm0, xmm1;
  128.  
  129.              add edi, ;
  130.  
  131.              movups xmm1, [edi];
  132.              movups xmm2, [edi + ];
  133.  
  134.              addps xmm1, xmm2;
  135.              addps xmm0, xmm1;
  136.  
  137.              add edi, ;
  138.  
  139.              loop LL1;                        
  140.  
  141.          ZZERO:
  142.  
  143.              movd ebx, xmm0;
  144.              psrldq xmm0, ;
  145.              movd eax, xmm0;
  146.  
  147.              movd xmm1, eax;
  148.              movd xmm2, ebx;
  149.              addps xmm1, xmm2;
  150.              movd eax, xmm1;
  151.              movd xmm3, eax;
  152.              psrldq xmm0, ;
  153.  
  154.              movd ebx, xmm0;
  155.              psrldq xmm0, ;
  156.              movd eax, xmm0;
  157.  
  158.              movd xmm1, eax;
  159.              movd xmm2, ebx;
  160.              addps xmm1, xmm2;
  161.              movd eax, xmm1;
  162.              movd xmm4, eax;
  163.              addps xmm3, xmm4;
  164.  
  165.              movd eax, xmm3;
  166.              mov temp, eax;
  167.  
  168.              EMMS;                            
  169.  
  170.          }
  171.      }

sse_acc_float   c++部分

  1. //上面的select记录本次调用sse_acc_float时，数据是否对齐内存
  2.     //下面分情况把剩余的和累加
  3.     int start;
  4.     float c = 0.0f;
  5.     if (select == )
  6.     {
  7.  
  8.         start = cnt - (cnt % );
  9.         for (int i = start; i < cnt; i++)
  10.         {
  11.             c += A[i];
  12.         }
  13.  
  14.     }
  15.     else
  16.     {
  17.         start = cnt - (cnt % );
  18.         for (int i = start; i < cnt; i++)
  19.         {
  20.             c += A[i];
  21.         }
  22.  
  23.     }
  24.  
  25.     //temp 是用指令计算 ，大部分数据的和
  26.     //c    是用C++语句计算， 所有数据模24或者56剩余部分数据的和
  27.     return(temp + c);

推荐参考：SIMD(单道指令多道数据流)指令(MMX/SSE1/SSE2)详解(中文).

我是一名编程菜鸟，有什么技术上的问题，欢迎讨论和交流指正。谢谢！

获取全部源码：点此  dot_acc.cpp

SIMD学习 -- 用SSE2指令作点乘和累加计算的更多相关文章

  1. Docker技术入门与实战 第二版-学习笔记-3-Dockerfile 指令详解

    前面已经讲解了FROM.RUN指令,还提及了COPY.ADD,接下来学习其他的指令 5.Dockerfile 指令详解 1> COPY 复制文件 格式: COPY  <源路径> .. ...

  2. 学习AngularJs:Directive指令用法（完整版）

    这篇文章主要学习AngularJs:Directive指令用法,内容很全面,感兴趣的小伙伴们可以参考一下   本教程使用AngularJs版本:1.5.3 AngularJs GitHub: http ...

  3. 【js类库AngularJs】学习angularJs的指令（包括常见表单验证，隐藏等功能）

    [js类库AngularJs]学习angularJs的指令(包括常见表单验证,隐藏等功能) AngularJS诞生于2009年,由Misko Hevery 等人创建,后为Google所收购.是一款优秀 ...

  4. Linux学习日志——基本指令②

    文章目录 Linux学习日志--基本指令② 前言 touch cp (copy) mv (move) rm vim 输出重定向(> 或 >>) cat df(disk free) f ...

  5. vue学习04 v-on指令

    vue学习04 v-on指令 v-on的作用是为元素绑定事件,比如click单击,dbclick双击 v-on指令可简写为@ 代码测试 <!DOCTYPE html> <html l ...

  6. vue学习06 v-show指令

    目录 vue学习06 v-show指令 v-show指令是:根据真假切换元素的显示状态 原理是修改元素的display,实现显示隐藏 指令后面的内容,最终都会解析为布尔值(true和false) 练习 ...

  7. vue学习08 v-bind指令

    目录 vue学习08 v-bind指令 v-bind指令的作用是为元素绑定属性 完整写法是v-bind:属性名,可简写为:属性名 练习代码为: 运行效果为: vue学习08 v-bind指令 v-bi ...

  8. SIMD指令集——一条指令操作多个数，SSE，AVX都是，例如：乘累加，Shuffle等

    SIMD指令集 from:https://zhuanlan.zhihu.com/p/31271788 SIMD,即Single Instruction, Multiple Data,一条指令操作多个数 ...

  9. 重温JSP学习笔记--三大指令九大内置对象

    最近在温习javaweb的相关基础知识,鉴于我弄丢了记满了整整一本的笔记,决定以后把笔记和一些学习上的心得以及碰到的一些问题统统都放在网上,今天看了一下jsp的相关基础,以下是笔记: JSP三大指令: ...

随机推荐

  1. BZOJ_2424_[HAOI2010]订货_最小费用最大流

    BZOJ_2424_[HAOI2010]订货_最小费用最大流 Description 某公司估计市场在第i个月对某产品的需求量为Ui,已知在第i月该产品的订货单价为di,上个月月底未销完的单位产品要付 ...

  2. bzoj3262 陌上花开——CDQ分治

    题目:https://www.lydsy.com/JudgeOnline/problem.php?id=3262 第一道CDQ分治题! 看博客:https://www.cnblogs.com/Narh ...

  3. nginx开发（四）调用ffmpeg，搭建rtmp直播流。

    1: 修改conf文件,配置rtmp直播 打开usr/local/nginx/conf/nginx.conf,添加红色内容: rtmp {#rtmp点播配置    server {        li ...

  4. java笔记线程方式1获取对象名称

    * 如何获取线程对象的名称呢? * public final String getName():获取线程的名称. * 如何设置线程对象的名称呢? * public final void setName ...

  5. 《Effective C++》笔记：III（转载）

    转自:http://www.cnblogs.com/destino74/p/3960802.html 条款5:Know what functions C++ silently writes and c ...

  6. Spring Theme简单应用

    Spring MVC特性里由一个是关于Spring Theme主题的应用,所以写了个Demo 1.这里先看项目结构(Meven项目) 2.所需的POM依赖 <dependency> < ...

  7. bzoj 4808: 马【匈牙利算法】

    网格图黑白染色,然后能互相攻击到的点之间连边,跑匈牙利算法最大匹配,答案是好点个数-最大匹配(最大独立集) 注意pao的时候只从一种颜色的格子统计即可 #include<iostream> ...

  8. [App Store Connect帮助]四、添加 App 图标、App 预览和屏幕快照（2）添加一个 App Store 图标

    您必须提供一个 App Store 图标,用于在 App Store 中的不同部分展示您的 App.请遵照 Human Interface Guidelines(<人机界面准则>)创建您的 ...

  9. 乐字节Java8核心特性之方法引用

    大家好,我是乐字节的小乐,上一次我们说到了Java8核心特性之函数式接口,接下来我们继续了解Java8又一核心特性--方法引用. Java8 中引入方法引用新特性,用于简化应用对象方法的调用, 方法引 ...

  10. Android之条形码、二维码扫描框架(非原创）

    文章大纲 一.条形码.二维码扫描框架介绍二.条形码.二维码的区别和组成结构介绍三.条形码.二维码扫描框架应用场景四.BGAQRCode-Android框架实战五.项目源码下载六.参考文章 一.条形码. ...