Annotation of OpenXM_contrib/gmp/mpn/x86/k7/mul_1.asm, Revision 1.1
1.1 ! maekawa 1: dnl AMD K7 mpn_mul_1 -- mpn by limb multiply.
! 2: dnl
! 3: dnl K7: 3.4 cycles/limb (at 16 limbs/loop).
! 4:
! 5:
! 6: dnl Copyright (C) 1999, 2000 Free Software Foundation, Inc.
! 7: dnl
! 8: dnl This file is part of the GNU MP Library.
! 9: dnl
! 10: dnl The GNU MP Library is free software; you can redistribute it and/or
! 11: dnl modify it under the terms of the GNU Lesser General Public License as
! 12: dnl published by the Free Software Foundation; either version 2.1 of the
! 13: dnl License, or (at your option) any later version.
! 14: dnl
! 15: dnl The GNU MP Library is distributed in the hope that it will be useful,
! 16: dnl but WITHOUT ANY WARRANTY; without even the implied warranty of
! 17: dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
! 18: dnl Lesser General Public License for more details.
! 19: dnl
! 20: dnl You should have received a copy of the GNU Lesser General Public
! 21: dnl License along with the GNU MP Library; see the file COPYING.LIB. If
! 22: dnl not, write to the Free Software Foundation, Inc., 59 Temple Place -
! 23: dnl Suite 330, Boston, MA 02111-1307, USA.
! 24:
! 25:
! 26: include(`../config.m4')
! 27:
! 28:
! 29: dnl K7: UNROLL_COUNT cycles/limb
! 30: dnl 8 3.9
! 31: dnl 16 3.4
! 32: dnl 32 3.4
! 33: dnl 64 3.35
! 34: dnl Maximum possible with the current code is 64.
! 35:
! 36: deflit(UNROLL_COUNT, 16)
! 37:
! 38:
! 39: C mp_limb_t mpn_mul_1 (mp_ptr dst, mp_srcptr src, mp_size_t size,
! 40: C mp_limb_t multiplier);
! 41: C mp_limb_t mpn_mul_1c (mp_ptr dst, mp_srcptr src, mp_size_t size,
! 42: C mp_limb_t multiplier, mp_limb_t carry);
! 43: C
! 44: C Multiply src,size by mult and store the result in dst,size.
! 45: C Return the carry limb from the top of the result.
! 46: C
! 47: C mpn_mul_1c() accepts an initial carry for the calculation, it's added into
! 48: C the low limb of the destination.
! 49: C
! 50: C Variations on the unrolled loop have been tried, with the current
! 51: C registers or with the counter on the stack to free up ecx. The current
! 52: C code is the fastest found.
! 53: C
! 54: C An interesting effect is that removing the stores "movl %ebx, disp0(%edi)"
! 55: C from the unrolled loop actually slows it down to 5.0 cycles/limb. Code
! 56: C with this change can be tested on sizes of the form UNROLL_COUNT*n+1
! 57: C without having to change the computed jump. There's obviously something
! 58: C fishy going on, perhaps with what execution units the mul needs.
! 59:
! 60: defframe(PARAM_CARRY, 20)
! 61: defframe(PARAM_MULTIPLIER,16)
! 62: defframe(PARAM_SIZE, 12)
! 63: defframe(PARAM_SRC, 8)
! 64: defframe(PARAM_DST, 4)
! 65:
! 66: defframe(SAVE_EBP, -4)
! 67: defframe(SAVE_EDI, -8)
! 68: defframe(SAVE_ESI, -12)
! 69: defframe(SAVE_EBX, -16)
! 70: deflit(STACK_SPACE, 16)
! 71:
! 72: dnl Must have UNROLL_THRESHOLD >= 2, since the unrolled loop can't handle 1.
! 73: ifdef(`PIC',`
! 74: deflit(UNROLL_THRESHOLD, 7)
! 75: ',`
! 76: deflit(UNROLL_THRESHOLD, 5)
! 77: ')
! 78:
! 79: .text
! 80: ALIGN(32)
! 81: PROLOGUE(mpn_mul_1c)
! 82: deflit(`FRAME',0)
! 83: movl PARAM_CARRY, %edx
! 84: jmp LF(mpn_mul_1,start_nc)
! 85: EPILOGUE()
! 86:
! 87:
! 88: PROLOGUE(mpn_mul_1)
! 89: deflit(`FRAME',0)
! 90: xorl %edx, %edx C initial carry
! 91: L(start_nc):
! 92: movl PARAM_SIZE, %ecx
! 93: subl $STACK_SPACE, %esp
! 94: deflit(`FRAME', STACK_SPACE)
! 95:
! 96: movl %edi, SAVE_EDI
! 97: movl %ebx, SAVE_EBX
! 98: movl %edx, %ebx
! 99:
! 100: movl %esi, SAVE_ESI
! 101: movl PARAM_SRC, %esi
! 102: cmpl $UNROLL_THRESHOLD, %ecx
! 103:
! 104: movl PARAM_DST, %edi
! 105: movl %ebp, SAVE_EBP
! 106: jae L(unroll)
! 107:
! 108: leal (%esi,%ecx,4), %esi
! 109: leal (%edi,%ecx,4), %edi
! 110: negl %ecx
! 111:
! 112: movl PARAM_MULTIPLIER, %ebp
! 113:
! 114: L(simple):
! 115: C eax scratch
! 116: C ebx carry
! 117: C ecx counter (negative)
! 118: C edx scratch
! 119: C esi src
! 120: C edi dst
! 121: C ebp multiplier
! 122:
! 123: movl (%esi,%ecx,4), %eax
! 124:
! 125: mull %ebp
! 126:
! 127: addl %ebx, %eax
! 128: movl %eax, (%edi,%ecx,4)
! 129: movl $0, %ebx
! 130:
! 131: adcl %edx, %ebx
! 132: incl %ecx
! 133: jnz L(simple)
! 134:
! 135: movl %ebx, %eax
! 136: movl SAVE_EBX, %ebx
! 137: movl SAVE_ESI, %esi
! 138:
! 139: movl SAVE_EDI, %edi
! 140: movl SAVE_EBP, %ebp
! 141: addl $STACK_SPACE, %esp
! 142:
! 143: ret
! 144:
! 145:
! 146: C -----------------------------------------------------------------------------
! 147: C The mov to load the next source limb is done well ahead of the mul, this
! 148: C is necessary for full speed. It leads to one limb handled separately
! 149: C after the loop.
! 150: C
! 151: C When unrolling to 32 or more, an offset of +4 is used on the src pointer,
! 152: C to avoid having an 0x80 displacement in the code for the last limb in the
! 153: C unrolled loop. This is for a fair comparison between 16 and 32 unrolling.
! 154:
! 155: ifelse(eval(UNROLL_COUNT >= 32),1,`
! 156: deflit(SRC_OFFSET,4)
! 157: ',`
! 158: deflit(SRC_OFFSET,)
! 159: ')
! 160:
! 161: C this is offset 0x62, so close enough to aligned
! 162: L(unroll):
! 163: C eax
! 164: C ebx initial carry
! 165: C ecx size
! 166: C edx
! 167: C esi src
! 168: C edi dst
! 169: C ebp
! 170: deflit(`FRAME', STACK_SPACE)
! 171:
! 172: leal -1(%ecx), %edx C one limb handled at end
! 173: leal -2(%ecx), %ecx C and ecx is one less than edx
! 174: movl %ebp, SAVE_EBP
! 175:
! 176: negl %edx
! 177: shrl $UNROLL_LOG2, %ecx C unrolled loop counter
! 178: movl (%esi), %eax C src low limb
! 179:
! 180: andl $UNROLL_MASK, %edx
! 181: movl PARAM_DST, %edi
! 182:
! 183: movl %edx, %ebp
! 184: shll $4, %edx
! 185:
! 186: C 17 code bytes per limb
! 187: ifdef(`PIC',`
! 188: call L(add_eip_to_edx)
! 189: L(here):
! 190: ',`
! 191: leal L(entry) (%edx,%ebp), %edx
! 192: ')
! 193: negl %ebp
! 194:
! 195: leal ifelse(UNROLL_BYTES,256,128+) SRC_OFFSET(%esi,%ebp,4), %esi
! 196: leal ifelse(UNROLL_BYTES,256,128) (%edi,%ebp,4), %edi
! 197: movl PARAM_MULTIPLIER, %ebp
! 198:
! 199: jmp *%edx
! 200:
! 201:
! 202: ifdef(`PIC',`
! 203: L(add_eip_to_edx):
! 204: C See README.family about old gas bugs
! 205: leal (%edx,%ebp), %edx
! 206: addl $L(entry)-L(here), %edx
! 207: addl (%esp), %edx
! 208: ret
! 209: ')
! 210:
! 211:
! 212: C ----------------------------------------------------------------------------
! 213: ALIGN(32)
! 214: L(top):
! 215: C eax next src limb
! 216: C ebx carry
! 217: C ecx counter
! 218: C edx scratch
! 219: C esi src+4
! 220: C edi dst
! 221: C ebp multiplier
! 222: C
! 223: C 17 code bytes per limb processed
! 224:
! 225: L(entry):
! 226: forloop(i, 0, UNROLL_COUNT-1, `
! 227: deflit(`disp_dst', eval(i*4 ifelse(UNROLL_BYTES,256,-128)))
! 228: deflit(`disp_src', eval(disp_dst + 4-(SRC_OFFSET-0)))
! 229:
! 230: mull %ebp
! 231:
! 232: addl %eax, %ebx
! 233: Zdisp( movl, disp_src,(%esi), %eax)
! 234: Zdisp( movl, %ebx, disp_dst,(%edi))
! 235:
! 236: movl $0, %ebx
! 237: adcl %edx, %ebx
! 238: ')
! 239:
! 240: decl %ecx
! 241:
! 242: leal UNROLL_BYTES(%esi), %esi
! 243: leal UNROLL_BYTES(%edi), %edi
! 244: jns L(top)
! 245:
! 246:
! 247: deflit(`disp0', ifelse(UNROLL_BYTES,256,-128))
! 248:
! 249: mull %ebp
! 250:
! 251: addl %eax, %ebx
! 252: movl $0, %eax
! 253: movl SAVE_ESI, %esi
! 254:
! 255: movl %ebx, disp0(%edi)
! 256: movl SAVE_EBX, %ebx
! 257: movl SAVE_EDI, %edi
! 258:
! 259: adcl %edx, %eax
! 260: movl SAVE_EBP, %ebp
! 261: addl $STACK_SPACE, %esp
! 262:
! 263: ret
! 264:
! 265: EPILOGUE()
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to mul_1.asm CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / gmp / mpn / x86 / k7