README
上传用户:qaz666999
上传日期:2022-08-06
资源大小:2570k
文件大小:9k
源码类别:

数学计算

开发平台:

Unix_Linux

  1. Copyright 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
  2. This file is part of the GNU MP Library.
  3. The GNU MP Library is free software; you can redistribute it and/or modify
  4. it under the terms of the GNU Lesser General Public License as published by
  5. the Free Software Foundation; either version 3 of the License, or (at your
  6. option) any later version.
  7. The GNU MP Library is distributed in the hope that it will be useful, but
  8. WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  9. or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
  10. License for more details.
  11. You should have received a copy of the GNU Lesser General Public License
  12. along with the GNU MP Library.  If not, see http://www.gnu.org/licenses/.
  13.                       IA-64 MPN SUBROUTINES
  14. This directory contains mpn functions for the IA-64 architecture.
  15. CODE ORGANIZATION
  16. mpn/ia64          itanium-2, and generic ia64
  17. The code here has been optimized primarily for Itanium 2.  Very few Itanium 1
  18. chips were ever sold, and Itanium 2 is more powerful, so the latter is what
  19. we concentrate on.
  20. CHIP NOTES
  21. The IA-64 ISA keeps instructions three and three in 128 bit bundles.
  22. Programmers/compilers need to put explicit breaks `;;' when there are WAW or
  23. RAW dependencies, with some notable exceptions.  Such "breaks" are typically
  24. at the end of a bundle, but can be put between operations within some bundle
  25. types too.
  26. The Itanium 1 and Itanium 2 implementations can under ideal conditions
  27. execute two bundles per cycle.  The Itanium 1 allows 4 of these instructions
  28. to do integer operations, while the Itanium 2 allows all 6 to be integer
  29. operations.
  30. Taken cloop branches seem to insert a bubble into the pipeline most of the
  31. time on Itanium 1.
  32. Loads to the fp registers bypass the L1 cache and thus get extremely long
  33. latencies, 9 cycles on the Itanium 1 and 6 cycles on the Itanium 2.
  34. The software pipeline stuff using br.ctop instruction causes delays, since
  35. many issue slots are taken up by instructions with zero predicates, and
  36. since many extra instructions are needed to set things up.  These features
  37. are clearly designed for code density, not speed.
  38. Misc pipeline limitations (Itanium 1):
  39. * The getf.sig instruction can only execute in M0.
  40. * At most four integer instructions/cycle.
  41. * Nops take up resources like any plain instructions.
  42. Misc pipeline limitations (Itanium 2):
  43. * The getf.sig instruction can only execute in M0.
  44. * Nops take up resources like any plain instructions.
  45. ASSEMBLY SYNTAX
  46. .align pads with nops in a text segment, but gas 2.14 and earlier
  47. incorrectly byte-swaps its nop bundle in big endian mode (eg. hpux), making
  48. it come out as break instructions.  We use the ALIGN() macro in
  49. mpn/ia64/ia64-defs.m4 when it might be executed across.  That macro
  50. suppresses any .align if the problem is detected by configure.  Lack of
  51. alignment might hurt performance but will at least be correct.
  52. foo:: to create a global symbol is not accepted by gas.  Use separate
  53. ".global foo" and "foo:" instead.
  54. .global is the standard global directive.  gas accepts .globl, but hpux "as"
  55. doesn't.
  56. .proc / .endp generates the appropriate .type and .size information for ELF,
  57. so the latter directives don't need to be given explicitly.
  58. .pred.rel "mutex"... is standard for annotating predicate register
  59. relationships.  gas also accepts .pred.rel.mutex, but hpux "as" doesn't.
  60. .pred directives can't be put on a line with a label, like
  61. ".Lfoo: .pred ...", the HP assembler on HP-UX 11.23 rejects that.
  62. gas is happy with it, and past versions of HP had seemed ok.
  63. // is the standard comment sequence, but we prefer "C" since it inhibits m4
  64. macro expansion.  See comments in ia64-defs.m4.
  65. REGISTER USAGE
  66. Special:
  67.    r0: constant 0
  68.    r1: global pointer (gp)
  69.    r8: return value
  70.    r12: stack pointer (sp)
  71.    r13: thread pointer (tp)
  72. Caller-saves: r8-r11 r14-r31 f6-f15 f32-f127
  73. Caller-saves but rotating: r32-
  74. ================================================================
  75. mpn_add_n, mpn_sub_n:
  76. The current code runs at 1.25 c/l on Itanium 2.
  77. ================================================================
  78. mpn_mul_1:
  79. The current code runs at 2 c/l on Itanium 2.
  80. Using a blocked approach, working off of 4 separate places in the operands,
  81. one could make use of the xma accumulation, and approach 1 c/l.
  82. ldf8 [up]
  83. xma.l
  84. xma.hu
  85. stf8  [wrp]
  86. ================================================================
  87. mpn_addmul_1:
  88. The current code runs at 2 c/l on Itanium 2.
  89. It seems possible to use a blocked approach, as with mpn_mul_1.  We should
  90. read rp[] to integer registers, allowing for just one getf.sig per cycle.
  91. ld8  [rp]
  92. ldf8 [up]
  93. xma.l
  94. xma.hu
  95. getf.sig
  96. add+add+cmp+cmp
  97. st8  [wrp]
  98. These 10 instructions can be scheduled to approach 1.667 cycles, and with
  99. the 4 cycle latency of xma, this means we need at least 3 blocks.  Using
  100. ldfp8 we could approach 1.583 c/l.
  101. ================================================================
  102. mpn_submul_1:
  103. The current code runs at 2.25 c/l on Itanium 2.  Getting to 2 c/l requires
  104. ldfp8 with all alignment headache that implies.
  105. ================================================================
  106. mpn_addmul_N
  107. For best speed, we need to give up using mpn_addmul_1 as the main multiply
  108. building block, and instead take multiple v limbs per loop.  For the Itanium
  109. 1, we need to take about 8 limbs at a time for full speed.  For the Itanium
  110. 2, something like mpn_addmul_4 should be enough.
  111. The add+cmp+cmp+add we use on the other codes is optimal for shortening
  112. recurrencies (1 cycle) but the sequence takes up 4 execution slots.  When
  113. recurrency depth is not critical, a more standard 3-cycle add+cmp+add is
  114. better.
  115. /* First load the 8 values from v */
  116. ldfp8 v0, v1 = [r35], 16;;
  117. ldfp8 v2, v3 = [r35], 16;;
  118. ldfp8 v4, v5 = [r35], 16;;
  119. ldfp8 v6, v7 = [r35], 16;;
  120. /* In the inner loop, get a new U limb and store a result limb. */
  121. mov lc = un
  122. Loop: ldf8 u0 = [r33], 8
  123. ld8 r0 = [r32]
  124. xma.l lp0 = v0, u0, hp0
  125. xma.hu hp0 = v0, u0, hp0
  126. xma.l lp1 = v1, u0, hp1
  127. xma.hu hp1 = v1, u0, hp1
  128. xma.l lp2 = v2, u0, hp2
  129. xma.hu hp2 = v2, u0, hp2
  130. xma.l lp3 = v3, u0, hp3
  131. xma.hu hp3 = v3, u0, hp3
  132. xma.l lp4 = v4, u0, hp4
  133. xma.hu hp4 = v4, u0, hp4
  134. xma.l lp5 = v5, u0, hp5
  135. xma.hu hp5 = v5, u0, hp5
  136. xma.l lp6 = v6, u0, hp6
  137. xma.hu hp6 = v6, u0, hp6
  138. xma.l lp7 = v7, u0, hp7
  139. xma.hu hp7 = v7, u0, hp7
  140. getf.sig l0 = lp0
  141. getf.sig l1 = lp1
  142. getf.sig l2 = lp2
  143. getf.sig l3 = lp3
  144. getf.sig l4 = lp4
  145. getf.sig l5 = lp5
  146. getf.sig l6 = lp6
  147. add+cmp+add xx, l0, r0
  148. add+cmp+add acc0, acc1, l1
  149. add+cmp+add acc1, acc2, l2
  150. add+cmp+add acc2, acc3, l3
  151. add+cmp+add acc3, acc4, l4
  152. add+cmp+add acc4, acc5, l5
  153. add+cmp+add acc5, acc6, l6
  154. getf.sig acc6 = lp7
  155. st8 [r32] = xx, 8
  156. br.cloop Loop
  157. 49 insn at max 6 insn/cycle: 8.167 cycles/limb8
  158. 11 memops at max 2 memops/cycle: 5.5 cycles/limb8
  159. 16 fpops at max 2 fpops/cycle: 8 cycles/limb8
  160. 21 intops at max 4 intops/cycle: 5.25 cycles/limb8
  161. 11+21 memops+intops at max 4/cycle 8 cycles/limb8
  162. ================================================================
  163. mpn_lshift, mpn_rshift
  164. The current code runs at 1 cycle/limb on Itanium 2.
  165. Using 63 separate loops, we could use the double-word shrp instruction.
  166. That instruction has a plain single-cycle latency.  We need 63 loops since
  167. this instruction only accept immediate count.  That would lead to a somewhat
  168. silly code size, but the speed would be 0.75 c/l on Itanium 2 (by using shrp
  169. each cycle plus shl/shr going down I1 for a further limb every second
  170. cycle).
  171. ================================================================
  172. mpn_copyi, mpn_copyd
  173. The current code runs at 0.5 c/l on Itanium 2.  But that is just for L1
  174. cache hit.  The 4-way unrolled loop takes just 2 cycles, and thus load-use
  175. scheduling isn't great.  It might be best to actually use modulo scheduled
  176. loops, since that will allow us to do better load-use scheduling without too
  177. much unrolling.
  178. Depending on size or operand alignment, we get 1 c/l or 0.5 c/l on Itanium
  179. 2, according to tune/speed.  Cache bank conflicts?
  180. REFERENCES
  181. Intel Itanium Architecture Software Developer's Manual, volumes 1 to 3,
  182. Intel document 245317-004, 245318-004, 245319-004 October 2002.  Volume 1
  183. includes an Itanium optimization guide.
  184. Intel Itanium Processor-specific Application Binary Interface (ABI), Intel
  185. document 245370-003, May 2001.  Describes C type sizes, dynamic linking,
  186. etc.
  187. Intel Itanium Architecture Assembly Language Reference Guide, Intel document
  188. 248801-004, 2000-2002.  Describes assembly instruction syntax and other
  189. directives.
  190. Itanium Software Conventions and Runtime Architecture Guide, Intel document
  191. 245358-003, May 2001.  Describes calling conventions, including stack
  192. unwinding requirements.
  193. Intel Itanium Processor Reference Manual for Software Optimization, Intel
  194. document 245473-003, November 2001.
  195. Intel Itanium-2 Processor Reference Manual for Software Development and
  196. Optimization, Intel document 251110-003, May 2004.
  197. All the above documents can be found online at
  198.     http://developer.intel.com/design/itanium/manuals.htm