Annotation of OpenXM_contrib/gmp/tune/speed-ext.c, Revision 1.1.1.2
1.1 maekawa 1: /* An example of extending the speed program to measure routines not in GMP. */
2:
3: /*
1.1.1.2 ! ohara 4: Copyright 1999, 2000 Free Software Foundation, Inc.
1.1 maekawa 5:
6: This file is part of the GNU MP Library.
7:
8: The GNU MP Library is free software; you can redistribute it and/or modify
9: it under the terms of the GNU Lesser General Public License as published by
10: the Free Software Foundation; either version 2.1 of the License, or (at your
11: option) any later version.
12:
13: The GNU MP Library is distributed in the hope that it will be useful, but
14: WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
15: or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
16: License for more details.
17:
18: You should have received a copy of the GNU Lesser General Public License
19: along with the GNU MP Library; see the file COPYING.LIB. If not, write to
20: the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
21: MA 02111-1307, USA.
22: */
23:
24:
25: /* The extension here is three versions of an mpn arithmetic mean. These
26: aren't meant to be particularly useful, just examples.
27:
28: You can run something like the following to compare their speeds.
29:
30: ./speed-ext -s 1-20 -c mean_calls mean_open mean_open2
31:
32: On RISC chips, mean_open() might be fastest if the compiler is doing a
33: good job. On the register starved x86s, mean_calls will be fastest.
34:
35:
36: Notes:
37:
38: SPEED_EXTRA_PROTOS and SPEED_EXTRA_ROUTINES are macros that get expanded
39: by speed.c in useful places. SPEED_EXTRA_PROTOS goes after the header
40: files, and SPEED_EXTRA_ROUTINES goes in the array of available routines.
41:
42: The advantage of this #include "speed.c" scheme is that there's no
43: editing of a copy of that file, and new features in new versions of it
44: will be immediately available.
45:
46: In a real program the routines mean_calls() etc would probably be in
47: separate C or assembler source files, and just the measuring
48: speed_mean_calls() etc would be here. Linking against other libraries
49: for things to measure is perfectly possible too.
50:
51: When attempting to compare two versions of the same named routine, say
52: like the generic and assembler versions of mpn_add_n(), creative use of
53: cc -D or #define is suggested, so one or both can be renamed and linked
54: into the same program. It'll be much easier to compare them side by side
55: than with separate programs for each.
56:
57: common.c has notes on writing speed measuring routines.
58:
59: Remember to link against tune/libspeed.la (or tune/.libs/libspeed.a if
60: not using libtool) to get common.o and other objects needed by speed.c. */
61:
62:
63: #define SPEED_EXTRA_PROTOS \
64: double speed_mean_calls (struct speed_params *s); \
65: double speed_mean_open (struct speed_params *s); \
66: double speed_mean_open2 (struct speed_params *s);
67:
68: #define SPEED_EXTRA_ROUTINES \
69: { "mean_calls", speed_mean_calls }, \
70: { "mean_open", speed_mean_open }, \
71: { "mean_open2", speed_mean_open2 },
72:
73: #include "speed.c"
74:
75:
76: /* A straightforward implementation calling mpn subroutines.
77:
78: wp,size is set to (xp,size + yp,size) / 2. The return value is the
79: remainder from the division. The other versions are the same. */
80:
81: mp_limb_t
82: mean_calls (mp_ptr wp, mp_srcptr xp, mp_srcptr yp, mp_size_t size)
83: {
84: mp_limb_t c, ret;
85:
86: ASSERT (size >= 1);
87:
88: c = mpn_add_n (wp, xp, yp, size);
89: ret = mpn_rshift (wp, wp, size, 1) >> (BITS_PER_MP_LIMB-1);
90: wp[size-1] |= (c << (BITS_PER_MP_LIMB-1));
91: return ret;
92: }
93:
94:
95: /* An open-coded version, making one pass over the data. The right shift is
96: done as the added limbs are produced. The addition code follows
97: mpn/generic/add_n.c. */
98:
99: mp_limb_t
100: mean_open (mp_ptr wp, mp_srcptr xp, mp_srcptr yp, mp_size_t size)
101: {
102: mp_limb_t w, wprev, x, y, c, ret;
103: mp_size_t i;
104:
105: ASSERT (size >= 1);
106:
107: x = xp[0];
108: y = yp[0];
109:
110: wprev = x + y;
111: c = (wprev < x);
112: ret = (wprev & 1);
113:
114: #define RSHIFT(hi,lo) (((lo) >> 1) | ((hi) << (BITS_PER_MP_LIMB-1)))
115:
116: for (i = 1; i < size; i++)
117: {
118: x = xp[i];
119: y = yp[i];
120:
121: w = x + c;
122: c = (w < x);
123: w += y;
124: c += (w < y);
125:
126: wp[i-1] = RSHIFT (w, wprev);
127: wprev = w;
128: }
129:
130: wp[i-1] = RSHIFT (c, wprev);
131:
132: return ret;
133: }
134:
135:
136: /* Another one-pass version, but right shifting the source limbs rather than
137: the result limbs. There's not much chance of this being better than the
138: above, but it's an alternative at least. */
139:
140: mp_limb_t
141: mean_open2 (mp_ptr wp, mp_srcptr xp, mp_srcptr yp, mp_size_t size)
142: {
143: mp_limb_t w, x, y, xnext, ynext, c, ret;
144: mp_size_t i;
145:
146: ASSERT (size >= 1);
147:
148: x = xp[0];
149: y = yp[0];
150:
151: /* ret is the low bit of x+y, c is the carry out of that low bit add */
152: ret = (x ^ y) & 1;
153: c = (x & y) & 1;
154:
155: for (i = 0; i < size-1; i++)
156: {
157: xnext = xp[i+1];
158: ynext = yp[i+1];
159: x = RSHIFT (xnext, x);
160: y = RSHIFT (ynext, y);
161:
162: w = x + c;
163: c = (w < x);
164: w += y;
165: c += (w < y);
166: wp[i] = w;
167:
168: x = xnext;
169: y = ynext;
170: }
171:
172: wp[i] = (x >> 1) + (y >> 1) + c;
173:
174: return ret;
175: }
176:
177:
178: /* The speed measuring routines are the same apart from which function they
179: run, so a macro is used. Actually this macro is the same as
180: SPEED_ROUTINE_MPN_BINARY_N. */
181:
182: #define SPEED_ROUTINE_MEAN(mean_fun) \
183: { \
184: unsigned i; \
185: mp_ptr wp; \
186: double t; \
187: TMP_DECL (marker); \
188: \
189: SPEED_RESTRICT_COND (s->size >= 1); \
190: \
191: TMP_MARK (marker); \
192: wp = SPEED_TMP_ALLOC_LIMBS (s->size, s->align_wp); \
193: \
194: speed_operand_src (s, s->xp, s->size); \
195: speed_operand_src (s, s->yp, s->size); \
196: speed_operand_dst (s, wp, s->size); \
197: speed_cache_fill (s); \
198: \
199: speed_starttime (); \
200: i = s->reps; \
201: do \
202: mean_fun (wp, s->xp, s->yp, s->size); \
203: while (--i != 0); \
204: t = speed_endtime (); \
205: \
206: TMP_FREE (marker); \
207: return t; \
208: }
209:
210: double
211: speed_mean_calls (struct speed_params *s)
212: {
213: SPEED_ROUTINE_MEAN (mean_calls);
214: }
215:
216: double
217: speed_mean_open (struct speed_params *s)
218: {
219: SPEED_ROUTINE_MEAN (mean_open);
220: }
221:
222: double
223: speed_mean_open2 (struct speed_params *s)
224: {
225: SPEED_ROUTINE_MEAN (mean_open2);
226: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to speed-ext.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / gmp / tune