Annotation of OpenXM_contrib/gmp/tune/tuneup.c, Revision 1.1.1.1
1.1 maekawa 1: /* Create tuned thresholds for various algorithms. */
2:
3: /*
4: Copyright (C) 1999, 2000 Free Software Foundation, Inc.
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: /* Usage: tune [-t] [-t] [-p precision]
25:
26: -t turns on some diagnostic traces, a second -t turns on more traces.
27:
28: The thresholds are determined as follows. A crossover may not be a
29: single size but rather a range where it oscillates between method A or
30: method B faster. If the threshold is set making B used where A is faster
31: (or vice versa) that's bad. Badness is the percentage time lost and
32: total badness is the sum of this over all sizes measured. The threshold
33: is set to minimize total badness.
34:
35: Suppose, as sizes increase, method B becomes faster than method A. The
36: effect of the rule is that, as you look at increasing sizes, isolated
37: points where B is faster are ignored, but when it's consistently faster,
38: or faster on balance, then the threshold is set there. The same result
39: is obtained thinking in the other direction of A becoming faster at
40: smaller sizes.
41:
42: In practice the thresholds tend to be chosen to bring on the next
43: algorithm fairly quickly.
44:
45: This rule is attractive because it's got a basis in reason and is fairly
46: easy to implement, but no work has been done to actually compare it in
47: absolute terms to other possibilities.
48:
49: Sometimes running the program twice produces slightly different results.
50: This is probably because there's so little separating algorithms near
51: their crossover, and on that basis it should make little or no difference
52: to the final speed of the relevant routines, but nothing has been done to
53: check that carefully.
54:
55: Limitations:
56:
57: The FFTs aren't subject to the same badness rule as the other thresholds,
58: so each k is probably being brought on a touch early. This isn't likely
59: to make a difference, and the simpler probing means fewer tests.
60:
61: */
62:
63: #define TUNE_PROGRAM_BUILD 1
64:
65: #include <math.h>
66: #include <stdio.h>
67: #include <stdlib.h>
68: #include <time.h>
69: #include <unistd.h>
70:
71: #include "gmp.h"
72: #include "gmp-impl.h"
73:
74: #include "speed.h"
75: #include "sqr_basecase.h"
76:
77: #if !HAVE_DECL_OPTARG
78: extern char *optarg;
79: extern int optind, opterr;
80: #endif
81:
82:
83: #define MAX_SIZE 1000 /* limbs */
84: #define STEP_FACTOR 0.01 /* how much to step sizes by (rounded down) */
85: #define MAX_TABLE 2 /* threshold entries */
86:
87:
88: #if WANT_FFT
89: mp_size_t option_fft_max_size = 50000; /* limbs */
90: #else
91: mp_size_t option_fft_max_size = 0;
92: #endif
93: int option_trace = 0;
94: int option_fft_trace = 0;
95: struct speed_params s;
96:
97: struct dat_t {
98: mp_size_t size;
99: double d;
100: } *dat = NULL;
101: int ndat = 0;
102: int allocdat = 0;
103:
104:
105: /* Each "_threshold" array must be 1 bigger than the number of thresholds
106: being tuned in a set, because one() stores an value in the entry above
107: the one it's determining. */
108:
109: mp_size_t mul_threshold[MAX_TABLE+1] = { MP_SIZE_T_MAX };
110: mp_size_t fft_modf_mul_threshold = MP_SIZE_T_MAX;
111: mp_size_t sqr_threshold[MAX_TABLE+1] = { MP_SIZE_T_MAX };
112: mp_size_t fft_modf_sqr_threshold = MP_SIZE_T_MAX;
113: mp_size_t bz_threshold[2] = { MP_SIZE_T_MAX };
114: mp_size_t fib_threshold[2] = { MP_SIZE_T_MAX };
115: mp_size_t powm_threshold[2] = { MP_SIZE_T_MAX };
116: mp_size_t gcd_accel_threshold[2] = { MP_SIZE_T_MAX };
117: mp_size_t gcdext_threshold[2] = { MP_SIZE_T_MAX };
118:
119:
120: #ifndef KARATSUBA_SQR_MAX
121: #define KARATSUBA_SQR_MAX 0 /* meaning no limit */
122: #endif
123:
124: struct param_t {
125: const char *name[MAX_TABLE];
126: int stop_since_change;
127: mp_size_t min_size;
128: mp_size_t max_size[MAX_TABLE];
129: };
130:
131:
132: /* Add an entry to the end of the dat[] array, reallocing to make it bigger
133: if necessary. */
134: void
135: add_dat (mp_size_t size, double d)
136: {
137: #define ALLOCDAT_STEP 500
138:
139: ASSERT_ALWAYS (ndat <= allocdat);
140:
141: if (ndat == allocdat)
142: {
143: dat = (struct dat_t *) _mp_allocate_or_reallocate
144: (dat, allocdat * sizeof(dat[0]),
145: (allocdat+ALLOCDAT_STEP) * sizeof(dat[0]));
146: allocdat += ALLOCDAT_STEP;
147: }
148:
149: dat[ndat].size = size;
150: dat[ndat].d = d;
151: ndat++;
152: }
153:
154:
155: /* Return the threshold size based on the data accumulated. */
156: mp_size_t
157: analyze_dat (int i, int final)
158: {
159: double x, min_x;
160: int j, min_j;
161:
162: /* If the threshold is set at dat[0].size, any positive values are bad. */
163: x = 0.0;
164: for (j = 0; j < ndat; j++)
165: if (dat[j].d > 0.0)
166: x += dat[j].d;
167:
168: if (option_trace >= 2 && final)
169: {
170: printf ("\n");
171: printf ("x is the sum of the badness from setting thresh at given size\n");
172: printf (" (minimum x is sought)\n");
173: printf ("i=%d size=%ld first x=%.4f\n", i, dat[j].size, x);
174: }
175:
176: min_x = x;
177: min_j = 0;
178:
179:
180: /* When stepping to the next dat[j].size, positive values are no longer
181: bad (so subtracted), negative values become bad (so add the absolute
182: value, meaning subtract). */
183: for (j = 0; j < ndat; x -= dat[j].d, j++)
184: {
185: if (option_trace >= 2 && final)
186: printf ("i=%d size=%ld x=%.4f\n", i, dat[j].size, x);
187:
188: if (x < min_x)
189: {
190: min_x = x;
191: min_j = j;
192: }
193: }
194:
195: return min_j;
196: }
197:
198:
199: double
200: tuneup_measure (speed_function_t fun, struct speed_params *s)
201: {
202: static mp_ptr xp, yp;
203: double t;
204: TMP_DECL (marker);
205:
206: TMP_MARK (marker);
207: s->xp = SPEED_TMP_ALLOC_LIMBS (s->size, 0);
208: s->yp = SPEED_TMP_ALLOC_LIMBS (s->size, 0);
209:
210: mpn_random (s->xp, s->size);
211: mpn_random (s->yp, s->size);
212:
213: t = speed_measure (fun, s);
214:
215: TMP_FREE (marker);
216: return t;
217: }
218:
219:
220: void
221: print_define (const char *name, mp_size_t value)
222: {
223: printf ("#ifndef %s\n", name);
224: printf ("#define %-23s ", name);
225: if (value == MP_SIZE_T_MAX)
226: printf ("MP_SIZE_T_MAX\n");
227: else
228: printf ("%5ld\n", value);
229: printf ("#endif\n");
230: }
231:
232:
233: /* table[i+1] needs to be set to a sensible value when testing method i+1
234: because mpn_mul_n uses TOOM3_MUL_THRESHOLD to size the temporary
235: workspace for mpn_kara_mul_n. */
236:
237: void
238: one (speed_function_t function, mp_size_t table[], size_t max_table,
239: struct param_t *param)
240: {
241: static struct param_t dummy;
242: int i;
243:
244: if (param == NULL) param = &dummy;
245:
246: #define DEFAULT(x,n) if (param->x == 0) param->x = (n);
247:
248: DEFAULT (stop_since_change, 80);
249: DEFAULT (min_size, 10);
250: for (i = 0; i < numberof (param->max_size); i++)
251: DEFAULT (max_size[i], MAX_SIZE);
252:
253: s.size = param->min_size;
254:
255: for (i = 0; i < max_table && s.size < MAX_SIZE; i++)
256: {
257: int since_positive, since_thresh_change;
258: int thresh_idx, new_thresh_idx;
259:
260: ndat = 0;
261: since_positive = 0;
262: since_thresh_change = 0;
263: thresh_idx = 0;
264:
265: if (option_trace >= 2)
266: {
267: printf (" algorithm-A algorithm-B ratio possible\n");
268: printf (" (seconds) (seconds) diff thresh\n");
269: }
270:
271: for ( ; s.size < MAX_SIZE;
272: s.size += MAX ((mp_size_t) floor (s.size * STEP_FACTOR), 1))
273: {
274: double ti, tiplus1, d;
275:
276: /* If there's a size limit and it's reached then it should still
277: be sensible to analyze the data since we want the threshold put
278: either at or near the limit. */
279: if (s.size >= param->max_size[i])
280: {
281: if (option_trace)
282: printf ("Reached maximum size (%ld) without otherwise stopping\n",
283: param->max_size[i]);
284: break;
285: }
286:
287: /*
288: FIXME: check minimum size requirements are met, possibly by just
289: checking for the -1 returns from the speed functions.
290: if (s.size < MPN_TOOM_TABLE_TO_MINSIZE (i))
291: continue;
292: */
293:
294: /* using method i at this size */
295: table[i] = s.size+1;
296: table[i+1] = MAX_SIZE;
297: ti = tuneup_measure (function, &s);
298: if (ti == -1.0)
299: abort ();
300:
301: /* using method i+1 at this size */
302: table[i] = s.size;
303: table[i+1] = s.size+1;
304: tiplus1 = tuneup_measure (function, &s);
305: if (tiplus1 == -1.0)
306: abort ();
307:
308: /* Calculate the fraction by which the one or the other routine is
309: slower. */
310: if (tiplus1 >= ti)
311: d = (tiplus1 - ti) / tiplus1; /* negative */
312: else
313: d = (tiplus1 - ti) / ti; /* positive */
314:
315: add_dat (s.size, d);
316:
317: new_thresh_idx = analyze_dat (i, 0);
318:
319:
320: if (option_trace >= 2)
321: printf ("i=%d size=%ld %.9f %.9f % .4f %c %d\n",
322: i, s.size, ti, tiplus1, d,
323: ti > tiplus1 ? '#' : ' ',
324: dat[new_thresh_idx].size);
325:
326: /* Stop if the last time method i was faster was more than a
327: certain number of measurements ago. */
328: #define STOP_SINCE_POSITIVE 200
329: if (d >= 0)
330: since_positive = 0;
331: else
332: if (++since_positive > STOP_SINCE_POSITIVE)
333: {
334: if (option_trace >= 1)
335: printf ("i=%d stopped due to since_positive (%d)\n",
336: i, STOP_SINCE_POSITIVE);
337: break;
338: }
339:
340: /* Stop if method i has become slower by a certain factor. */
341: #define STOP_FACTOR 1.2
342: if (ti >= tiplus1 * STOP_FACTOR)
343: {
344: if (option_trace >= 1)
345: printf ("i=%d stopped due to ti >= tiplus1 * factor (%.1f)\n",
346: i, STOP_FACTOR);
347: break;
348: }
349:
350: /* Stop if the threshold implied hasn't changed in a certain
351: number of measurements. (It's this condition that ususally
352: stops the loop.) */
353: if (thresh_idx != new_thresh_idx)
354: since_thresh_change = 0, thresh_idx = new_thresh_idx;
355: else
356: if (++since_thresh_change > param->stop_since_change)
357: {
358: if (option_trace >= 1)
359: printf ("i=%d stopped due to since_thresh_change (%d)\n",
360: i, param->stop_since_change);
361: break;
362: }
363:
364: /* Stop if the threshold implied is more than a certain number of
365: measurements ago. */
366: #define STOP_SINCE_AFTER 500
367: if (ndat - thresh_idx > STOP_SINCE_AFTER)
368: {
369: if (option_trace >= 1)
370: printf ("i=%d stopped due to ndat - thresh_idx > amount (%d)\n",
371: i, STOP_SINCE_AFTER);
372: break;
373: }
374: }
375:
376: /* Stop when the size limit is reached before the end of the
377: crossover, without a specified param->max_size[i]. */
378: if (s.size >= MAX_SIZE)
379: {
380: fprintf (stderr, "%s\n", param->name[i]);
381: fprintf (stderr, "i=%d sizes %ld to %ld total %d measurements\n",
382: i, dat[0].size, dat[ndat-1].size, ndat);
383: fprintf (stderr, " max size reached before end of crossover\n");
384: break;
385: }
386:
387: if (option_trace >= 1)
388: printf ("i=%d sizes %ld to %ld total %d measurements\n",
389: i, dat[0].size, dat[ndat-1].size, ndat);
390:
391: if (ndat == 0)
392: break;
393:
394: table[i] = dat[analyze_dat (i, 1)].size;
395:
396: print_define (param->name[i], table[i]);
397:
398: /* Look for the next threshold starting from the current one, but back
399: a bit. */
400: s.size = table[i]+1;
401: }
402: }
403:
404:
405: /* Special probing for the fft thresholds. The size restrictions on the
406: FFTs mean the graph of time vs size has a step effect. See this for
407: example using
408:
409: ./speed -s 4096-16384 -t 128 -P foo mpn_mul_fft.8 mpn_mul_fft.9
410: gnuplot foo.gnuplot
411:
412: The current approach is to compare routines at the midpoint of relevant
413: steps. Arguably a more sophisticated system of threshold data is wanted
414: if this step effect remains. */
415:
416: struct fft_param_t {
417: const char *table_name;
418: const char *threshold_name;
419: const char *modf_threshold_name;
420: mp_size_t *p_threshold;
421: mp_size_t *p_modf_threshold;
422: mp_size_t first_size;
423: mp_size_t max_size;
424: speed_function_t function;
425: speed_function_t mul_function;
426: mp_size_t sqr;
427: };
428:
429: /* mpn_mul_fft requires pl a multiple of 2^k limbs, but with
430: N=pl*BIT_PER_MP_LIMB it internally also pads out so N/2^k is a multiple
431: of 2^(k-1) bits. */
432:
433: mp_size_t
434: fft_step_size (int k)
435: {
436: if (2*k-1 > BITS_PER_INT)
437: {
438: printf ("Can't handle k=%d\n", k);
439: abort ();
440: }
441: return (1<<k) * (MAX (1<<(k-1), BITS_PER_MP_LIMB)) / BITS_PER_MP_LIMB;
442: }
443:
444: mp_size_t
445: fft_next_size (mp_size_t pl, int k)
446: {
447: mp_size_t m = fft_step_size (k);
448:
449: /* printf ("[k=%d %ld] %ld ->", k, m, pl); */
450:
451: if (pl == 0 || (pl & (m-1)) != 0)
452: pl = (pl | (m-1)) + 1;
453:
454: /* printf (" %ld\n", pl); */
455: return pl;
456: }
457:
458: void
459: fft (struct fft_param_t *p)
460: {
461: mp_size_t size;
462: int i, k;
463:
464: for (i = 0; i < numberof (mpn_fft_table[p->sqr]); i++)
465: mpn_fft_table[p->sqr][i] = MP_SIZE_T_MAX;
466:
467: *p->p_threshold = MP_SIZE_T_MAX;
468: *p->p_modf_threshold = MP_SIZE_T_MAX;
469:
470: option_trace = MAX (option_trace, option_fft_trace);
471:
472: printf ("#ifndef %s\n", p->table_name);
473: printf ("#define %s {", p->table_name);
474: if (option_trace >= 2)
475: printf ("\n");
476:
477: k = FFT_FIRST_K;
478: size = p->first_size;
479: for (;;)
480: {
481: double tk, tk1;
482:
483: size = fft_next_size (size+1, k+1);
484:
485: if (size >= p->max_size)
486: break;
487: if (k >= FFT_FIRST_K + numberof (mpn_fft_table[p->sqr]))
488: break;
489:
490: usleep(10000);
491:
492: /* compare k to k+1 in the middle of the current k+1 step */
493: s.size = size + fft_step_size (k+1) / 2;
494: s.r = k;
495: tk = tuneup_measure (p->function, &s);
496: if (tk == -1.0)
497: abort ();
498:
499: usleep(10000);
500:
501: s.r = k+1;
502: tk1 = tuneup_measure (p->function, &s);
503: if (tk1 == -1.0)
504: abort ();
505:
506: if (option_trace >= 2)
507: printf ("at %ld size=%ld k=%d %.9lf k=%d %.9lf\n",
508: size, s.size, k, tk, k+1, tk1);
509:
510: /* declare the k+1 threshold as soon as it's faster at its midpoint */
511: if (tk1 < tk)
512: {
513: mpn_fft_table[p->sqr][k-FFT_FIRST_K] = s.size;
514: printf (" %ld,", s.size);
515: if (option_trace >= 2) printf ("\n");
516: k++;
517: }
518: }
519:
520: mpn_fft_table[p->sqr][k-FFT_FIRST_K] = 0;
521: printf (" 0 }\n");
522: printf ("#endif\n");
523:
524:
525: size = p->first_size;
526:
527: /* Declare an FFT faster than a plain toom3 etc multiplication found as
528: soon as one faster measurement obtained. A multiplication in the
529: middle of the FFT step is tested. */
530: for (;;)
531: {
532: int modf = (*p->p_modf_threshold == MP_SIZE_T_MAX);
533: double tk, tm;
534:
535: /* k=7 should be the first FFT which can beat toom3 on a full
536: multiply, so jump to that threshold and save some probing after the
537: modf threshold is found. */
538: if (!modf && size < mpn_fft_table[p->sqr][2])
539: {
540: size = mpn_fft_table[p->sqr][2];
541: if (option_trace >= 2)
542: printf ("jump to size=%ld\n", size);
543: }
544:
545: size = fft_next_size (size+1, mpn_fft_best_k (size, p->sqr));
546: k = mpn_fft_best_k (size, p->sqr);
547:
548: if (size >= p->max_size)
549: break;
550:
551: usleep(10000);
552:
553: s.size = size + fft_step_size (k) / 2;
554: s.r = k;
555: tk = tuneup_measure (p->function, &s);
556: if (tk == -1.0)
557: abort ();
558:
559: usleep(10000);
560:
561: if (!modf) s.size /= 2;
562: tm = tuneup_measure (p->mul_function, &s);
563: if (tm == -1.0)
564: abort ();
565:
566: if (option_trace >= 2)
567: printf ("at %ld size=%ld k=%d %.9lf size=%ld %s mul %.9lf\n",
568: size,
569: size + fft_step_size (k) / 2, k, tk,
570: s.size, modf ? "modf" : "full", tm);
571:
572: if (tk < tm)
573: {
574: if (modf)
575: {
576: *p->p_modf_threshold = s.size;
577: print_define (p->modf_threshold_name, *p->p_modf_threshold);
578: }
579: else
580: {
581: *p->p_threshold = s.size;
582: print_define (p->threshold_name, *p->p_threshold);
583: break;
584: }
585: }
586: }
587:
588: }
589:
590:
591: void
592: all (void)
593: {
594: TMP_DECL (marker);
595:
596: TMP_MARK (marker);
597: s.xp_block = SPEED_TMP_ALLOC_LIMBS (SPEED_BLOCK_SIZE, 0);
598: s.yp_block = SPEED_TMP_ALLOC_LIMBS (SPEED_BLOCK_SIZE, 0);
599:
600: speed_time_init ();
601: fprintf (stderr, "speed_precision %d, speed_unittime %.2e\n",
602: speed_precision, speed_unittime);
603: fprintf (stderr, "MAX_SIZE %ld, fft_max_size %ld, STEP_FACTOR %.3f\n",
604: MAX_SIZE, option_fft_max_size, STEP_FACTOR);
605: fprintf (stderr, "\n");
606:
607: {
608: struct tm *tp;
609: time_t t;
610: time (&t);
611: tp = localtime (&t);
612: printf ("/* Generated by tuneup.c, %d-%02d-%02d. */\n\n",
613: tp->tm_year+1900, tp->tm_mon+1, tp->tm_mday);
614: }
615:
616: {
617: static struct param_t param;
618: param.name[0] = "KARATSUBA_MUL_THRESHOLD";
619: param.name[1] = "TOOM3_MUL_THRESHOLD";
620: param.max_size[1] = TOOM3_MUL_THRESHOLD_LIMIT;
621: one (speed_mpn_mul_n, mul_threshold, numberof(mul_threshold)-1, ¶m);
622: }
623: printf("\n");
624:
625: {
626: static struct param_t param;
627: param.name[0] = "KARATSUBA_SQR_THRESHOLD";
628: param.name[1] = "TOOM3_SQR_THRESHOLD";
629: param.max_size[0] = KARATSUBA_SQR_MAX;
630: one (speed_mpn_sqr_n, sqr_threshold, numberof(sqr_threshold)-1, ¶m);
631: }
632: printf("\n");
633:
634: {
635: static struct param_t param;
636: param.name[0] = "BZ_THRESHOLD";
637: one (speed_mpn_bz_tdiv_qr, bz_threshold, 1, ¶m);
638: }
639: printf("\n");
640:
641: {
642: static struct param_t param;
643: param.name[0] = "FIB_THRESHOLD";
644: one (speed_mpz_fib_ui, fib_threshold, 1, ¶m);
645: }
646: printf("\n");
647:
648: /* mpz_powm becomes slow before long, so stop soon after the determined
649: threshold stops changing. */
650: {
651: static struct param_t param;
652: param.name[0] = "POWM_THRESHOLD";
653: param.stop_since_change = 15;
654: one (speed_mpz_powm, powm_threshold, 1, ¶m);
655: }
656: printf("\n");
657:
658: {
659: static struct param_t param;
660: param.name[0] = "GCD_ACCEL_THRESHOLD";
661: param.min_size = 1;
662: one (speed_mpn_gcd, gcd_accel_threshold, 1, ¶m);
663: }
664: {
665: static struct param_t param;
666: param.name[0] = "GCDEXT_THRESHOLD";
667: param.min_size = 1;
668: param.max_size[0] = 200;
669: one (speed_mpn_gcdext, gcdext_threshold, 1, ¶m);
670: }
671: printf("\n");
672:
673: if (option_fft_max_size != 0)
674: {
675: {
676: static struct fft_param_t param;
677: param.table_name = "FFT_MUL_TABLE";
678: param.threshold_name = "FFT_MUL_THRESHOLD";
679: param.p_threshold = &FFT_MUL_THRESHOLD;
680: param.modf_threshold_name = "FFT_MODF_MUL_THRESHOLD";
681: param.p_modf_threshold = &FFT_MODF_MUL_THRESHOLD;
682: param.first_size = TOOM3_MUL_THRESHOLD / 2;
683: param.max_size = option_fft_max_size;
684: param.function = speed_mpn_mul_fft;
685: param.mul_function = speed_mpn_mul_n;
686: param.sqr = 0;
687: fft (¶m);
688: }
689: printf("\n");
690: {
691: static struct fft_param_t param;
692: param.table_name = "FFT_SQR_TABLE";
693: param.threshold_name = "FFT_SQR_THRESHOLD";
694: param.p_threshold = &FFT_SQR_THRESHOLD;
695: param.modf_threshold_name = "FFT_MODF_SQR_THRESHOLD";
696: param.p_modf_threshold = &FFT_MODF_SQR_THRESHOLD;
697: param.first_size = TOOM3_SQR_THRESHOLD / 2;
698: param.max_size = option_fft_max_size;
699: param.function = speed_mpn_mul_fft_sqr;
700: param.mul_function = speed_mpn_sqr_n;
701: param.sqr = 0;
702: fft (¶m);
703: }
704: printf ("\n");
705: }
706:
707: TMP_FREE (marker);
708: }
709:
710:
711: int
712: main (int argc, char *argv[])
713: {
714: int opt;
715:
716: /* Unbuffered so if output is redirected to a file it isn't lost if the
717: program is killed part way through. */
718: setbuf (stdout, NULL);
719: setbuf (stderr, NULL);
720:
721: while ((opt = getopt(argc, argv, "f:o:p:t")) != EOF)
722: {
723: switch (opt) {
724: case 'f':
725: if (optarg[0] == 't')
726: option_fft_trace = 2;
727: else
728: option_fft_max_size = atol (optarg);
729: break;
730: case 'o':
731: speed_option_set (optarg);
732: break;
733: case 'p':
734: speed_precision = atoi (optarg);
735: break;
736: case 't':
737: option_trace++;
738: break;
739: case '?':
740: exit(1);
741: }
742: }
743:
744: all ();
745: return 0;
746: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to tuneup.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / gmp / tune