数学研发网设为首页收藏本站
切换到窄版

 找回密码
 欢迎注册
数学研发论坛»论坛 › 【算法研发】 › 编程擂台 › x86上128位二进制乘法最快速算法征解
1 ...67891011121314... 15下一页
返回列表 发新帖
楼主: 无心人

[擂台] x86上128位二进制乘法最快速算法征解

[复制链接]
无心人
 楼主| 发表于 2008-3-27 13:39:04 | 显示全部楼层
想到一个节约指令的拆解方法 假设数据在mm0 mm7=0 movq mm1, mm0 punpckhdq mm1, mm7 punpckldq mm0, mm7 则分解mm0=mm1:mm0
毋因群疑而阻独见　　毋任己意而废人言
毋私小惠而伤大体　　毋借公论以快私情
回复 支持 反对

使用道具 举报

无心人
 楼主| 发表于 2008-3-27 14:46:54 | 显示全部楼层
void UInt128x128To256_SSE2_92F( UINT32 * const result, const UINT32 * const left, const UINT32 * const right ) { __asm { mov eax, [left] mov edx, [right] mov ecx, [result] movd mm0, [eax] pmuludq mm0, [edx] //mm0 = 0:0 pxor mm7, mm7 //mm7 = 0 movd [ecx], mm0 punpckhdq mm0, mm7 movd mm1, [eax] pmuludq mm1, [edx+4] //mm1=0:1 movd mm2, [edx] pmuludq mm2, [eax+4] //mm2=1:0 movq mm3, mm1 punpckhdq mm3, mm7 punpckldq mm1, mm7 movq mm4, mm2 punpckhdq mm4, mm7 punpckldq mm2, mm7 paddq mm0, mm1 paddq mm0, mm2 paddq mm3, mm4 movd [ecx+4], mm0 punpckhdq mm0, mm7 paddq mm0, mm3 movd mm1, [eax+4] pmuludq mm1, [edx+4] //mm1=1:1 movd mm2, [eax] pmuludq mm2, [edx+8] //mm2=0:2 movd mm3, [edx] pmuludq mm3, [eax+8] //mm3=2:0 movq mm4, mm1 punpckhdq mm4, mm7 punpckldq mm1, mm7 movq mm5, mm2 punpckhdq mm5, mm7 punpckldq mm2, mm7 movq mm6, mm3 punpckhdq mm6, mm7 punpckldq mm3, mm7 paddq mm0, mm1 paddq mm4, mm5 paddq mm0, mm2 paddq mm4, mm6 paddq mm0, mm3 movd [ecx+8], mm0 punpckhdq mm0, mm7 paddq mm0, mm4 movd mm1, [eax] pmuludq mm1, [edx+12] //mm1=0:3 movd mm2, [eax+12] pmuludq mm2, [edx] //mm2=3：0 movq mm4, mm1 punpckhdq mm4, mm7 punpckldq mm1, mm7 movq mm5, mm2 punpckhdq mm5, mm7 punpckldq mm2, mm7 paddq mm0, mm1 paddq mm4, mm5 paddq mm0, mm2 movd mm1, [eax+4] pmuludq mm1, [edx+8] //mm1=1:2 movd mm2, [edx+4] pmuludq mm2, [eax+8] //mm2=2:1 movq mm5, mm1 punpckhdq mm5, mm7 punpckldq mm1, mm7 movq mm6, mm2 punpckhdq mm6, mm7 punpckldq mm2, mm7 paddq mm0, mm1 paddq mm4, mm5 paddq mm0, mm2 paddq mm4, mm6 movd [ecx+12], mm0 punpckhdq mm0, mm7 paddq mm0, mm4 movd mm1, [eax+8] pmuludq mm1, [edx+8] //mm1=2:2 movd mm2, [eax+4] pmuludq mm2, [edx+12] //mm2=1:3 movd mm3, [edx+4] pmuludq mm3, [eax+12] //mm3=3:1 movq mm4, mm1 punpckhdq mm4, mm7 punpckldq mm1, mm7 movq mm5, mm2 punpckhdq mm5, mm7 punpckldq mm2, mm7 movq mm6, mm3 punpckhdq mm6, mm7 punpckldq mm3, mm7 paddq mm0, mm1 paddq mm4, mm5 paddq mm0, mm2 paddq mm4, mm6 paddq mm0, mm3 movd [ecx+16], mm0 punpckhdq mm0, mm7 paddq mm0, mm4 movd mm1, [eax+8] pmuludq mm1, [edx+12] //mm1=2:3 movd mm2, [edx+8] pmuludq mm2, [eax+12] //mm2=3:2 movq mm3, mm1 punpckhdq mm3, mm7 punpckldq mm1, mm7 movq mm4, mm2 punpckhdq mm4, mm7 punpckldq mm2, mm7 paddq mm0, mm1 paddq mm0, mm2 paddq mm3, mm4 movd [ecx+20], mm0 punpckhdq mm0, mm7 paddq mm0, mm3 movd mm1, [eax+12] pmuludq mm1, [edx+12] paddq mm0, mm1 movq [ecx+24], mm0 emms } } 时间不理想
毋因群疑而阻独见　　毋任己意而废人言
毋私小惠而伤大体　　毋借公论以快私情
回复 支持 反对

使用道具 举报

无心人
 楼主| 发表于 2008-3-27 21:32:25 | 显示全部楼层
76有问题 movq [RESULT_REG+24], mm5 psrlq mm5, 32 //carry //------保存最高DWORD movq [RESULT_REG+28], mm5 //mm3,中间结果 ================================= 就是movq [RESULT_REG+24], mm5 不知道后面两条啥意思？ 另外最后一条应该是movd 如果写movq 存在内存溢出危险
毋因群疑而阻独见　　毋任己意而废人言
毋私小惠而伤大体　　毋借公论以快私情
回复 支持 反对

使用道具 举报

liangbch
发表于 2008-3-27 22:30:59 | 显示全部楼层
完全采用SSE2指令的一个版本，指令数110条，比预期的指令少要多，仅仅比76楼少一条指令。这个版本全部使用XMM寄存器。解包主要采用pshufd指令来实现。尽管指令数不多，但却比采用我的另一个使用MMX寄存器的版本慢上好多（在PIV 2.6G上测试的结果). 个人感觉，一次计算2组 32bit * 32bit 的SSE2指令并没有带来多大收益，就这个题目而言，使用MMX寄存器可能是一个好的选择。下面是完整的源代码。
  1. _declspec(naked)
  2. void UInt128x128To256_SSE2_94F( UINT32 * const result,
  3. const UINT32 * const left,
  4. const UINT32 * const right )
  5. // 使用XMM寄存器
  6. // 16次乘法，分4趟，
  7. // 操作数一律在xmm 寄存器中进行,每次乘法 计算2 组 32bit * 32 bit 乘法，每次加法 仅仅使用低64bit
  8. // 第1趟计算 left[] * right[0]
  9. // 第2趟计算 left[] * right[1]
  10. // 第3趟计算 left[] * right[2]
  11. // 第4趟计算 left[] * right[3]
  13. // 每趟的计算结果为 5 DWORD，最低位DWORD 直接存储到result, 前3趟的计算结果的高4个DWORD（中间结果)存储到一组寄存器
  15. // 寄存器的使用
  16. // 1. 中间结果 放入 xmm0,xmm1,xmm2,xmm3
  17. // 2。乘数 使用 xmm4
  18. // 2. 乘积1 使用 xmm5
  19. // 3. 乘积2 使用 xmm6
  20. // 4. 进位 使用 xmm7
  21. // 5. 掩码 依然使用xmm5, 和 乘积1 分时复用
  22. // 可以看到8个mmx寄存器全部派上用场
  24. {
  25. #define LEFT_REG eax
  26. #define RIGHT_REG edx
  27. #define RESULT_REG ecx
  29. #define T0_REG xmm0
  30. #define T1_REG xmm1
  31. #define T2_REG xmm2
  32. #define T3_REG xmm3
  34. #undef MUL_REG
  35. #define MUL_REG xmm4
  37. #undef MASK_REG
  38. #define MASK_REG xmm5
  40. #define PROD_1_REG xmm5
  41. #define PROD_2_REG xmm6
  42. #define CARRY_REG xmm7
  44. // 记号 XX00, 表示当前 128bit 寄存器的 值状态，每个字符表示32bit, X表示有数，0表示这部分为0
  45. // 第1个字符bit0-bit31, 第2个表示bit32-bit63,
  46. // 第3个字符bit64-bit95, 最后1个字符表示bit96-bit127
  47. // D0: 表示寄存器的 bit0-bit31
  48. // D1: 表示寄存器的 bit32-bit63,
  49. // D2: 表示寄存器的 bit64-bit95,
  50. // D3: 表示寄存器的 bit96-bit127
  51. // -〉表示传送
  53. __asm
  54. {
  55. mov RIGHT_REG, dword ptr[esp + 0Ch] ; right
  56. mov LEFT_REG, dword ptr [esp + 08h] ; left
  57. mov RESULT_REG, dword ptr[esp + 04h] ; result
  58. push ebx
  59. mov ebx,0xffffffff //置掩码,用来清除高位,仅仅保留低32bit
  61. //第1趟乘开始---
  62. movq MUL_REG, qword ptr [RIGHT_REG]
  63. pshufd MUL_REG, MUL_REG, 01000100b // R[0] -> 0:3, R[1] -> 2:4
  65. movdqu PROD_1_REG, [LEFT_REG] // 将4个DWORD一次载入
  66. pshufd PROD_2_REG, PROD_1_REG, 00110010b // L[2:3] -> PROD_2_REG
  67. pshufd PROD_1_REG, PROD_1_REG, 11011100b // L[0:1] -> PROD_1_REG
  69. //-------- 第1,2次乘
  70. pmuludq PROD_1_REG, MUL_REG // L[0:1] * R[0], XXXX
  71. movd [RESULT_REG],PROD_1_REG // store low32 bit of L0 * R[0]
  72. psrldq PROD_1_REG, 4 // PROD_1_REG >>= 32, high 32 bit is full zero,shape XXX0
  73. pshufd CARRY_REG, PROD_1_REG, 11111100b // 将carry分解出来, X0000
  74. psrldq PROD_1_REG, 4 // PROD_1_REG:[D0,D1]= L1*R[0],RROD_1_REG: XX00
  75. paddq PROD_1_REG, CARRY_REG // PROD_1_REG:[D0,D1]= L1 * R[0] + carry, RROD_1_REG: XX00
  77. //----插入第3,4次乘指令
  78. pmuludq PROD_2_REG, MUL_REG //PROD_2_REG:[D0-D4]= L[2:3] * R[0], PROD_2_REG:XXXX
  80. pshufd T0_REG, PROD_1_REG, 11111100b // T0= L1 * R[0], T0_REG: X0000
  81. pshufd CARRY_REG, PROD_1_REG, 11111101b // high 32bit of L1 * R[0] -->carry, carry,X0000
  83. movd MASK_REG, ebx
  84. paddq PROD_2_REG, CARRY_REG // PROD_2_REG += carry, PROD_2_REG:XXXX
  85. movdqa T1_REG, PROD_2_REG // T1= L2 * RO, T1_REG: XXXX
  87. psrldq PROD_2_REG, 4 // PROD_2_REG: XXX0
  88. pand T1_REG, MASK_REG // T1_REG: X0000
  90. pshufd CARRY_REG, PROD_2_REG, 11111100b // 将carry分解出来, CARRY_REG:X0000
  91. psrldq PROD_2_REG, 4 // PROD_2_REG = L3 *R[0], PROD_2_REG:XX00
  92. paddq PROD_2_REG, CARRY_REG // PROD_2_REG = L3 *R[0] + carry, PROD_2_REG:XX00
  94. pshufd T2_REG, PROD_2_REG, 11111100b // PROD_2_REG:D0 -> T2, T2:X0000
  95. pshufd T3_REG, PROD_2_REG, 11111101b // PROD_2_REG:D0 -> T3, T3 :X0000
  98. //----第二趟乘开始
  99. psrldq MUL_REG, 4
  101. movdqu PROD_1_REG, [LEFT_REG] // 将4个DWORD一次载入
  102. pshufd PROD_2_REG, PROD_1_REG, 00110010b // L[2:3] -> PROD_2_REG
  103. pshufd PROD_1_REG, PROD_1_REG, 11011100b // L[0:1] -> PROD_1_REG
  105. // 第5,6次乘
  106. pmuludq PROD_1_REG, MUL_REG // L[0:1] * R[1], PROD_1_REG:XXXX
  107. paddq PROD_1_REG, T0_REG // L[0:1] * R[1] + t0, PROD_1_REG:XXXX
  108. movd [RESULT_REG+4],PROD_1_REG // PROD_1_REG:D0 -> result
  109. psrldq PROD_1_REG, 4 // PROD_1_REG >>= 32, PROD_1_REG: XXX0
  110. pshufd CARRY_REG, PROD_1_REG, 11111100b // 将carry分解出来,PROD_1_REG:D0 -> carry
  111. psrldq PROD_1_REG, 4 // PROD_1_REG>>32, PROD_1_REG: XX00
  112. paddq PROD_1_REG, CARRY_REG // PROD_1_REG += carry, PROD_1_REG:XX00
  113. paddq PROD_1_REG, T1_REG // PROD_1_REG += T1, PROD_1_REG:XX00
  115. //- 插入第7,8次乘指令
  116. pmuludq PROD_2_REG, MUL_REG // L[2:3] * R[1], PROD_2_REG:XXXX
  118. pshufd T0_REG, PROD_1_REG, 11111100b // PROD_1_REG:D0 -> T0, T0:X000
  119. pshufd CARRY_REG, PROD_1_REG, 11111101b // PROD_1_REG:D1 -> carry, carry:X000
  121. movd MASK_REG, ebx
  122. paddq PROD_2_REG, CARRY_REG // PROD_2_REG +=carry
  123. paddq PROD_2_REG, T2_REG // PROD_2_REG += T2, PROD_2_REG:XX00
  124. movdqa T1_REG, PROD_2_REG // PROD_2_REG -> T1, T1:XXXX
  126. psrldq PROD_2_REG, 4 // PROD_2_REG: XXX0
  127. pand T1_REG, MASK_REG // T1:X000
  129. pshufd CARRY_REG, PROD_2_REG, 11111100b // 将carry分解出来, carry:X0000
  130. psrldq PROD_2_REG, 4 // PROD_2_REG>>32, PROD_2_REG: XX00
  131. paddq PROD_2_REG, CARRY_REG // PROD_2_REG += carry, PROD_2_REG:XX00
  132. paddq PROD_2_REG, T3_REG // PROD_2_REG += T3, PROD_2_REG:XX00
  134. pshufd T2_REG, PROD_2_REG, 11111100b //PROD_2_REG:D0 -> T2, T2:X000
  135. pshufd T3_REG, PROD_2_REG, 11111101b //PROD_2_REG:D1 -> T3, T3:X000
  138. // 第3趟乘开始 -
  139. movq MUL_REG, qword ptr [RIGHT_REG+8]
  140. pshufd MUL_REG, MUL_REG, 01000100b // R[0] -> 0:3, R[1] -> 2:4
  142. movdqu PROD_1_REG, [LEFT_REG] // 将4个DWORD一次载入
  143. pshufd PROD_2_REG, PROD_1_REG, 00110010b // L[2:3] -> PROD_2_REG
  144. pshufd PROD_1_REG, PROD_1_REG, 11011100b // L[0:1] -> PROD_1_REG
  147. // 第9,10 次乘
  148. pmuludq PROD_1_REG, MUL_REG // L[0:1] * R[2], PROD_1_REG:XXXX
  149. paddq PROD_1_REG, T0_REG // L[0:1] * R[2] + t0, PROD_1_REG:XXXX
  150. movd [RESULT_REG+8],PROD_1_REG // PROD_1_REG:D0 -> result
  151. psrldq PROD_1_REG, 4 // PROD_1_REG >>= 32, PROD_1_REG: XXX0
  152. pshufd CARRY_REG, PROD_1_REG, 11111100b // 将carry分解出来,PROD_1_REG:D0 -> carry
  153. psrldq PROD_1_REG, 4 // PROD_1_REG: XX00
  154. paddq PROD_1_REG, CARRY_REG // PROD_1_REG += carry, PROD_1_REG:XX00
  155. paddq PROD_1_REG, T1_REG // PROD_1_REG += T1, PROD_1_REG:XX00
  157. //- 插入第11,12次乘指令
  158. pmuludq PROD_2_REG, MUL_REG // L[2:3] * R[2], PROD_2_REG:XXXX
  160. pshufd T0_REG, PROD_1_REG, 11111100b // PROD_1_REG:D0 -> T0, T0:X000
  161. pshufd CARRY_REG, PROD_1_REG, 11111101b // PROD_1_REG:D1 -> carry, carry:X000
  163. movd MASK_REG, ebx
  164. paddq PROD_2_REG, CARRY_REG // PROD_2_REG += carry
  165. paddq PROD_2_REG, T2_REG // PROD_1_REG += T2, PROD_1_REG:XX00
  166. movdqa T1_REG, PROD_2_REG // PROD_2_REG -> T1, T1:XXXX
  168. psrldq PROD_2_REG, 4 // PROD_2_REG>>32, PROD_2_REG: XXX0
  169. pand T1_REG, MASK_REG // T1:X000
  171. pshufd CARRY_REG, PROD_2_REG, 11111100b // 将carry分解出来, carry:X0000
  172. psrldq PROD_2_REG, 4 // PROD_2_REG>>32, PROD_2_REG: XX00
  173. paddq PROD_2_REG, CARRY_REG // PROD_2_REG += carry, PROD_2_REG:XX00
  174. paddq PROD_2_REG, T3_REG // PROD_2_REG += T3, PROD_2_REG:XX00
  176. pshufd T2_REG, PROD_2_REG, 11111100b //PROD_2_REG:D0 -> T2, T2:X000
  177. pshufd T3_REG, PROD_2_REG, 11111101b //PROD_2_REG:D1 -> T3, T3:X000
  180. // 第4 趟乘开始 -
  181. psrldq MUL_REG, 4 //
  183. movdqu PROD_1_REG, [LEFT_REG] // 将4个DWORD一次载入
  184. pshufd PROD_2_REG, PROD_1_REG, 00110010b // L[2:3] -> PROD_2_REG
  185. pshufd PROD_1_REG, PROD_1_REG, 11011100b // L[0:1] -> PROD_1_REG
  187. // 第13,14 次乘
  188. pmuludq PROD_1_REG, MUL_REG // L[0:1] * R[3], PROD_1_REG:XXXX
  189. paddq PROD_1_REG, T0_REG // L[0:1] * R[3]+ t0, PROD_1_REG:XXXX
  190. movd [RESULT_REG+12],PROD_1_REG // PROD_1_REG:D0 -> result
  191. psrldq PROD_1_REG, 4 // PROD_1_REG >>= 32, PROD_1_REG: XXX0
  192. pshufd CARRY_REG, PROD_1_REG, 11111100b // 将carry分解出来,PROD_1_REG:D0 -> carry
  193. psrldq PROD_1_REG, 4 // PROD_1_REG>>32, PROD_1_REG: XX00
  194. paddq PROD_1_REG, CARRY_REG // PROD_1_REG += carry, PROD_1_REG:XX00
  195. paddq PROD_1_REG, T1_REG
  197. //- 插入第15,16次乘指令
  198. pmuludq PROD_2_REG, MUL_REG // L[2:3] * R[3], PROD_2_REG:XXXX
  200. movd [RESULT_REG+16], PROD_1_REG // PROD_1_REG:D0
  201. pshufd CARRY_REG, PROD_1_REG, 11111101b // PROD_1_REG:D1 -> carry, carry:X000
  203. paddq PROD_2_REG, CARRY_REG // PROD_2_REG +=carry
  204. paddq PROD_2_REG, T2_REG // PROD_2_REG +=carry
  205. movd [RESULT_REG+20], PROD_2_REG // PROD_2_REG -> T1, T1:XXXX
  207. psrldq PROD_2_REG, 4 // PROD_2_REG>>32, PROD_2_REG: XXX0
  209. pshufd CARRY_REG, PROD_2_REG, 11111100b // 将carry分解出来, carry:X0000
  210. psrldq PROD_2_REG, 4 // PROD_2_REG>>32, PROD_2_REG: XX00
  211. paddq PROD_2_REG, CARRY_REG // PROD_2_REG += carry, PROD_2_REG:XX00
  212. paddq PROD_2_REG, T3_REG
  213. movq qword ptr [RESULT_REG+24],PROD_2_REG
  215. // 恢复寄存器
  216. pop ebx
  217. ret
  218. }
  219. }
复制代码
毋因群疑而阻独见　　毋任己意而废人言
毋私小惠而伤大体　　毋借公论以快私情
回复 支持 反对

使用道具 举报

liangbch
发表于 2008-3-27 22:37:41 | 显示全部楼层
原帖由 无心人 于 2008-3-27 21:32 发表 76有问题 movq [RESULT_REG+24], mm5 psrlq mm5, 32 //carry //------保存最高DWORD ...
movq 表示一次写2个DWORD（8个byte）和movdqa不同，并不需要16字节对齐。如果不是特别处理，right，left，result应为DWORD数组，一定是4字节对齐的，所以使用这条指令不会出错。 关于最后的指令，我仔细看了下，确实有问题，下面的2条指令应该删除。 “psrlq mm5, 32” 和 “ movq [RESULT_REG+28], mm5”，如此速度更快些。
毋因群疑而阻独见　　毋任己意而废人言
毋私小惠而伤大体　　毋借公论以快私情
回复 支持 反对

使用道具 举报

liangbch
发表于 2008-3-27 22:50:57 | 显示全部楼层
正如无心人所言，第76#程序有个bug,就是对result缓冲区多写了4个byte，不过结果却是正确的。修复后的版本见下，减少了2条指令，加上Emms指令，指令条数和94楼，56楼持平（110 条）。不知有谁会破了这个记录。
  1. _declspec(naked)
  2. void UInt128x128To256_SSE2_96F( UINT32 * const result,
  3. const UINT32 * const left,
  4. const UINT32 * const right )
  5. // 使用MMX寄存器， 但用SSE2指令
  6. // 指令的使用，乘法 使用 32bit * 32bit 的MMX指令，加法使用 64 bit + 64 bit 的SSE2指令
  8. // 16次乘法，分4趟， 操作数一律在mmx 寄存器中进行
  9. // 第1趟计算 left[] * right[0]
  10. // 第2趟计算 left[] * right[1]
  11. // 第3趟计算 left[] * right[2]
  12. // 第4趟计算 left[] * right[3]
  14. // 每趟的计算结果为 5 DWORD，最低位DWORD 直接存储到result, 前3趟的计算结果的高4个DWORD（中间结果)存储到一组寄存器
  16. // 寄存器的使用
  18. // 中间结果 放入 mm0,mm1,mm2,mm3
  20. // 掩码寄存器 mm7, 用来请64位寄存器的高32bit
  21. // 进位 寄存器 和 当前乘积寄存器 为 mm4 和 mm5,轮换使用
  22. // 乘数 寄存器 mm6
  23. // 可以看到8个mmx寄存器全部派上用场
  25. {
  26. #define LEFT_REG eax
  27. #define RIGHT_REG edx
  28. #define RESULT_REG ecx
  29. #define MASK_REG mm7
  30. #define MUL_REG mm6
  32. __asm
  33. {
  34. mov eax, 0xffffffff
  35. mov RESULT_REG, dword ptr[esp + 04h] ; result
  36. movd MASK_REG, eax
  38. mov RIGHT_REG, dword ptr[esp + 0Ch] ; right
  39. movq MUL_REG, [RIGHT_REG]
  40. mov LEFT_REG, dword ptr [esp + 08h] ; left
  43. //--------第1次乘
  44. movd mm4, [LEFT_REG+0]
  45. pmuludq mm4, MUL_REG
  46. movd [RESULT_REG], mm4
  47. psrlq mm4, 32 //carry
  49. //------第2次乘
  50. movd mm5, [LEFT_REG+4]
  51. pmuludq mm5, MUL_REG
  52. paddq mm5, mm4 //64bit + 32 bit carry
  53. movq mm0, mm5
  54. psrlq mm5, 32 //carry
  55. pand mm0, MASK_REG //mm0,中间结果
  57. //------第3次乘
  58. movd mm4, [LEFT_REG+8]
  59. pmuludq mm4, MUL_REG
  60. paddq mm4, mm5 //64bit + 32 bit carry
  61. movq mm1, mm4
  62. psrlq mm4, 32 //carry
  63. pand mm1, MASK_REG //mm1,中间结果
  65. //------第4次乘
  66. movd mm5, [LEFT_REG+12]
  67. pmuludq mm5, MUL_REG
  68. paddq mm5, mm4 //64bit + 32 bit carry
  69. movq mm2, mm5
  70. psrlq mm5, 32 //carry
  71. pand mm2, MASK_REG //mm2,中间结果
  72. movq mm3, mm5 //mm3,中间结果
  74. //----得到乘数
  75. psrlq MUL_REG, 32 //得到right[1]
  78. //---第二趟乘---------
  80. //--------第5次乘
  81. movd mm4, [LEFT_REG+0]
  82. pmuludq mm4, MUL_REG
  83. paddq mm4, mm0 // 64bit + 32 bit 中间结果
  84. movd [RESULT_REG+4], mm4
  85. psrlq mm4, 32 //carry
  87. //------第6次乘
  88. movd mm5, [LEFT_REG+4]
  89. pmuludq mm5, MUL_REG
  90. paddq mm5, mm4 //64bit + 32 bit carry
  91. paddq mm5, mm1 //64bit + 32 bit 中间结果
  92. movq mm0, mm5
  93. psrlq mm5, 32 //carry
  94. pand mm0, MASK_REG //mm0,中间结果
  96. //------第7次乘
  97. movd mm4, [LEFT_REG+8]
  98. pmuludq mm4, MUL_REG
  99. paddq mm4, mm5 //64bit + 32 bit carry
  100. paddq mm4, mm2 //64bit + 32 bit 中间结果
  101. movq mm1, mm4
  102. psrlq mm4, 32 //carry
  103. pand mm1, MASK_REG //mm1,中间结果
  105. //------第8次乘
  106. movd mm5, [LEFT_REG+12]
  107. pmuludq mm5, MUL_REG
  108. paddq mm5, mm4 //64bit + 32 bit carry
  109. paddq mm5, mm3 //64bit + 32 bit 中间结果
  110. movq mm2, mm5
  111. psrlq mm5, 32 //carry
  112. pand mm2, MASK_REG //mm2,中间结果
  113. movq mm3, mm5 //mm3,中间结果
  115. //----得到乘数
  116. movq MUL_REG, [RIGHT_REG+8]
  118. //--------第9次乘
  119. movd mm4, [LEFT_REG+0]
  120. pmuludq mm4, MUL_REG
  121. paddq mm4, mm0 // 64bit + 32 bit 中间结果
  122. movd [RESULT_REG+8], mm4
  123. psrlq mm4, 32 //carry
  125. //------第10次乘
  126. movd mm5, [LEFT_REG+4]
  127. pmuludq mm5, MUL_REG
  128. paddq mm5, mm4 //64bit + 32 bit carry
  129. paddq mm5, mm1 //64bit + 32 bit 中间结果
  130. movq mm0, mm5
  131. psrlq mm5, 32 //carry
  132. pand mm0, MASK_REG //mm0,中间结果
  134. //------第11次乘
  135. movd mm4, [LEFT_REG+8]
  136. pmuludq mm4, MUL_REG
  137. paddq mm4, mm5 //64bit + 32 bit carry
  138. paddq mm4, mm2 //64bit + 32 bit 中间结果
  139. movq mm1, mm4
  140. psrlq mm4, 32 //carry
  141. pand mm1, MASK_REG //mm1,中间结果
  143. //------第12次乘
  144. movd mm5, [LEFT_REG+12]
  145. pmuludq mm5, MUL_REG
  146. paddq mm5, mm4 //64bit + 32 bit carry
  147. paddq mm5, mm3 //64bit + 32 bit 中间结果
  148. movq mm2, mm5
  149. psrlq mm5, 32 //carry
  150. pand mm2, MASK_REG //mm2,中间结果
  151. movq mm3, mm5 //mm3,中间结果
  154. //----得到乘数
  155. psrlq MUL_REG, 32 //得到right[1]
  157. //--------第13次乘
  158. movd mm4, [LEFT_REG+0]
  159. pmuludq mm4, MUL_REG
  160. paddq mm4, mm0 // 64bit + 32 bit 中间结果
  161. movd [RESULT_REG+12], mm4
  162. psrlq mm4, 32 //carry
  164. //------第14次乘
  165. movd mm5, [LEFT_REG+4]
  166. pmuludq mm5, MUL_REG
  167. paddq mm5, mm4 //64bit + 32 bit carry
  168. paddq mm5, mm1 //64bit + 32 bit 中间结果
  169. movd [RESULT_REG+16], mm5
  170. psrlq mm5, 32 //carry
  173. //------第15次乘
  174. movd mm4, [LEFT_REG+8]
  175. pmuludq mm4, MUL_REG
  176. paddq mm4, mm5 //64bit + 32 bit carry
  177. paddq mm4, mm2 //64bit + 32 bit 中间结果
  178. movd [RESULT_REG+20], mm4
  179. psrlq mm4, 32 //carry
  182. //------第16次乘
  183. movd mm5, [LEFT_REG+12]
  184. pmuludq mm5, MUL_REG
  185. paddq mm5, mm4 //64bit + 32 bit carry
  186. paddq mm5, mm3 //64bit + 32 bit
  187. movq [RESULT_REG+24], mm5
  189. emms
  190. ret
  191. }
  192. }
复制代码
毋因群疑而阻独见　　毋任己意而废人言
毋私小惠而伤大体　　毋借公论以快私情
回复 支持 反对

使用道具 举报

无心人
 楼主| 发表于 2008-3-28 07:58:00 | 显示全部楼层
我说的并不是他指令错误 而是最后还4个字节位置 用8字节写，至少在我的VC2008肯定是抛出异常的 ：） ======================================== 另外，我觉得 双乘并不弱于MMX，关键在我们的指令安排可能存在问题 现在想起来，16个乘，如果每条用6个指令加结果，就至少100条了 而我想，减少每次乘法后结果的指令数是很困难的 如果仔细比较，你们会发现，这次时间已逼近你们96bit的算法的时间了 而按照比率，这次最佳时间是上次的1.5倍以上 现在是否突破了上次的1.5倍呢？
毋因群疑而阻独见　　毋任己意而废人言
毋私小惠而伤大体　　毋借公论以快私情
回复 支持 反对

使用道具 举报

无心人
 楼主| 发表于 2008-3-31 11:09:15 | 显示全部楼层
怎么停顿了 不想讨论了么？
毋因群疑而阻独见　　毋任己意而废人言
毋私小惠而伤大体　　毋借公论以快私情
回复 支持 反对

使用道具 举报

liangbch
发表于 2008-3-31 11:31:24 | 显示全部楼层
原帖由 无心人 于 2008-3-31 11:09 发表 怎么停顿了 不想讨论了么？
好吧， 我将编写一个完全使用X86指令（不使用任何MMX,SSE,SSE2指令的版本）的版本，再对比现在的SSE2,MMX版本，看看使用 SIMD 指令的 最高加速比是多少。
毋因群疑而阻独见　　毋任己意而废人言
毋私小惠而伤大体　　毋借公论以快私情
回复 支持 反对

使用道具 举报

无心人
 楼主| 发表于 2008-3-31 11:36:15 | 显示全部楼层
SSE2代码似乎还存在优化可能
毋因群疑而阻独见　　毋任己意而废人言
毋私小惠而伤大体　　毋借公论以快私情
回复 支持 反对

使用道具 举报

1 ...67891011121314... 15下一页
返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 欢迎注册

本版积分规则

小黑屋|手机版|数学研发网 ( 苏ICP备07505100号 )

GMT+8, 2024-12-22 09:51 , Processed in 0.024914 second(s), 15 queries .

Powered by Discuz! X3.5

© 2001-2024 Discuz! Team.

快速回复 返回顶部 返回列表