/** * $Id:$ * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** * * The contents of this file may be used under the terms of either the GNU * General Public License Version 2 or later (the "GPL", see * http://www.gnu.org/licenses/gpl.html ), or the Blender License 1.0 or * later (the "BL", see http://www.blender.org/BL/ ) which has to be * bought from the Blender Foundation to become active, in which case the * above mentioned GPL option does not apply. * * The Original Code is Copyright (C) 1997 by Ton Roosendaal, Frank van Beek and Joeri Kassenaar. * All rights reserved. * * The Original Code is: all of this file. * * Contributor(s): none yet. * * ***** END GPL/BL DUAL LICENSE BLOCK ***** */ /** * $Id:$ * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** * * The contents of this file may be used under the terms of either the GNU * General Public License Version 2 or later (the "GPL", see * http://www.gnu.org/licenses/gpl.html ), or the Blender License 1.0 or * later (the "BL", see http://www.blender.org/BL/ ) which has to be * bought from the Blender Foundation to become active, in which case the * above mentioned GPL option does not apply. * * The Original Code is Copyright (C) 1997 by Ton Roosendaal, Frank van Beek and Joeri Kassenaar. * All rights reserved. * * The Original Code is: all of this file. * * Contributor(s): none yet. * * ***** END GPL/BL DUAL LICENSE BLOCK ***** */ /* uit netnews: * email: cmaae47@ic.ac.uk (Thomas Sippel - Dau) (uk.ac.ic on Janet) * voice: +44 (1)71 594 6904 (day), or +44 (1)71 594 6957 (fax) * snail: Imperial College of Science, Technology and Medicine cc -DR -O2 performance.c -lm -o performance cc -DR -O2 -mips2 performance.c -lm -o performance 25 MHz 486 under DOS 0.45 Mflops 25 MHz 486 under SCO Unix 0.95 Mflops 66 MKz 486 DX2 under Linux and gcc 2.0 Mflops RS/6000 model 530 ( 25 MHz) 2.6 Mflops CDC 4340 2.8 Mflops Sparkstation 2 3.2 Mflops Iris 4D/30 3.4 Mflops Iris Indigo ( 33 MHz) 3.7 Mflops alpha model 300L (100 MHz) 6.3 Mflops HP 7000 model 720 ( 50 MHz) 6.5 Mflops Iris Indigo R4000 (100 MHz) 6.5 Mflops Iris Indigo R4000 (100 MHz) 8.9 Mflops (compiled with -mips2) BIJ NEOGEO: quad (R4000 100MHz) 8.99 Mflops (-mips2) indigo (R3000 33 MHz) 3.85 Mflops iris (R3000 30 MHz) 3.56 Mflops */ /**** benchmark for testing floating point performance * * fpr - Find Prime Root modulo a prime. * ** 13. 7. 1987 original cast using Ansi C time interface tsd * 30. 6. 1994 readied for distribution tsd * ** Copyright (C) July 1987 Thomas Sippel - Dau * * This program may by copied and adapted for other systems * as long as the following conditions are met: * * o this copyright notice must not be removed, altered or mutilated * o the program may only be used or adapted for peaceful purposes * o the program and adaptions must be made available in source form * to anybody who is being offered a binary translation * o the weighting of 8 flop for the inner loop must be kept for * results published */ /* Useful primes for this program: * * 257, 8191, 65521, 65537, 999959, 999961, 999983, 9999943, 99999941 * * The formal worst case requirement for the algorithm is that the * prime number (the first argument) is less than the square root of * the maximum number the architecture can handle, i.e. for 32 bit * integers, the prime number should be less than 65536 for unsigned * and less than 32768 for signed ints. In practice, the biggest number * that is actually generated is (limit-1)*(seed+n), for a small n. * The asymptotic density of prime roots is about 1/e, so some should * be found fairly rapidly. * * If the limit is not a prime, this program is in an infinite loop. * This is done to defeat compiler optimisations, it is NOT a bug. * * The central loop can be abandoned when the local iteration count * (cnt) is greater than (limit-1)/2, but a compiler that can do that * optimisation from general principles has not yet come my way. */ #include #include /* Some C compilers use CLK_TCK 1,000,000 for some bogus compatibility * arguments. A correctly implemented ansi C compiler will skip the * following code. In any case, cross-check results with the system * processing time reporting to give reasonable results. */ #ifndef CLK_TCK #define CLK_TCK 100 /* this may be 60 on some machines - best use ansi */ #include #include #define clock_t long clock_t clock () { struct tms t; times ( &t ); return ( t.tms_utime + t.tms_stime ); /* no children */ } #endif /* clock () for systems not yet bothering to support ansi C */ #ifdef R #define reg register #else #define reg #endif main ( argc, argv ) int argc; char **argv; { reg long int prim, test, rest, quot, cnt, its; long int xprim = 999959, xtest =100; reg double prod; clock_t secs; if ( argc > 1 ) xprim = atoi ( argv [ 1 ] ); if ( argc > 2 ) xtest = atoi ( argv [ 2 ] ); if ( argc != 3 ) help ( *argv ); secs = clock (); its = 0; prim = xprim; test = xtest % prim; if ( prim < 0L ) prim = -prim; if ( test < 0L ) test = -test; do { rest = 1; cnt = 1; test++; do { prod = test * ( double ) rest; /* 1 flop, 2 conv */ quot = prod / prim; /* 1 flop, 2 conv */ rest = prod - prim * ( double ) quot; /* 2 flop, 3 conv */ cnt++; /* 1 integer inc */ } while ( rest > 1L ); /* test and jump */ /* counting conversion as half a * * floating point operation, we * * should get about 8 flops/loop */ its += cnt++; } while ( cnt < prim && prim > test ); secs = clock () - secs; prod = secs / ( double ) (10000.0*CLK_TCK); printf ( "%9s: %d is a prime root of %d, found after %d tries\n", *argv, test, prim, its ); printf ( "%9s: %.3f seconds prime root extraction time, %.3f kiloflops\n", *argv, prod, 8 * its / ( 1000 * prod ) ); exit (0); } help ( progname ) char *progname; { fprintf ( stderr, "Syntax: %s \n", progname ); fprintf ( stderr, "%s%s%s%s", "Function: find a prime root modulo \n", "Parameters:\n", " a prime number to be the modulus\n", " value past which to start searching\n" ); }