Annotation of OpenXM_contrib/gmp/mpn/x86/k6/k62mmx/copyi.asm, Revision 1.1.1.1
1.1 maekawa 1: dnl AMD K6-2 mpn_copyi -- copy limb vector, incrementing.
2: dnl
3: dnl K6-2: 0.56 or 1.0 cycles/limb (at 32 limbs/loop), depending on data
4: dnl alignment.
5:
6:
7: dnl Copyright (C) 1999, 2000 Free Software Foundation, Inc.
8: dnl
9: dnl This file is part of the GNU MP Library.
10: dnl
11: dnl The GNU MP Library is free software; you can redistribute it and/or
12: dnl modify it under the terms of the GNU Lesser General Public License as
13: dnl published by the Free Software Foundation; either version 2.1 of the
14: dnl License, or (at your option) any later version.
15: dnl
16: dnl The GNU MP Library is distributed in the hope that it will be useful,
17: dnl but WITHOUT ANY WARRANTY; without even the implied warranty of
18: dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19: dnl Lesser General Public License for more details.
20: dnl
21: dnl You should have received a copy of the GNU Lesser General Public
22: dnl License along with the GNU MP Library; see the file COPYING.LIB. If
23: dnl not, write to the Free Software Foundation, Inc., 59 Temple Place -
24: dnl Suite 330, Boston, MA 02111-1307, USA.
25:
26:
27: include(`../config.m4')
28:
29:
30: dnl K6-2 aligned:
31: dnl UNROLL_COUNT cycles/limb
32: dnl 8 0.75
33: dnl 16 0.625
34: dnl 32 0.5625
35: dnl 64 0.53
36: dnl Maximum possible with the current code is 64, the minimum is 2.
37:
38: deflit(UNROLL_COUNT, 32)
39:
40:
41: C void mpn_copyi (mp_ptr dst, mp_srcptr src, mp_size_t size);
42: C
43: C The MMX loop is faster than a rep movs when src and dst are both 0mod8.
44: C With one 0mod8 and one 4mod8 it's 1.056 c/l and the rep movs at 1.0 c/l is
45: C used instead.
46: C
47: C mod8
48: C src dst
49: C 0 0 both aligned, use mmx
50: C 0 4 unaligned, use rep movs
51: C 4 0 unaligned, use rep movs
52: C 4 4 do one movs, then both aligned, use mmx
53: C
54: C The MMX code on aligned data is 0.5 c/l, plus loop overhead of 2
55: C cycles/loop, which is 0.0625 c/l at 32 limbs/loop.
56: C
57: C A pattern of two movq loads and two movq stores (or four and four) was
58: C tried, but found to be the same speed as just one of each.
59: C
60: C Note that this code only suits K6-2 and K6-3. Plain K6 does only one mmx
61: C instruction per cycle, so "movq"s are no faster than the simple 1 c/l rep
62: C movs.
63: C
64: C Enhancement:
65: C
66: C Addressing modes like disp(%esi,%ecx,4) aren't currently used. They'd
67: C make it possible to avoid incrementing %esi and %edi in the loop and hence
68: C get loop overhead down to 1 cycle. Care would be needed to avoid bad
69: C cache line crossings since the "movq"s would then be 5 code bytes rather
70: C than 4.
71:
72:
73: defframe(PARAM_SIZE,12)
74: defframe(PARAM_SRC, 8)
75: defframe(PARAM_DST, 4)
76: deflit(`FRAME',0)
77:
78: .text
79: ALIGN(32)
80:
81: PROLOGUE(mpn_copyi)
82: movl PARAM_SIZE, %ecx
83: movl %esi, %eax
84:
85: movl PARAM_SRC, %esi
86: movl %edi, %edx
87:
88: cld
89:
90: movl PARAM_DST, %edi
91: cmpl $UNROLL_COUNT, %ecx
92:
93: ja L(unroll)
94:
95: L(simple):
96: rep
97: movsl
98:
99: movl %eax, %esi
100: movl %edx, %edi
101:
102: ret
103:
104:
105: L(unroll):
106: C if src and dst are different alignments mod8, then use rep movs
107: C if src and dst are both 4mod8 then process one limb to get 0mod8
108:
109: pushl %ebx
110: leal (%esi,%edi), %ebx
111:
112: testb $4, %bl
113: popl %ebx
114:
115: jnz L(simple)
116: testl $4, %esi
117:
118: leal -UNROLL_COUNT(%ecx), %ecx
119: jz L(already_aligned)
120:
121: decl %ecx
122:
123: movsl
124: L(already_aligned):
125:
126:
127: ifelse(UNROLL_BYTES,256,`
128: addl $128, %esi
129: addl $128, %edi
130: ')
131:
132: C this is offset 0x34, no alignment needed
133: L(top):
134: C eax saved esi
135: C ebx
136: C ecx counter, limbs
137: C edx saved edi
138: C esi src, incrementing
139: C edi dst, incrementing
140: C ebp
141: C
142: C Zdisp gets 0(%esi) left that way to avoid vector decode, and with
143: C 0(%edi) keeps code aligned to 16 byte boundaries.
144:
145: deflit(CHUNK_COUNT, 2)
146: forloop(`i', 0, UNROLL_COUNT/CHUNK_COUNT-1, `
147: deflit(`disp', eval(i*CHUNK_COUNT*4 ifelse(UNROLL_BYTES,256,-128)))
148: Zdisp( movq, disp,(%esi), %mm0)
149: Zdisp( movq, %mm0, disp,(%edi))
150: ')
151:
152: addl $UNROLL_BYTES, %esi
153: subl $UNROLL_COUNT, %ecx
154:
155: leal UNROLL_BYTES(%edi), %edi
156: jns L(top)
157:
158:
159: C now %ecx is -UNROLL_COUNT to -1 representing repectively 0 to
160: C UNROLL_COUNT-1 limbs remaining
161:
162: testb $eval(UNROLL_COUNT/2), %cl
163:
164: leal UNROLL_COUNT(%ecx), %ecx
165: jz L(not_half)
166:
167: C at an unroll count of 32 this block of code is 16 cycles faster than
168: C the rep movs, less 3 or 4 to test whether to do it
169:
170: forloop(`i', 0, UNROLL_COUNT/CHUNK_COUNT/2-1, `
171: deflit(`disp', eval(i*CHUNK_COUNT*4 ifelse(UNROLL_BYTES,256,-128)))
172: movq disp(%esi), %mm0
173: movq %mm0, disp(%edi)
174: ')
175: addl $eval(UNROLL_BYTES/2), %esi
176: addl $eval(UNROLL_BYTES/2), %edi
177:
178: subl $eval(UNROLL_COUNT/2), %ecx
179: L(not_half):
180:
181:
182: ifelse(UNROLL_BYTES,256,`
183: subl $128, %esi
184: subl $128, %edi
185: ')
186:
187: rep
188: movsl
189:
190: movl %eax, %esi
191: movl %edx, %edi
192:
193: femms
194: ret
195:
196: EPILOGUE()
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to copyi.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 / k6 / k62mmx