[llvm-commits] [test-suite] r168264 - in /test-suite/trunk/SingleSource/Benchmarks: ./ LivermoreLoops/
David Blaikie
dblaikie at gmail.com
Fri Dec 7 15:41:00 PST 2012
It'd be really nice to clean this up... seems it's either up to you to
do so, or the buildslave maintainers. I'd prefer you to look into
this, since you introduced it. If you don't have the resources to
reproduce this, let me know how I can help to provide repro steps or
data from the slaves themselves.
On Sun, Nov 25, 2012 at 11:15 AM, David Blaikie <dblaikie at gmail.com> wrote:
> On Sat, Nov 17, 2012 at 10:52 AM, Renato Golin <rengolin at systemcall.org> wrote:
>> Author: rengolin
>> Date: Sat Nov 17 12:52:20 2012
>> New Revision: 168264
>>
>> URL: http://llvm.org/viewvc/llvm-project?rev=168264&view=rev
>> Log:
>> Adding simplified LivermoreLoops benchmarks, split kernels and created bogus heuristics for FP precision tests/vectorization
>
> This has been/is failing on the ubuntu builder:
> http://lab.llvm.org:8011/builders/clang-x86_64-debian-fnt/builds/12074/steps/make.test-suite/logs/fail.LLC
>
> Could you please investigate/fix.
>
>
>>
>> Added:
>> test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/
>> test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/Makefile
>> test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/README
>> test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel01.c
>> test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel01.reference_output
>> test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel02.c
>> test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel02.reference_output
>> test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel03.c
>> test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel03.reference_output
>> test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel04.c
>> test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel04.reference_output
>> test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel05.c
>> test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel05.reference_output
>> test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel06.c
>> test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel06.reference_output
>> test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel07.c
>> test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel07.reference_output
>> test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel08.c
>> test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel08.reference_output
>> test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel09.c
>> test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel09.reference_output
>> test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel10.c
>> test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel10.reference_output
>> test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel11.c
>> test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel11.reference_output
>> test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel12.c
>> test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel12.reference_output
>> test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel13.c
>> test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel13.reference_output
>> test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel14.c
>> test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel14.reference_output
>> test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel15.c
>> test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel15.reference_output
>> test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel16.c
>> test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel16.reference_output
>> test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel17.c
>> test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel17.reference_output
>> test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel18.c
>> test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel18.reference_output
>> test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel19.c
>> test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel19.reference_output
>> test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel20.c
>> test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel20.reference_output
>> test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel21.c
>> test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel21.reference_output
>> test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel22.c
>> test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel22.reference_output
>> test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel23.c
>> test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel23.reference_output
>> test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel24.c
>> test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel24.reference_output
>> test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/lloops.h
>> Modified:
>> test-suite/trunk/SingleSource/Benchmarks/Makefile
>>
>> Added: test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/Makefile
>> URL: http://llvm.org/viewvc/llvm-project/test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/Makefile?rev=168264&view=auto
>> ==============================================================================
>> --- test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/Makefile (added)
>> +++ test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/Makefile Sat Nov 17 12:52:20 2012
>> @@ -0,0 +1,7 @@
>> +LEVEL = ../../..
>> +
>> +LDFLAGS += -m64 -lrt -lc -lm
>> +
>> +FP_TOLERANCE := 0.0001
>> +
>> +include $(LEVEL)/SingleSource/Makefile.singlesrc
>>
>> Added: test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/README
>> URL: http://llvm.org/viewvc/llvm-project/test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/README?rev=168264&view=auto
>> ==============================================================================
>> --- test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/README (added)
>> +++ test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/README Sat Nov 17 12:52:20 2012
>> @@ -0,0 +1,68 @@
>> +This benchmark has been extensively modified to cope with LNT's infrastructure.
>> +
>> +It no longer checks for CPU frequency, nor produces comparable outputs to
>> +previous versions. The main reason to have this benchmark is to check both
>> +performance and correctness of floating point loop reductions during
>> +vectorization, so the heuristics provided is nothing more than just
>> +a floating point hash generated from some of the data to compare for
>> +floating point accuracy.
>> +
>> +Also, the timings are being taken on the whole executable (by LNT), so
>> +they're not as accurate as taking the inner loop, since there is considerable
>> +code to prepare the data and to calculate the heuristics.
>> +
>> +However, both prepare and heuristics are fp-loop based, so will also
>> +benefit from optimizations in that area, which will affect the final
>> +timing.
>> +
>> +File downloaded from http://www.roylongbottom.org.uk/classic.htm
>> +
>> +Extracted from original code at http://www.netlib.org/benchmark/livermorec
>> +
>> +/* Livermore Loops coded in C Latest File Modification 20 Oct 92,
>> + * by Tim Peters, Kendall Square Res. Corp. tim at ksr.com, ksr!tim at uunet.uu.net
>> + * SUBROUTINE KERNEL( TK) replaces the Fortran routine in LFK Test program.
>> + ************************************************************************
>> + * *
>> + * KERNEL executes 24 samples of "C" computation *
>> + * *
>> + * TK(1) - total cpu time to execute only the 24 kernels.*
>> + * TK(2) - total Flops executed by the 24 Kernels *
>> + * *
>> + ************************************************************************
>> + * *
>> + * L. L. N. L. " C " K E R N E L S: M F L O P S *
>> + * *
>> + * These kernels measure " C " numerical computation *
>> + * rates for a spectrum of cpu-limited computational *
>> + * structures or benchmarks. Mathematical through-put *
>> + * is measured in units of millions of floating-point *
>> + * operations executed per second, called Megaflops/sec. *
>> + * *
>> + * Fonzi's Law: There is not now and there never will be a language *
>> + * in which it is the least bit difficult to write *
>> + * bad programs. *
>> + * F.H.MCMAHON 1972 *
>> + ************************************************************************
>> + *Originally from Greg Astfalk, AT&T, P.O.Box 900, Princeton, NJ. 08540*
>> + * by way of Frank McMahon (LLNL). *
>> + * *
>> + * REFERENCE *
>> + * *
>> + * F.H.McMahon, The Livermore Fortran Kernels: *
>> + * A Computer Test Of The Numerical Performance Range, *
>> + * Lawrence Livermore National Laboratory, *
>> + * Livermore, California, UCRL-53745, December 1986. *
>> + * *
>> + * from: National Technical Information Service *
>> + * U.S. Department of Commerce *
>> + * 5285 Port Royal Road *
>> + * Springfield, VA. 22161 *
>> + * *
>> + * Changes made to correct many array subscripting problems, *
>> + * make more readable (added #define's), include the original *
>> + * FORTRAN versions of the runs as comments, and make more *
>> + * portable by Kelly O'Hair (LLNL) and Chuck Rasbold (LLNL). *
>> + * *
>> + ************************************************************************
>> + */
>>
>> Added: test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel01.c
>> URL: http://llvm.org/viewvc/llvm-project/test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel01.c?rev=168264&view=auto
>> ==============================================================================
>> --- test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel01.c (added)
>> +++ test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel01.c Sat Nov 17 12:52:20 2012
>> @@ -0,0 +1,38 @@
>> +/***********************************************************************
>> + * gcc kernel01.c -m64 -lrt -lc -lm
>> + * L. L. N. L. " C " K E R N E L S: M F L O P S P C V E R S I O N
>> + */
>> +
>> +#include "lloops.h"
>> +
>> +/********************************************************************
>> +* Kernel 1 -- hydro fragment *
>> +********************************************************************/
>> +double kernel01()
>> +{
>> + unsigned iter = 0;
>> + long k;
>> + double heuristics=0.0;
>> +
>> + parameters (1);
>> + do
>> + {
>> + for ( k=0 ; k<n ; k++ )
>> + {
>> + x[k] = q + y[k]*( r*z[k+10] + t*z[k+11] );
>> + }
>> +
>> + }
>> + while (iter++ < ITERATIONS);
>> +
>> + for ( k=0; k<n; k++ )
>> + heuristics += x[k];
>> +
>> + return heuristics;
>> +}
>> +
>> +int main(int argc, char *argv[])
>> +{
>> + printf("%f\n", kernel01());
>> + return 0;
>> +}
>>
>> Added: test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel01.reference_output
>> URL: http://llvm.org/viewvc/llvm-project/test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel01.reference_output?rev=168264&view=auto
>> ==============================================================================
>> --- test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel01.reference_output (added)
>> +++ test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel01.reference_output Sat Nov 17 12:52:20 2012
>> @@ -0,0 +1,2 @@
>> +114.305175
>> +exit 0
>>
>> Added: test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel02.c
>> URL: http://llvm.org/viewvc/llvm-project/test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel02.c?rev=168264&view=auto
>> ==============================================================================
>> --- test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel02.c (added)
>> +++ test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel02.c Sat Nov 17 12:52:20 2012
>> @@ -0,0 +1,48 @@
>> +/***********************************************************************
>> + * gcc kernel02.c -m64 -lrt -lc -lm
>> + * L. L. N. L. " C " K E R N E L S: M F L O P S P C V E R S I O N
>> + */
>> +
>> +#include "lloops.h"
>> +
>> +/**********************************************************************
>> +* Kernel 2 -- ICCG excerpt (Incomplete Cholesky Conjugate Gradient) *
>> +**********************************************************************/
>> +double kernel02()
>> +{
>> + long ipnt, ipntp, ii;
>> + long i, k;
>> + double heuristics=0.0;
>> + unsigned iter = 0;
>> +
>> + parameters (2);
>> + do
>> + {
>> + ii = n;
>> + ipntp = 0;
>> + do
>> + {
>> + ipnt = ipntp;
>> + ipntp += ii;
>> + ii /= 2;
>> + i = ipntp;
>> + for ( k=ipnt+1 ; k<ipntp ; k=k+2 )
>> + {
>> + i++;
>> + x[i] = x[k] - v[k]*x[k-1] - v[k+1]*x[k+1];
>> + }
>> + } while ( ii>0 );
>> + }
>> + while (iter++ < ITERATIONS);
>> +
>> + for ( k=0; k<n; k++ )
>> + heuristics += x[k];
>> +
>> + return heuristics;
>> +}
>> +
>> +int main(int argc, char *argv[])
>> +{
>> + printf("%f\n", kernel02());
>> + return 0;
>> +}
>>
>> Added: test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel02.reference_output
>> URL: http://llvm.org/viewvc/llvm-project/test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel02.reference_output?rev=168264&view=auto
>> ==============================================================================
>> --- test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel02.reference_output (added)
>> +++ test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel02.reference_output Sat Nov 17 12:52:20 2012
>> @@ -0,0 +1,2 @@
>> +10.098717
>> +exit 0
>>
>> Added: test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel03.c
>> URL: http://llvm.org/viewvc/llvm-project/test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel03.c?rev=168264&view=auto
>> ==============================================================================
>> --- test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel03.c (added)
>> +++ test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel03.c Sat Nov 17 12:52:20 2012
>> @@ -0,0 +1,36 @@
>> +/***********************************************************************
>> + * gcc kernel03.c -m64 -lrt -lc -lm
>> + * L. L. N. L. " C " K E R N E L S: M F L O P S P C V E R S I O N
>> + */
>> +
>> +#include "lloops.h"
>> +
>> +/********************************************************************
>> +* Kernel 3 -- inner product *
>> +********************************************************************/
>> +double kernel03()
>> +{
>> + long k;
>> + unsigned iter = 0;
>> + double heuristics=0.0;
>> +
>> + parameters (3);
>> + do
>> + {
>> + q = 0.0;
>> + for ( k=0 ; k<n ; k++ )
>> + {
>> + q += z[k]*x[k];
>> + }
>> + heuristics += q;
>> + }
>> + while (iter++ < ITERATIONS);
>> +
>> + return heuristics;
>> +}
>> +
>> +int main(int argc, char *argv[])
>> +{
>> + printf("%f\n", kernel03());
>> + return 0;
>> +}
>>
>> Added: test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel03.reference_output
>> URL: http://llvm.org/viewvc/llvm-project/test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel03.reference_output?rev=168264&view=auto
>> ==============================================================================
>> --- test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel03.reference_output (added)
>> +++ test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel03.reference_output Sat Nov 17 12:52:20 2012
>> @@ -0,0 +1,2 @@
>> +1000752.890492
>> +exit 0
>>
>> Added: test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel04.c
>> URL: http://llvm.org/viewvc/llvm-project/test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel04.c?rev=168264&view=auto
>> ==============================================================================
>> --- test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel04.c (added)
>> +++ test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel04.c Sat Nov 17 12:52:20 2012
>> @@ -0,0 +1,48 @@
>> +/***********************************************************************
>> + * gcc kernel04.c -m64 -lrt -lc -lm
>> + * L. L. N. L. " C " K E R N E L S: M F L O P S P C V E R S I O N
>> + */
>> +
>> +#include "lloops.h"
>> +
>> +/********************************************************************
>> +* Kernel 4 -- banded linear equations *
>> +********************************************************************/
>> +double kernel04()
>> +{
>> + long lw;
>> + double temp;
>> + long j, k, m;
>> + double heuristics=0.0;
>> + unsigned iter = 0;
>> +
>> + parameters (4);
>> + m = ( 1001-7 )/2;
>> + do
>> + {
>> + for ( k=6 ; k<1001 ; k=k+m )
>> + {
>> + lw = k - 6;
>> + temp = x[k-1];
>> +
>> + for ( j=4 ; j<n ; j=j+5 )
>> + {
>> + temp -= x[lw]*y[j];
>> + lw++;
>> + }
>> + x[k-1] = y[4]*temp;
>> + }
>> + }
>> + while (iter++ < ITERATIONS);
>> +
>> + for ( k=0; k<n; k++ )
>> + heuristics += x[k];
>> +
>> + return heuristics;
>> +}
>> +
>> +int main(int argc, char *argv[])
>> +{
>> + printf("%f\n", kernel04());
>> + return 0;
>> +}
>>
>> Added: test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel04.reference_output
>> URL: http://llvm.org/viewvc/llvm-project/test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel04.reference_output?rev=168264&view=auto
>> ==============================================================================
>> --- test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel04.reference_output (added)
>> +++ test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel04.reference_output Sat Nov 17 12:52:20 2012
>> @@ -0,0 +1,2 @@
>> +23.058175
>> +exit 0
>>
>> Added: test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel05.c
>> URL: http://llvm.org/viewvc/llvm-project/test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel05.c?rev=168264&view=auto
>> ==============================================================================
>> --- test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel05.c (added)
>> +++ test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel05.c Sat Nov 17 12:52:20 2012
>> @@ -0,0 +1,37 @@
>> +/***********************************************************************
>> + * gcc kernel05.c -m64 -lrt -lc -lm
>> + * L. L. N. L. " C " K E R N E L S: M F L O P S P C V E R S I O N
>> + */
>> +
>> +#include "lloops.h"
>> +
>> +/********************************************************************
>> +* Kernel 5 -- tri-diagonal elimination, below diagonal *
>> +********************************************************************/
>> +double kernel05()
>> +{
>> + long i;
>> + unsigned iter = 0;
>> + double heuristics=0.0;
>> +
>> + parameters (5);
>> + do
>> + {
>> + for ( i=1 ; i<n ; i++ )
>> + {
>> + x[i] = z[i]*( y[i] - x[i-1] );
>> + }
>> + }
>> + while (iter++ < ITERATIONS);
>> +
>> + for ( i=0; i<n; i++ )
>> + heuristics += x[i];
>> +
>> + return heuristics;
>> +}
>> +
>> +int main(int argc, char *argv[])
>> +{
>> + printf("%f\n", kernel05());
>> + return 0;
>> +}
>>
>> Added: test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel05.reference_output
>> URL: http://llvm.org/viewvc/llvm-project/test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel05.reference_output?rev=168264&view=auto
>> ==============================================================================
>> --- test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel05.reference_output (added)
>> +++ test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel05.reference_output Sat Nov 17 12:52:20 2012
>> @@ -0,0 +1,2 @@
>> +64.724263
>> +exit 0
>>
>> Added: test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel06.c
>> URL: http://llvm.org/viewvc/llvm-project/test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel06.c?rev=168264&view=auto
>> ==============================================================================
>> --- test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel06.c (added)
>> +++ test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel06.c Sat Nov 17 12:52:20 2012
>> @@ -0,0 +1,41 @@
>> +/***********************************************************************
>> + * gcc kernel06.c -m64 -lrt -lc -lm
>> + * L. L. N. L. " C " K E R N E L S: M F L O P S P C V E R S I O N
>> + */
>> +
>> +#include "lloops.h"
>> +
>> +/********************************************************************
>> +* Kernel 6 -- general linear recurrence equations *
>> +********************************************************************/
>> +double kernel06()
>> +{
>> + long i, k;
>> + unsigned iter = 0;
>> + double heuristics=0.0;
>> +
>> + parameters (6);
>> + do
>> + {
>> + for ( i=1 ; i<n ; i++ )
>> + {
>> + w[i] = 0.01;
>> + for ( k=0 ; k<i ; k++ )
>> + {
>> + w[i] += b[k][i] * w[(i-k)-1];
>> + }
>> + }
>> + }
>> + while (iter++ < ITERATIONS);
>> +
>> + for ( i=0; i<n; i++ )
>> + heuristics += w[i];
>> +
>> + return heuristics;
>> +}
>> +
>> +int main(int argc, char *argv[])
>> +{
>> + printf("%f\n", kernel06());
>> + return 0;
>> +}
>>
>> Added: test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel06.reference_output
>> URL: http://llvm.org/viewvc/llvm-project/test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel06.reference_output?rev=168264&view=auto
>> ==============================================================================
>> --- test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel06.reference_output (added)
>> +++ test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel06.reference_output Sat Nov 17 12:52:20 2012
>> @@ -0,0 +1,2 @@
>> +0.726808
>> +exit 0
>>
>> Added: test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel07.c
>> URL: http://llvm.org/viewvc/llvm-project/test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel07.c?rev=168264&view=auto
>> ==============================================================================
>> --- test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel07.c (added)
>> +++ test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel07.c Sat Nov 17 12:52:20 2012
>> @@ -0,0 +1,39 @@
>> +/***********************************************************************
>> + * gcc kernel07.c -m64 -lrt -lc -lm
>> + * L. L. N. L. " C " K E R N E L S: M F L O P S P C V E R S I O N
>> + */
>> +
>> +#include "lloops.h"
>> +
>> +/********************************************************************
>> +* Kernel 7 -- equation of state fragment *
>> +********************************************************************/
>> +double kernel07()
>> +{
>> + long k;
>> + unsigned iter = 0;
>> + double heuristics=0.0;
>> +
>> + parameters (7);
>> + do
>> + {
>> + for ( k=0 ; k<n ; k++ )
>> + {
>> + x[k] = u[k] + r*( z[k] + r*y[k] ) +
>> + t*( u[k+3] + r*( u[k+2] + r*u[k+1] ) +
>> + t*( u[k+6] + q*( u[k+5] + q*u[k+4] ) ) );
>> + }
>> + }
>> + while (iter++ < ITERATIONS);
>> +
>> + for ( k=0; k<n; k++ )
>> + heuristics += x[k];
>> +
>> + return heuristics;
>> +}
>> +
>> +int main(int argc, char *argv[])
>> +{
>> + printf("%f\n", kernel07());
>> + return 0;
>> +}
>>
>> Added: test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel07.reference_output
>> URL: http://llvm.org/viewvc/llvm-project/test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel07.reference_output?rev=168264&view=auto
>> ==============================================================================
>> --- test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel07.reference_output (added)
>> +++ test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel07.reference_output Sat Nov 17 12:52:20 2012
>> @@ -0,0 +1,2 @@
>> +128.666894
>> +exit 0
>>
>> Added: test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel08.c
>> URL: http://llvm.org/viewvc/llvm-project/test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel08.c?rev=168264&view=auto
>> ==============================================================================
>> --- test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel08.c (added)
>> +++ test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel08.c Sat Nov 17 12:52:20 2012
>> @@ -0,0 +1,57 @@
>> +/***********************************************************************
>> + * gcc kernel08.c -m64 -lrt -lc -lm
>> + * L. L. N. L. " C " K E R N E L S: M F L O P S P C V E R S I O N
>> + */
>> +
>> +#include "lloops.h"
>> +
>> +/********************************************************************
>> +* Kernel 8 -- ADI integration *
>> +********************************************************************/
>> +double kernel08()
>> +{
>> + long nl1, nl2;
>> + long kx, ky;
>> + unsigned iter = 0;
>> + double heuristics=0.0;
>> +
>> + nl1 = 0;
>> + nl2 = 1;
>> +
>> + parameters (8);
>> + do
>> + {
>> + for ( kx=1 ; kx<3 ; kx++ )
>> + {
>> +
>> + for ( ky=1 ; ky<n ; ky++ )
>> + {
>> + du1[ky] = u1[nl1][ky+1][kx] - u1[nl1][ky-1][kx];
>> + du2[ky] = u2[nl1][ky+1][kx] - u2[nl1][ky-1][kx];
>> + du3[ky] = u3[nl1][ky+1][kx] - u3[nl1][ky-1][kx];
>> + u1[nl2][ky][kx]=
>> + u1[nl1][ky][kx]+a11*du1[ky]+a12*du2[ky]+a13*du3[ky] + sig*
>> + (u1[nl1][ky][kx+1]-2.0*u1[nl1][ky][kx]+u1[nl1][ky][kx-1]);
>> + u2[nl2][ky][kx]=
>> + u2[nl1][ky][kx]+a21*du1[ky]+a22*du2[ky]+a23*du3[ky] + sig*
>> + (u2[nl1][ky][kx+1]-2.0*u2[nl1][ky][kx]+u2[nl1][ky][kx-1]);
>> + u3[nl2][ky][kx]=
>> + u3[nl1][ky][kx]+a31*du1[ky]+a32*du2[ky]+a33*du3[ky] + sig*
>> + (u3[nl1][ky][kx+1]-2.0*u3[nl1][ky][kx]+u3[nl1][ky][kx-1]);
>> + }
>> + }
>> + }
>> + while (iter++ < ITERATIONS);
>> +
>> + for ( kx=0; kx<3; kx++ )
>> + for ( ky=0; ky<n; ky++ )
>> + heuristics += u3[nl2][ky][kx];
>> +
>> + return heuristics;
>> +}
>> +
>> +int main(int argc, char *argv[])
>> +{
>> + printf("%f\n", kernel08());
>> + return 0;
>> +}
>>
>> Added: test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel08.reference_output
>> URL: http://llvm.org/viewvc/llvm-project/test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel08.reference_output?rev=168264&view=auto
>> ==============================================================================
>> --- test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel08.reference_output (added)
>> +++ test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel08.reference_output Sat Nov 17 12:52:20 2012
>> @@ -0,0 +1,2 @@
>> +29.995340
>> +exit 0
>>
>> Added: test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel09.c
>> URL: http://llvm.org/viewvc/llvm-project/test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel09.c?rev=168264&view=auto
>> ==============================================================================
>> --- test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel09.c (added)
>> +++ test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel09.c Sat Nov 17 12:52:20 2012
>> @@ -0,0 +1,40 @@
>> +/***********************************************************************
>> + * gcc kernel09.c -m64 -lrt -lc -lm
>> + * L. L. N. L. " C " K E R N E L S: M F L O P S P C V E R S I O N
>> + */
>> +
>> +#include "lloops.h"
>> +
>> +/********************************************************************
>> +* Kernel 9 -- integrate predictors *
>> +********************************************************************/
>> +double kernel09()
>> +{
>> + long i;
>> + unsigned iter = 0;
>> + double heuristics=0.0;
>> +
>> + parameters (9);
>> + do
>> + {
>> + for ( i=0 ; i<n ; i++ )
>> + {
>> + px[i][0] = dm28*px[i][12] + dm27*px[i][11] + dm26*px[i][10] +
>> + dm25*px[i][ 9] + dm24*px[i][ 8] + dm23*px[i][ 7] +
>> + dm22*px[i][ 6] + c0*( px[i][ 4] + px[i][ 5])
>> + + px[i][ 2];
>> + }
>> + }
>> + while (iter++ < ITERATIONS);
>> +
>> + for ( i=0; i<n; i++ )
>> + heuristics += px[i][0];
>> +
>> + return heuristics;
>> +}
>> +
>> +int main(int argc, char *argv[])
>> +{
>> + printf("%f\n", kernel09());
>> + return 0;
>> +}
>>
>> Added: test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel09.reference_output
>> URL: http://llvm.org/viewvc/llvm-project/test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel09.reference_output?rev=168264&view=auto
>> ==============================================================================
>> --- test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel09.reference_output (added)
>> +++ test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel09.reference_output Sat Nov 17 12:52:20 2012
>> @@ -0,0 +1,2 @@
>> +-0.023686
>> +exit 0
>>
>> Added: test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel10.c
>> URL: http://llvm.org/viewvc/llvm-project/test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel10.c?rev=168264&view=auto
>> ==============================================================================
>> --- test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel10.c (added)
>> +++ test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel10.c Sat Nov 17 12:52:20 2012
>> @@ -0,0 +1,54 @@
>> +/***********************************************************************
>> + * gcc kernel10.c -m64 -lrt -lc -lm
>> + * L. L. N. L. " C " K E R N E L S: M F L O P S P C V E R S I O N
>> + */
>> +
>> +#include "lloops.h"
>> +
>> +/********************************************************************
>> +* Kernel 10 -- difference predictors *
>> +********************************************************************/
>> +double kernel10()
>> +{
>> + long i;
>> + double ar, br, cr;
>> + unsigned iter = 0;
>> + double heuristics=0.0;
>> +
>> + parameters (10);
>> + do
>> + {
>> + for ( i=0 ; i<n ; i++ )
>> + {
>> + ar = cx[i][ 4];
>> + br = ar - px[i][ 4];
>> + px[i][ 4] = ar;
>> + cr = br - px[i][ 5];
>> + px[i][ 5] = br;
>> + ar = cr - px[i][ 6];
>> + px[i][ 6] = cr;
>> + br = ar - px[i][ 7];
>> + px[i][ 7] = ar;
>> + cr = br - px[i][ 8];
>> + px[i][ 8] = br;
>> + ar = cr - px[i][ 9];
>> + px[i][ 9] = cr;
>> + br = ar - px[i][10];
>> + px[i][10] = ar;
>> + cr = br - px[i][11];
>> + px[i][11] = br;
>> + px[i][13] = cr - px[i][12];
>> + px[i][12] = cr;
>> + }
>> + heuristics += px[i][11]+px[i][12];
>> + }
>> + while (iter++ < ITERATIONS);
>> +
>> + return heuristics;
>> +}
>> +
>> +int main(int argc, char *argv[])
>> +{
>> + printf("%f\n", kernel10());
>> + return 0;
>> +}
>>
>> Added: test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel10.reference_output
>> URL: http://llvm.org/viewvc/llvm-project/test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel10.reference_output?rev=168264&view=auto
>> ==============================================================================
>> --- test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel10.reference_output (added)
>> +++ test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel10.reference_output Sat Nov 17 12:52:20 2012
>> @@ -0,0 +1,2 @@
>> +-24.687150
>> +exit 0
>>
>> Added: test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel11.c
>> URL: http://llvm.org/viewvc/llvm-project/test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel11.c?rev=168264&view=auto
>> ==============================================================================
>> --- test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel11.c (added)
>> +++ test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel11.c Sat Nov 17 12:52:20 2012
>> @@ -0,0 +1,38 @@
>> +/***********************************************************************
>> + * gcc kernel11.c -m64 -lrt -lc -lm
>> + * L. L. N. L. " C " K E R N E L S: M F L O P S P C V E R S I O N
>> + */
>> +
>> +#include "lloops.h"
>> +
>> +/********************************************************************
>> +* Kernel 11 -- first sum *
>> +********************************************************************/
>> +double kernel11()
>> +{
>> + long k;
>> + unsigned iter = 0;
>> + double heuristics=0.0;
>> +
>> + parameters (11);
>> + do
>> + {
>> + x[0] = y[0];
>> + for ( k=1 ; k<n ; k++ )
>> + {
>> + x[k] = x[k-1] + y[k];
>> + }
>> + }
>> + while (iter++ < ITERATIONS);
>> +
>> + for ( k=0; k<n; k++ )
>> + heuristics += x[k];
>> +
>> + return heuristics;
>> +}
>> +
>> +int main(int argc, char *argv[])
>> +{
>> + printf("%f\n", kernel11());
>> + return 0;
>> +}
>>
>> Added: test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel11.reference_output
>> URL: http://llvm.org/viewvc/llvm-project/test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel11.reference_output?rev=168264&view=auto
>> ==============================================================================
>> --- test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel11.reference_output (added)
>> +++ test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel11.reference_output Sat Nov 17 12:52:20 2012
>> @@ -0,0 +1,2 @@
>> +351535.161787
>> +exit 0
>>
>> Added: test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel12.c
>> URL: http://llvm.org/viewvc/llvm-project/test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel12.c?rev=168264&view=auto
>> ==============================================================================
>> --- test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel12.c (added)
>> +++ test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel12.c Sat Nov 17 12:52:20 2012
>> @@ -0,0 +1,37 @@
>> +/***********************************************************************
>> + * gcc kernel12.c -m64 -lrt -lc -lm
>> + * L. L. N. L. " C " K E R N E L S: M F L O P S P C V E R S I O N
>> + */
>> +
>> +#include "lloops.h"
>> +
>> +/********************************************************************
>> +* Kernel 12 -- first difference *
>> +********************************************************************/
>> +double kernel12()
>> +{
>> + long k;
>> + unsigned iter = 0;
>> + double heuristics=0.0;
>> +
>> + parameters (12);
>> + do
>> + {
>> + for ( k=0 ; k<n ; k++ )
>> + {
>> + x[k] = y[k+1] - y[k];
>> + }
>> + }
>> + while (iter++ < ITERATIONS);
>> +
>> + for ( k=0; k<n; k++ )
>> + heuristics += x[k];
>> +
>> + return heuristics;
>> +}
>> +
>> +int main(int argc, char *argv[])
>> +{
>> + printf("%f\n", kernel12());
>> + return 0;
>> +}
>>
>> Added: test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel12.reference_output
>> URL: http://llvm.org/viewvc/llvm-project/test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel12.reference_output?rev=168264&view=auto
>> ==============================================================================
>> --- test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel12.reference_output (added)
>> +++ test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel12.reference_output Sat Nov 17 12:52:20 2012
>> @@ -0,0 +1,2 @@
>> +0.004074
>> +exit 0
>>
>> Added: test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel13.c
>> URL: http://llvm.org/viewvc/llvm-project/test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel13.c?rev=168264&view=auto
>> ==============================================================================
>> --- test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel13.c (added)
>> +++ test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel13.c Sat Nov 17 12:52:20 2012
>> @@ -0,0 +1,53 @@
>> +/***********************************************************************
>> + * gcc kernel13.c -m64 -lrt -lc -lm
>> + * L. L. N. L. " C " K E R N E L S: M F L O P S P C V E R S I O N
>> + */
>> +
>> +#include "lloops.h"
>> +
>> +/********************************************************************
>> +* Kernel 13 -- 2-D PIC (Particle In Cell) *
>> +********************************************************************/
>> +double kernel13()
>> +{
>> + long ip, i1, i2, j1, j2;
>> + unsigned iter = 0;
>> + double heuristics=0.0;
>> +
>> + parameters (13);
>> + do
>> + {
>> + for ( ip=0; ip<n; ip++)
>> + {
>> + i1 = (long)p[ip][0];
>> + j1 = (long)p[ip][1];
>> + i1 &= 64-1;
>> + j1 &= 64-1;
>> + p[ip][2] += b[j1][i1];
>> + p[ip][3] += c[j1][i1];
>> + p[ip][0] += p[ip][2];
>> + p[ip][1] += p[ip][3];
>> + i2 = (long)p[ip][0];
>> + j2 = (long)p[ip][1];
>> + i2 = ( i2 & (64-1) ) - 1 ;
>> + j2 = ( j2 & (64-1) ) - 1 ;
>> + p[ip][0] += y[i2+32];
>> + p[ip][1] += z[j2+32];
>> + i2 += e[i2+32];
>> + j2 += f[j2+32];
>> + h[j2][i2] += 1.0;
>> + }
>> + }
>> + while (iter++ < ITERATIONS);
>> +
>> + for ( ip=0; ip<n; ip++ )
>> + heuristics += p[ip][0]+p[ip][1]+p[ip][2]+p[ip][3];
>> +
>> + return heuristics;
>> +}
>> +
>> +int main(int argc, char *argv[])
>> +{
>> + printf("%f\n", kernel13());
>> + return 0;
>> +}
>>
>> Added: test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel13.reference_output
>> URL: http://llvm.org/viewvc/llvm-project/test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel13.reference_output?rev=168264&view=auto
>> ==============================================================================
>> --- test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel13.reference_output (added)
>> +++ test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel13.reference_output Sat Nov 17 12:52:20 2012
>> @@ -0,0 +1,2 @@
>> +8332792153.297057
>> +exit 0
>>
>> Added: test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel14.c
>> URL: http://llvm.org/viewvc/llvm-project/test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel14.c?rev=168264&view=auto
>> ==============================================================================
>> --- test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel14.c (added)
>> +++ test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel14.c Sat Nov 17 12:52:20 2012
>> @@ -0,0 +1,56 @@
>> +/***********************************************************************
>> + * gcc kernel14.c -m64 -lrt -lc -lm
>> + * L. L. N. L. " C " K E R N E L S: M F L O P S P C V E R S I O N
>> + */
>> +
>> +#include "lloops.h"
>> +
>> +/********************************************************************
>> +* Kernel 14 -- 1-D PIC (Particle In Cell) *
>> +********************************************************************/
>> +double kernel14()
>> +{
>> + long k;
>> + unsigned iter = 0;
>> + double heuristics=0.0;
>> +
>> + parameters (14);
>> + do
>> + {
>> + for ( k=0 ; k<n ; k++ )
>> + {
>> + vx[k] = 0.0;
>> + xx[k] = 0.0;
>> + ix[k] = (long) grd[k];
>> + xi[k] = (double) ix[k];
>> + ex1[k] = ex[ ix[k] - 1 ];
>> + dex1[k] = dex[ ix[k] - 1 ];
>> + }
>> + for ( k=0 ; k<n ; k++ )
>> + {
>> + vx[k] = vx[k] + ex1[k] + ( xx[k] - xi[k] )*dex1[k];
>> + xx[k] = xx[k] + vx[k] + flx;
>> + ir[k] = (long)xx[k];
>> + rx[k] = xx[k] - ir[k];
>> + ir[k] = ( ir[k] & (2048-1) ) + 1;
>> + xx[k] = rx[k] + ir[k];
>> + }
>> + for ( k=0 ; k<n ; k++ )
>> + {
>> + rh[ ir[k]-1 ] += 1.0 - rx[k];
>> + rh[ ir[k] ] += rx[k];
>> + }
>> + }
>> + while (iter++ < ITERATIONS);
>> +
>> + for ( k=0; k<n; k++ )
>> + heuristics += xx[k]+rh[ir[k]];
>> +
>> + return heuristics;
>> +}
>> +
>> +int main(int argc, char *argv[])
>> +{
>> + printf("%f\n", kernel14());
>> + return 0;
>> +}
>>
>> Added: test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel14.reference_output
>> URL: http://llvm.org/viewvc/llvm-project/test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel14.reference_output?rev=168264&view=auto
>> ==============================================================================
>> --- test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel14.reference_output (added)
>> +++ test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel14.reference_output Sat Nov 17 12:52:20 2012
>> @@ -0,0 +1,2 @@
>> +105154353.678321
>> +exit 0
>>
>> Added: test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel15.c
>> URL: http://llvm.org/viewvc/llvm-project/test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel15.c?rev=168264&view=auto
>> ==============================================================================
>> --- test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel15.c (added)
>> +++ test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel15.c Sat Nov 17 12:52:20 2012
>> @@ -0,0 +1,100 @@
>> +/***********************************************************************
>> + * gcc kernel15.c -m64 -lrt -lc -lm
>> + * L. L. N. L. " C " K E R N E L S: M F L O P S P C V E R S I O N
>> + */
>> +
>> +#include "lloops.h"
>> +
>> +/********************************************************************
>> +* Kernel 15 -- Casual Fortran. Development version *
>> +********************************************************************/
>> +double kernel15()
>> +{
>> + double ar, br;
>> + long j, k;
>> + long ng, nz;
>> + unsigned iter = 0;
>> + double heuristics=0.0;
>> +
>> + parameters (15);
>> + do
>> + {
>> + ng = 7;
>> + nz = n;
>> + ar = 0.053;
>> + br = 0.073;
>> + for ( j=1 ; j<ng ; j++ )
>> + {
>> + for ( k=1 ; k<nz ; k++ )
>> + {
>> + if ( (j+1) >= ng )
>> + {
>> + vy[j][k] = 0.0;
>> + continue;
>> + }
>> + if ( vh[j+1][k] > vh[j][k] )
>> + {
>> + t = ar;
>> + }
>> + else
>> + {
>> + t = br;
>> + }
>> + if ( vf[j][k] < vf[j][k-1] )
>> + {
>> + if ( vh[j][k-1] > vh[j+1][k-1] )
>> + r = vh[j][k-1];
>> + else
>> + r = vh[j+1][k-1];
>> + s = vf[j][k-1];
>> + }
>> + else
>> + {
>> + if ( vh[j][k] > vh[j+1][k] )
>> + r = vh[j][k];
>> + else
>> + r = vh[j+1][k];
>> + s = vf[j][k];
>> + }
>> + vy[j][k] = sqrt( vg[j][k]*vg[j][k] + r*r )* t/s;
>> + if ( (k+1) >= nz )
>> + {
>> + vs[j][k] = 0.0;
>> + continue;
>> + }
>> + if ( vf[j][k] < vf[j-1][k] )
>> + {
>> + if ( vg[j-1][k] > vg[j-1][k+1] )
>> + r = vg[j-1][k];
>> + else
>> + r = vg[j-1][k+1];
>> + s = vf[j-1][k];
>> + t = br;
>> + }
>> + else
>> + {
>> + if ( vg[j][k] > vg[j][k+1] )
>> + r = vg[j][k];
>> + else
>> + r = vg[j][k+1];
>> + s = vf[j][k];
>> + t = ar;
>> + }
>> + vs[j][k] = sqrt( vh[j][k]*vh[j][k] + r*r )* t / s;
>> + }
>> + }
>> + }
>> + while (iter++ < ITERATIONS);
>> +
>> + for ( j=0; j<ng; j++ )
>> + for ( k=0; k<nz; k++ )
>> + heuristics += vs[j][k];;
>> +
>> + return heuristics;
>> +}
>> +
>> +int main(int argc, char *argv[])
>> +{
>> + printf("%f\n", kernel15());
>> + return 0;
>> +}
>>
>> Added: test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel15.reference_output
>> URL: http://llvm.org/viewvc/llvm-project/test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel15.reference_output?rev=168264&view=auto
>> ==============================================================================
>> --- test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel15.reference_output (added)
>> +++ test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel15.reference_output Sat Nov 17 12:52:20 2012
>> @@ -0,0 +1,2 @@
>> +-37.410287
>> +exit 0
>>
>> Added: test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel16.c
>> URL: http://llvm.org/viewvc/llvm-project/test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel16.c?rev=168264&view=auto
>> ==============================================================================
>> --- test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel16.c (added)
>> +++ test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel16.c Sat Nov 17 12:52:20 2012
>> @@ -0,0 +1,97 @@
>> +/***********************************************************************
>> + * gcc kernel16.c -m64 -lrt -lc -lm
>> + * L. L. N. L. " C " K E R N E L S: M F L O P S P C V E R S I O N
>> + */
>> +
>> +#include "lloops.h"
>> +
>> +/********************************************************************
>> +* Kernel 16 -- Monte Carlo search loop *
>> +********************************************************************/
>> +double kernel16()
>> +{
>> + long ii;
>> + long k;
>> + long i1, j2, j4, lb;
>> + double tmp;
>> + double heuristics=0.0;
>> + unsigned iter = 0;
>> +
>> + parameters (16);
>> +
>> + ii = n / 3;
>> + lb = ii + ii;
>> + k3 = k2 = 0;
>> + do
>> + {
>> + i1 = m16 = 1;
>> + label410:
>> + j2 = ( n + n )*( m16 - 1 ) + 1;
>> + for ( k=1 ; k<=n ; k++ )
>> + {
>> + k2++;
>> + j4 = j2 + k + k;
>> + j5 = zone[j4-1];
>> + if ( j5 < n )
>> + {
>> + if ( j5+lb < n )
>> + { /* 420 */
>> + tmp = plan[j5-1] - t; /* 435 */
>> + }
>> + else
>> + {
>> + if ( j5+ii < n )
>> + { /* 415 */
>> + tmp = plan[j5-1] - s; /* 430 */
>> + }
>> + else
>> + {
>> + tmp = plan[j5-1] - r; /* 425 */
>> + }
>> + }
>> + }
>> + else if( j5 == n )
>> + {
>> + break; /* 475 */
>> + }
>> + else
>> + {
>> + k3++; /* 450 */
>> + tmp=(d[j5-1]-(d[j5-2]*(t-d[j5-3])*(t-d[j5-3])+(s-d[j5-4])*
>> + (s-d[j5-4])+(r-d[j5-5])*(r-d[j5-5])));
>> + }
>> + if ( tmp < 0.0 )
>> + {
>> + if ( zone[j4-2] < 0 ) /* 445 */
>> + continue; /* 470 */
>> + else if ( !zone[j4-2] )
>> + break; /* 480 */
>> + }
>> + else if ( tmp )
>> + {
>> + if ( zone[j4-2] > 0 ) /* 440 */
>> + continue; /* 470 */
>> + else if ( !zone[j4-2] )
>> + break; /* 480 */
>> + }
>> + else break; /* 485 */
>> + m16++; /* 455 */
>> + if ( m16 > zone[0] )
>> + m16 = 1; /* 460 */
>> + if ( i1-m16 ) /* 465 */
>> + goto label410;
>> + else
>> + break;
>> + }
>> + heuristics += tmp;
>> + }
>> + while (iter++ < ITERATIONS);
>> +
>> + return heuristics;
>> +}
>> +
>> +int main(int argc, char *argv[])
>> +{
>> + printf("%f\n", kernel16());
>> + return 0;
>> +}
>>
>> Added: test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel16.reference_output
>> URL: http://llvm.org/viewvc/llvm-project/test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel16.reference_output?rev=168264&view=auto
>> ==============================================================================
>> --- test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel16.reference_output (added)
>> +++ test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel16.reference_output Sat Nov 17 12:52:20 2012
>> @@ -0,0 +1,2 @@
>> +103398.570444
>> +exit 0
>>
>> Added: test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel17.c
>> URL: http://llvm.org/viewvc/llvm-project/test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel17.c?rev=168264&view=auto
>> ==============================================================================
>> --- test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel17.c (added)
>> +++ test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel17.c Sat Nov 17 12:52:20 2012
>> @@ -0,0 +1,59 @@
>> +/***********************************************************************
>> + * gcc kernel17.c -m64 -lrt -lc -lm
>> + * L. L. N. L. " C " K E R N E L S: M F L O P S P C V E R S I O N
>> + */
>> +
>> +#include "lloops.h"
>> +
>> +/********************************************************************
>> +* Kernel 17 -- implicit, conditional computation *
>> +********************************************************************/
>> +double kernel17()
>> +{
>> + long i, j;
>> + double scale, xnei, xnc, e3,e6;
>> + long ink;
>> + unsigned iter = 0;
>> + double heuristics=0.0;
>> +
>> + parameters (17);
>> + do
>> + {
>> + i = n-1;
>> + j = 0;
>> + ink = -1;
>> + scale = 5.0 / 3.0;
>> + xnm = 1.0 / 3.0;
>> + e6 = 1.03 / 3.07;
>> + goto l61;
>> + l60: e6 = xnm*vsp[i] + vstp[i];
>> + vxne[i] = e6;
>> + xnm = e6;
>> + ve3[i] = e6;
>> + i += ink;
>> + if ( i==j ) goto end;
>> + l61: e3 = xnm*vlr[i] + vlin[i];
>> + xnei = vxne[i];
>> + vxnd[i] = e6;
>> + xnc = scale*e3;
>> + if ( xnm > xnc ) goto l60;
>> + if ( xnei > xnc ) goto l60;
>> + ve3[i] = e3;
>> + e6 = e3 + e3 - xnm;
>> + vxne[i] = e3 + e3 - xnei;
>> + xnm = e6;
>> + i += ink;
>> + if ( i != j ) goto l61;
>> + end:
>> + heuristics += xnm + xnc + xnei;
>> + }
>> + while (iter++ < ITERATIONS);
>> +
>> + return heuristics;
>> +}
>> +
>> +int main(int argc, char *argv[])
>> +{
>> + printf("%f\n", kernel17());
>> + return 0;
>> +}
>>
>> Added: test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel17.reference_output
>> URL: http://llvm.org/viewvc/llvm-project/test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel17.reference_output?rev=168264&view=auto
>> ==============================================================================
>> --- test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel17.reference_output (added)
>> +++ test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel17.reference_output Sat Nov 17 12:52:20 2012
>> @@ -0,0 +1,2 @@
>> +40734.646337
>> +exit 0
>>
>> Added: test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel18.c
>> URL: http://llvm.org/viewvc/llvm-project/test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel18.c?rev=168264&view=auto
>> ==============================================================================
>> --- test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel18.c (added)
>> +++ test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel18.c Sat Nov 17 12:52:20 2012
>> @@ -0,0 +1,74 @@
>> +/***********************************************************************
>> + * gcc kernel18.c -m64 -lrt -lc -lm
>> + * L. L. N. L. " C " K E R N E L S: M F L O P S P C V E R S I O N
>> + */
>> +
>> +#include "lloops.h"
>> +
>> +/********************************************************************
>> +* Kernel 18 - 2-D explicit hydrodynamics fragment *
>> +********************************************************************/
>> +double kernel18()
>> +{
>> + long j, k;
>> + long jn, kn;
>> + double heuristics=0.0;
>> + unsigned iter = 0;
>> +
>> + parameters (18);
>> + do
>> + {
>> + t = 0.0037;
>> + s = 0.0041;
>> + kn = 6;
>> + jn = n;
>> + for ( k=1 ; k<kn ; k++ )
>> + {
>> +
>> + for ( j=1 ; j<jn ; j++ )
>> + {
>> + za[k][j] = ( zp[k+1][j-1] +zq[k+1][j-1] -zp[k][j-1] -zq[k][j-1] )*
>> + ( zr[k][j] +zr[k][j-1] ) / ( zm[k][j-1] +zm[k+1][j-1]);
>> + zb[k][j] = ( zp[k][j-1] +zq[k][j-1] -zp[k][j] -zq[k][j] ) *
>> + ( zr[k][j] +zr[k-1][j] ) / ( zm[k][j] +zm[k][j-1]);
>> + }
>> + }
>> + for ( k=1 ; k<kn ; k++ )
>> + {
>> +
>> + for ( j=1 ; j<jn ; j++ )
>> + {
>> + zu[k][j] += s*( za[k][j] *( zz[k][j] - zz[k][j+1] ) -
>> + za[k][j-1] *( zz[k][j] - zz[k][j-1] ) -
>> + zb[k][j] *( zz[k][j] - zz[k-1][j] ) +
>> + zb[k+1][j] *( zz[k][j] - zz[k+1][j] ) );
>> + zv[k][j] += s*( za[k][j] *( zr[k][j] - zr[k][j+1] ) -
>> + za[k][j-1] *( zr[k][j] - zr[k][j-1] ) -
>> + zb[k][j] *( zr[k][j] - zr[k-1][j] ) +
>> + zb[k+1][j] *( zr[k][j] - zr[k+1][j] ) );
>> + }
>> + }
>> + for ( k=1 ; k<kn ; k++ )
>> + {
>> +
>> + for ( j=1 ; j<jn ; j++ )
>> + {
>> + zr[k][j] = zr[k][j] + t*zu[k][j];
>> + zz[k][j] = zz[k][j] + t*zv[k][j];
>> + }
>> + }
>> + }
>> + while (iter++ < ITERATIONS);
>> +
>> + for ( k=0; k<6; k++ )
>> + for ( j=0; j<jn; j++ )
>> + heuristics += (zu[k][j]*zv[k][j])+(zr[k][j]*zz[k][j]);
>> +
>> + return heuristics;
>> +}
>> +
>> +int main(int argc, char *argv[])
>> +{
>> + printf("%f\n", kernel18());
>> + return 0;
>> +}
>>
>> Added: test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel18.reference_output
>> URL: http://llvm.org/viewvc/llvm-project/test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel18.reference_output?rev=168264&view=auto
>> ==============================================================================
>> --- test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel18.reference_output (added)
>> +++ test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel18.reference_output Sat Nov 17 12:52:20 2012
>> @@ -0,0 +1,2 @@
>> +1.472564
>> +exit 0
>>
>> Added: test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel19.c
>> URL: http://llvm.org/viewvc/llvm-project/test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel19.c?rev=168264&view=auto
>> ==============================================================================
>> --- test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel19.c (added)
>> +++ test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel19.c Sat Nov 17 12:52:20 2012
>> @@ -0,0 +1,46 @@
>> +/***********************************************************************
>> + * gcc kernel19.c -m64 -lrt -lc -lm
>> + * L. L. N. L. " C " K E R N E L S: M F L O P S P C V E R S I O N
>> + */
>> +
>> +#include "lloops.h"
>> +
>> +/********************************************************************
>> +* Kernel 19 -- general linear recurrence equations *
>> +********************************************************************/
>> +double kernel19()
>> +{
>> + long i, k;
>> + long kb5i;
>> + double heuristics=0.0;
>> + unsigned iter = 0;
>> +
>> + parameters (19);
>> + kb5i = 0;
>> + do
>> + {
>> + for ( k=0 ; k<n ; k++ )
>> + {
>> + b5[k+kb5i] = sa[k] + stb5*sb[k];
>> + stb5 = b5[k+kb5i] - stb5;
>> + }
>> + for ( i=1 ; i<=n ; i++ )
>> + {
>> + k = n - i;
>> + b5[k+kb5i] = sa[k] + stb5*sb[k];
>> + stb5 = b5[k+kb5i] - stb5;
>> + }
>> + }
>> + while (iter++ < ITERATIONS);
>> +
>> + for ( k=0; k<n; k++ )
>> + heuristics += b5[k];
>> +
>> + return heuristics;
>> +}
>> +
>> +int main(int argc, char *argv[])
>> +{
>> + printf("%f\n", kernel19());
>> + return 0;
>> +}
>>
>> Added: test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel19.reference_output
>> URL: http://llvm.org/viewvc/llvm-project/test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel19.reference_output?rev=168264&view=auto
>> ==============================================================================
>> --- test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel19.reference_output (added)
>> +++ test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel19.reference_output Sat Nov 17 12:52:20 2012
>> @@ -0,0 +1,2 @@
>> +10.629982
>> +exit 0
>>
>> Added: test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel20.c
>> URL: http://llvm.org/viewvc/llvm-project/test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel20.c?rev=168264&view=auto
>> ==============================================================================
>> --- test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel20.c (added)
>> +++ test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel20.c Sat Nov 17 12:52:20 2012
>> @@ -0,0 +1,48 @@
>> +/***********************************************************************
>> + * gcc kernel20.c -m64 -lrt -lc -lm
>> + * L. L. N. L. " C " K E R N E L S: M F L O P S P C V E R S I O N
>> + */
>> +
>> +#include "lloops.h"
>> +
>> +/*************************************************************************
>> +* Kernel 20 - Discrete ordinates transport, conditional recurrence on xx *
>> +*************************************************************************/
>> +double kernel20()
>> +{
>> + long k;
>> + double di, dn;
>> + double heuristics=0.0;
>> + unsigned iter = 0;
>> +
>> + parameters (20);
>> + do
>> + {
>> + for ( k=0 ; k<n ; k++ )
>> + {
>> + di = y[k] - g[k] / ( xx[k] + dk );
>> + dn = 0.2;
>> +
>> + if ( di )
>> + {
>> + dn = z[k]/di ;
>> + if ( t < dn ) dn = t;
>> + if ( s > dn ) dn = s;
>> + }
>> + x[k] = ( ( w[k] + v[k]*dn )* xx[k] + u[k] ) / ( vx[k] + v[k]*dn );
>> + xx[k+1] = ( x[k] - xx[k] )* dn + xx[k];
>> + }
>> + }
>> + while (iter++ < ITERATIONS);
>> +
>> + for ( k=0; k<n; k++ )
>> + heuristics += x[k] + xx[k];
>> +
>> + return heuristics;
>> +}
>> +
>> +int main(int argc, char *argv[])
>> +{
>> + printf("%f\n", kernel20());
>> + return 0;
>> +}
>>
>> Added: test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel20.reference_output
>> URL: http://llvm.org/viewvc/llvm-project/test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel20.reference_output?rev=168264&view=auto
>> ==============================================================================
>> --- test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel20.reference_output (added)
>> +++ test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel20.reference_output Sat Nov 17 12:52:20 2012
>> @@ -0,0 +1,2 @@
>> +91947.677434
>> +exit 0
>>
>> Added: test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel21.c
>> URL: http://llvm.org/viewvc/llvm-project/test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel21.c?rev=168264&view=auto
>> ==============================================================================
>> --- test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel21.c (added)
>> +++ test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel21.c Sat Nov 17 12:52:20 2012
>> @@ -0,0 +1,45 @@
>> +/***********************************************************************
>> + * gcc kernel21.c -m64 -lrt -lc -lm
>> + * L. L. N. L. " C " K E R N E L S: M F L O P S P C V E R S I O N
>> + */
>> +
>> +#include "lloops.h"
>> +
>> +/********************************************************************
>> +* Kernel 21 -- matrix*matrix product *
>> +********************************************************************/
>> +double kernel21()
>> +{
>> + long i, j, k;
>> + double heuristics=0.0;
>> + unsigned iter = 0;
>> +
>> + parameters (21);
>> + do
>> + {
>> + for ( k=0 ; k<25 ; k++ )
>> + {
>> + for ( i=0 ; i<25 ; i++ )
>> + {
>> + for ( j=0 ; j<n ; j++ )
>> + {
>> + px[j][i] += vy[k][i] * cx[j][k];
>> + }
>> + }
>> + }
>> + }
>> + while (iter++ < ITERATIONS/10); /* this one takes a while! */
>> +
>> + /* Inverse order iteration on purpose */
>> + for ( j=0; j<n; j++ )
>> + for ( k=0; k<25; k++ )
>> + heuristics += px[j][k];
>> +
>> + return heuristics;
>> +}
>> +
>> +int main(int argc, char *argv[])
>> +{
>> + printf("%f\n", kernel21());
>> + return 0;
>> +}
>>
>> Added: test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel21.reference_output
>> URL: http://llvm.org/viewvc/llvm-project/test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel21.reference_output?rev=168264&view=auto
>> ==============================================================================
>> --- test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel21.reference_output (added)
>> +++ test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel21.reference_output Sat Nov 17 12:52:20 2012
>> @@ -0,0 +1,2 @@
>> +9.307049
>> +exit 0
>>
>> Added: test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel22.c
>> URL: http://llvm.org/viewvc/llvm-project/test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel22.c?rev=168264&view=auto
>> ==============================================================================
>> --- test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel22.c (added)
>> +++ test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel22.c Sat Nov 17 12:52:20 2012
>> @@ -0,0 +1,42 @@
>> +/***********************************************************************
>> + * gcc kernel22.c -m64 -lrt -lc -lm
>> + * L. L. N. L. " C " K E R N E L S: M F L O P S P C V E R S I O N
>> + */
>> +
>> +#include "lloops.h"
>> +
>> +/********************************************************************
>> +* Kernel 22 -- Planckian distribution *
>> +********************************************************************/
>> +double kernel22()
>> +{
>> + long k;
>> + double heuristics=0.0;
>> + unsigned iter = 0;
>> +
>> + parameters (22);
>> + start_time();
>> +
>> + expmax = 20.0;
>> + u[n-1] = 0.99*expmax*v[n-1];
>> + do
>> + {
>> + for ( k=0 ; k<n ; k++ )
>> + {
>> + y[k] = u[k] / v[k];
>> + w[k] = x[k] / ( exp( y[k] ) -1.0 );
>> + }
>> + }
>> + while (iter++ < ITERATIONS);
>> +
>> + for ( k=0; k<n; k++ )
>> + heuristics += w[k];
>> +
>> + return heuristics;
>> +}
>> +
>> +int main(int argc, char *argv[])
>> +{
>> + printf("%f\n", kernel22());
>> + return 0;
>> +}
>>
>> Added: test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel22.reference_output
>> URL: http://llvm.org/viewvc/llvm-project/test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel22.reference_output?rev=168264&view=auto
>> ==============================================================================
>> --- test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel22.reference_output (added)
>> +++ test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel22.reference_output Sat Nov 17 12:52:20 2012
>> @@ -0,0 +1,2 @@
>> +5.819019
>> +exit 0
>>
>> Added: test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel23.c
>> URL: http://llvm.org/viewvc/llvm-project/test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel23.c?rev=168264&view=auto
>> ==============================================================================
>> --- test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel23.c (added)
>> +++ test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel23.c Sat Nov 17 12:52:20 2012
>> @@ -0,0 +1,44 @@
>> +/***********************************************************************
>> + * gcc kernel23.c -m64 -lrt -lc -lm
>> + * L. L. N. L. " C " K E R N E L S: M F L O P S P C V E R S I O N
>> + */
>> +
>> +#include "lloops.h"
>> +
>> +/********************************************************************
>> +* Kernel 23 -- 2-D implicit hydrodynamics fragment *
>> +********************************************************************/
>> +double kernel23()
>> +{
>> + long j, k;
>> + double qa;
>> + double heuristics=0.0;
>> + unsigned iter = 0;
>> +
>> + parameters (23);
>> + do
>> + {
>> + for ( j=1 ; j<6 ; j++ )
>> + {
>> + for ( k=1 ; k<n ; k++ )
>> + {
>> + qa = za[j+1][k]*zr[j][k] + za[j-1][k]*zb[j][k] +
>> + za[j][k+1]*zu[j][k] + za[j][k-1]*zv[j][k] + zz[j][k];
>> + za[j][k] += 0.175*( qa - za[j][k] );
>> + }
>> + }
>> + }
>> + while (iter++ < ITERATIONS);
>> +
>> + for ( j=0; j<6; j++ )
>> + for ( k=0; k<n; k++ )
>> + heuristics += za[j][k];
>> +
>> + return heuristics;
>> +}
>> +
>> +int main(int argc, char *argv[])
>> +{
>> + printf("%f\n", kernel23());
>> + return 0;
>> +}
>>
>> Added: test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel23.reference_output
>> URL: http://llvm.org/viewvc/llvm-project/test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel23.reference_output?rev=168264&view=auto
>> ==============================================================================
>> --- test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel23.reference_output (added)
>> +++ test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel23.reference_output Sat Nov 17 12:52:20 2012
>> @@ -0,0 +1,2 @@
>> +-0.074030
>> +exit 0
>>
>> Added: test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel24.c
>> URL: http://llvm.org/viewvc/llvm-project/test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel24.c?rev=168264&view=auto
>> ==============================================================================
>> --- test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel24.c (added)
>> +++ test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel24.c Sat Nov 17 12:52:20 2012
>> @@ -0,0 +1,37 @@
>> +/***********************************************************************
>> + * gcc kernel24.c -m64 -lrt -lc -lm
>> + * L. L. N. L. " C " K E R N E L S: M F L O P S P C V E R S I O N
>> + */
>> +
>> +#include "lloops.h"
>> +
>> +/********************************************************************
>> +* Kernel 24 -- find location of first minimum in array *
>> +********************************************************************/
>> +double kernel24()
>> +{
>> + long k;
>> + unsigned iter = 0;
>> + double heuristics=0.0;
>> +
>> + parameters (24);
>> + x[n/2] = -1.0e+10;
>> + do
>> + {
>> + m24 = 0;
>> + for ( k=1 ; k<n ; k++ )
>> + {
>> + if ( x[k] < x[m24] ) m24 = k;
>> + }
>> + heuristics += m24;
>> + }
>> + while (iter++ < ITERATIONS);
>> +
>> + return heuristics;
>> +}
>> +
>> +int main(int argc, char *argv[])
>> +{
>> + printf("%f\n", kernel24());
>> + return 0;
>> +}
>>
>> Added: test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel24.reference_output
>> URL: http://llvm.org/viewvc/llvm-project/test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel24.reference_output?rev=168264&view=auto
>> ==============================================================================
>> --- test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel24.reference_output (added)
>> +++ test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/kernel24.reference_output Sat Nov 17 12:52:20 2012
>> @@ -0,0 +1,2 @@
>> +50000500.000000
>> +exit 0
>>
>> Added: test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/lloops.h
>> URL: http://llvm.org/viewvc/llvm-project/test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/lloops.h?rev=168264&view=auto
>> ==============================================================================
>> --- test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/lloops.h (added)
>> +++ test-suite/trunk/SingleSource/Benchmarks/LivermoreLoops/lloops.h Sat Nov 17 12:52:20 2012
>> @@ -0,0 +1,583 @@
>> +/**********************************************************************
>> + * L. L. N. L. " C " K E R N E L S: M F L O P S P C V E R S I O N
>> + *
>> + * This is the header file that contains common code and the global
>> + * variables in which the kernels operate into. These globals also work
>> + * as a way to verify that the compiler can vectorize if the variables
>> + * belong to global structures, so moving them to inside the kernel would
>> + * invalidate that test.
>> + *
>> + * See each kernel (kernelNN.c) for more information on each test.
>> + *
>> + * This code have been tested on Linux/AMD_64 and is not guarantee to
>> + * work on any other combination. If you know it does, please update
>> + * this part of the comment.
>> + */
>> +
>> +#include <stdio.h>
>> +#include <math.h>
>> +
>> +/* Timer */
>> +#include <time.h>
>> +struct timespec tp1;
>> +unsigned int millisecs = 0;
>> +double theseSecs = 0.0;
>> +double startSecs = 0.0;
>> +double secs;
>> +
>> +void getSecs()
>> +{
>> + clock_gettime(CLOCK_REALTIME, &tp1);
>> + theseSecs = tp1.tv_sec + tp1.tv_nsec / 1e9;
>> +}
>> +
>> +void start_time()
>> +{
>> + getSecs();
>> + startSecs = theseSecs;
>> +}
>> +
>> +void end_time()
>> +{
>> + getSecs();
>> + secs = theseSecs - startSecs;
>> + millisecs = (int)(1000.0 * secs);
>> +}
>> +
>> +/* Test Variables */
>> +struct Arrays
>> +{
>> + double U[1001];
>> + double V[1001];
>> + double W[1001];
>> + double X[1001];
>> + double Y[1001];
>> + double Z[1001];
>> + double G[1001];
>> + double Du1[101];
>> + double Du2[101];
>> + double Du3[101];
>> + double Grd[1001];
>> + double Dex[1001];
>> + double Xi[1001];
>> + double Ex[1001];
>> + double Ex1[1001];
>> + double Dex1[1001];
>> + double Vx[1001];
>> + double Xx[1001];
>> + double Rx[1001];
>> + double Rh[2048];
>> + double Vsp[101];
>> + double Vstp[101];
>> + double Vxne[101];
>> + double Vxnd[101];
>> + double Ve3[101];
>> + double Vlr[101];
>> + double Vlin[101];
>> + double B5[101];
>> + double Plan[300];
>> + double D[300];
>> + double Sa[101];
>> + double Sb[101];
>> + double P[512][4];
>> + double Px[101][25];
>> + double Cx[101][25];
>> + double Vy[25][101];
>> + double Vh[7][101];
>> + double Vf[7][101];
>> + double Vg[7][101];
>> + double Vs[7][101];
>> + double Za[7][101];
>> + double Zp[7][101];
>> + double Zq[7][101];
>> + double Zr[7][101];
>> + double Zm[7][101];
>> + double Zb[7][101];
>> + double Zu[7][101];
>> + double Zv[7][101];
>> + double Zz[7][101];
>> + double B[64][64];
>> + double C[64][64];
>> + double H[64][64];
>> + double U1[2][101][5];
>> + double U2[2][101][5];
>> + double U3[2][101][5];
>> + double Xtra[40];
>> + long E[96];
>> + long F[96];
>> + long Ix[1001];
>> + long Ir[1001];
>> + long Zone[301];
>> + double X0[1001];
>> + double W0[1001];
>> + double Px0[101][25];
>> + double P0[512][4];
>> + double H0[64][64];
>> + double Rh0[2048];
>> + double Vxne0[101];
>> + double Zr0[7][101];
>> + double Zu0[7][101];
>> + double Zv0[7][101];
>> + double Zz0[7][101];
>> + double Za0[101][25];
>> + double Stb50;
>> + double Xx0;
>> +}as1;
>> +
>> +#define u as1.U
>> +#define v as1.V
>> +#define w as1.W
>> +#define x as1.X
>> +#define y as1.Y
>> +#define z as1.Z
>> +#define g as1.G
>> +#define du1 as1.Du1
>> +#define du2 as1.Du2
>> +#define du3 as1.Du3
>> +#define grd as1.Grd
>> +#define dex as1.Dex
>> +#define xi as1.Xi
>> +#define ex as1.Ex
>> +#define ex1 as1.Ex1
>> +#define dex1 as1.Dex1
>> +#define vx as1.Vx
>> +#define xx as1.Xx
>> +#define rx as1.Rx
>> +#define rh as1.Rh
>> +#define vsp as1.Vsp
>> +#define vstp as1.Vstp
>> +#define vxne as1.Vxne
>> +#define vxnd as1.Vxnd
>> +#define ve3 as1.Ve3
>> +#define vlr as1.Vlr
>> +#define vlin as1.Vlin
>> +#define b5 as1.B5
>> +#define plan as1.Plan
>> +#define d as1.D
>> +#define sa as1.Sa
>> +#define sb as1.Sb
>> +#define p as1.P
>> +#define px as1.Px
>> +#define cx as1.Cx
>> +#define vy as1.Vy
>> +#define vh as1.Vh
>> +#define vf as1.Vf
>> +#define vg as1.Vg
>> +#define vs as1.Vs
>> +#define za as1.Za
>> +#define zb as1.Zb
>> +#define zp as1.Zp
>> +#define zq as1.Zq
>> +#define zr as1.Zr
>> +#define zm as1.Zm
>> +#define zz as1.Zz
>> +#define zu as1.Zu
>> +#define zv as1.Zv
>> +#define b as1.B
>> +#define c as1.C
>> +#define h as1.H
>> +#define u1 as1.U1
>> +#define u2 as1.U2
>> +#define u3 as1.U3
>> +#define xtra as1.Xtra
>> +#define a11 as1.Xtra[1]
>> +#define a12 as1.Xtra[2]
>> +#define a13 as1.Xtra[3]
>> +#define a21 as1.Xtra[4]
>> +#define a22 as1.Xtra[5]
>> +#define a23 as1.Xtra[6]
>> +#define a31 as1.Xtra[7]
>> +#define a32 as1.Xtra[8]
>> +#define a33 as1.Xtra[9]
>> +#define c0 as1.Xtra[12]
>> +#define dk as1.Xtra[15]
>> +#define dm22 as1.Xtra[16]
>> +#define dm23 as1.Xtra[17]
>> +#define dm24 as1.Xtra[18]
>> +#define dm25 as1.Xtra[19]
>> +#define dm26 as1.Xtra[20]
>> +#define dm27 as1.Xtra[21]
>> +#define dm28 as1.Xtra[22]
>> +#define expmax as1.Xtra[26]
>> +#define flx as1.Xtra[27]
>> +#define q as1.Xtra[28]
>> +#define r as1.Xtra[30]
>> +#define s as1.Xtra[32]
>> +#define sig as1.Xtra[34]
>> +#define stb5 as1.Xtra[35]
>> +#define t as1.Xtra[36]
>> +#define xnm as1.Xtra[39]
>> +#define e as1.E
>> +#define f as1.F
>> +#define ix as1.Ix
>> +#define ir as1.Ir
>> +#define zone as1.Zone
>> +#define x0 as1.X0
>> +#define w0 as1.W0
>> +#define px0 as1.Px0
>> +#define p0 as1.P0
>> +#define h0 as1.H0
>> +#define rh0 as1.Rh0
>> +#define vxne0 as1.Vxne0
>> +#define zr0 as1.Zr0
>> +#define zu0 as1.Zu0
>> +#define zv0 as1.Zv0
>> +#define zz0 as1.Zz0
>> +#define za0 as1.Za0
>> +#define stb50 as1.Stb50
>> +#define xx0 as1.Xx0
>> +
>> +struct Parameters
>> +{
>> + long Inner_loops;
>> + long Outer_loops;
>> + long Loop_mult;
>> + double Flops_per_loop;
>> + double Sumcheck[3][25];
>> + long Accuracy[3][25];
>> + double LoopTime[3][25];
>> + double LoopSpeed[3][25];
>> + double LoopFlos[3][25];
>> + long Xflops[25];
>> + long Xloops[3][25];
>> + long Nspan[3][25];
>> + double TimeStart;
>> + double TimeEnd;
>> + double Loopohead;
>> + long Count;
>> + long Count2;
>> + long Pass;
>> + long Extra_loops[3][25];
>> + long K2;
>> + long K3;
>> + long M16;
>> + long J5;
>> + long Section;
>> + long N16;
>> + double Mastersum;
>> + long M24;
>> +
>> +
>> +}as2;
>> +
>> +#define n as2.Inner_loops
>> +#define loop as2.Outer_loops
>> +#define mult as2.Loop_mult
>> +#define nflops as2.Flops_per_loop
>> +#define Checksum as2.Sumcheck
>> +#define accuracy as2.Accuracy
>> +#define RunTime as2.LoopTime
>> +#define Mflops as2.LoopSpeed
>> +#define FPops as2.LoopFlos
>> +#define nspan as2.Nspan
>> +#define xflops as2.Xflops
>> +#define xloops as2.Xloops
>> +#define StartTime as2.TimeStart
>> +#define EndTime as2.TimeEnd
>> +#define overhead_l as2.Loopohead
>> +#define count as2.Count
>> +#define count2 as2.Count2
>> +#define pass as2.Pass
>> +#define extra_loops as2.Extra_loops
>> +#define k2 as2.K2
>> +#define k3 as2.K3
>> +#define m16 as2.M16
>> +#define j5 as2.J5
>> +#define section as2.Section
>> +#define n16 as2.N16
>> +#define MasterSum as2.Mastersum
>> +#define m24 as2.M24
>> +
>> +/* Forward declarations */
>> +void init(long);
>> +long parameters(long);
>> +void iqranf();
>> +
>> +/* These should really be a parameters */
>> +#define ITERATIONS 100000
>> +#define KERNELS 24
>> +
>> +/* Initialises arrays and variables */
>> +void init(long which)
>> +{
>> + long i, j, k, l, m, nn;
>> + double ds, dw, rr, ss;
>> + double fuzz, fizz, buzz, scaled, one;
>> +
>> + scaled = (double)(10.0);
>> + scaled = (double)(1.0) / scaled;
>> + fuzz = (double)(0.0012345);
>> + buzz = (double)(1.0) + fuzz;
>> + fizz = (double)(1.1) * fuzz;
>> + one = (double)(1.0);
>> +
>> + for ( k=0 ; k<19977 + 34132 ; k++)
>> + {
>> + if (k == 19977)
>> + {
>> + fuzz = (double)(0.0012345);
>> + buzz = (double) (1.0) + fuzz;
>> + fizz = (double) (1.1) * fuzz;
>> + }
>> + buzz = (one - fuzz) * buzz + fuzz;
>> + fuzz = - fuzz;
>> + u[k] = (buzz - fizz) * scaled;
>> + }
>> +
>> + fuzz = (double)(0.0012345);
>> + buzz = (double) (1.0) + fuzz;
>> + fizz = (double) (1.1) * fuzz;
>> +
>> + for ( k=1 ; k<40 ; k++)
>> + {
>> + buzz = (one - fuzz) * buzz + fuzz;
>> + fuzz = - fuzz;
>> + xtra[k] = (buzz - fizz) * scaled;
>> + }
>> +
>> + ds = 1.0;
>> + dw = 0.5;
>> + for ( l=0 ; l<4 ; l++ )
>> + {
>> + for ( i=0 ; i<512 ; i++ )
>> + {
>> + p[i][l] = ds;
>> + ds = ds + dw;
>> + }
>> + }
>> + for ( i=0 ; i<96 ; i++ )
>> + {
>> + e[i] = 1;
>> + f[i] = 1;
>> + }
>> +
>> +
>> + iqranf();
>> + dw = -100.0;
>> + for ( i=0; i<1001 ; i++ )
>> + {
>> + dex[i] = dw * dex[i];
>> + grd[i] = ix[i];
>> + y[i] = grd[i] * fizz;
>> + }
>> + flx = 0.001;
>> +
>> +
>> + d[0]= 1.01980486428764;
>> + nn = n16;
>> +
>> + for ( l=1 ; l<300 ; l++ )
>> + {
>> + d[l] = d[l-1] + 1.000e-4 / d[l-1];
>> + }
>> + rr = d[nn-1];
>> + for ( l=1 ; l<=2 ; l++ )
>> + {
>> + m = (nn+nn)*(l-1);
>> + for ( j=1 ; j<=2 ; j++ )
>> + {
>> + for ( k=1 ; k<=nn ; k++ )
>> + {
>> + m = m + 1;
>> + ss = (double)(k);
>> + plan[m-1] = rr * ((ss + 1.0) / ss);
>> + zone[m-1] = k + k;
>> + }
>> + }
>> + }
>> + k = nn + nn + 1;
>> + zone[k-1] = nn;
>> +
>> + if (which == 16)
>> + {
>> + r = d[n-1];
>> + s = d[n-2];
>> + t = d[n-3];
>> + k3 = k2 = 0;
>> + }
>> + expmax = 20.0;
>> + if (which == 22)
>> + {
>> + u[n-1] = 0.99*expmax*v[n-1];
>> + }
>> + if (which == 24)
>> + {
>> + x[n/2] = -1.0e+10;
>> + }
>> +
>> + /* Make copies of data for extra loops */
>> +
>> + for ( i=0; i<1001 ; i++ )
>> + {
>> + x0[i] = x[i];
>> + w0[i] = w[i];
>> + for (j=0 ; j<25 ; j++ )
>> + {
>> + cx[i][j] = x[i]*buzz;
>> + px[i][j] = w[i]*fuzz;
>> + }
>> + }
>> + for ( i=0 ; i<101 ; i++ )
>> + {
>> + for (j=0 ; j<25 ; j++ )
>> + {
>> + px0[i][j] = px[i][j];
>> + }
>> + }
>> + for ( i=0 ; i<512 ; i++ )
>> + {
>> + for (j=0 ; j<4 ; j++ )
>> + {
>> + p0[i][j] = p[i][j];
>> + }
>> + }
>> + for ( i=0 ; i<64 ; i++ )
>> + {
>> + for (j=0 ; j<64 ; j++ )
>> + {
>> + h0[i][j] = h[i][j];
>> + }
>> + }
>> + for ( i=0; i<2048 ; i++ )
>> + {
>> + rh0[i] = rh[i];
>> + }
>> + for ( i=0; i<101 ; i++ )
>> + {
>> + vxne0[i] = vxne[i];
>> + }
>> + for ( i=0 ; i<7 ; i++ )
>> + {
>> + for (j=0 ; j<101 ; j++ )
>> + {
>> + zr0[i][j] = zr[i][j];
>> + zu0[i][j] = zu[i][j];
>> + zv0[i][j] = zv[i][j];
>> + zz0[i][j] = zz[i][j];
>> + za0[i][j] = za[i][j];
>> + }
>> + }
>> + stb50 = stb5;
>> + xx0 = xx[0];
>> +
>> + return;
>> +}
>> +
>> +/* Set up parameters for each kernel */
>> +long parameters(long which)
>> +{
>> +
>> + long nloops[3][25] =
>> + { {0, 1001, 101, 1001, 1001, 1001, 64, 995, 100,
>> + 101, 101, 1001, 1000, 64, 1001, 101, 75,
>> + 101, 100, 101, 1000, 101, 101, 100, 1001 },
>> + {0, 101, 101, 101, 101, 101, 32, 101, 100,
>> + 101, 101, 101, 100, 32, 101, 101, 40,
>> + 101, 100, 101, 100, 50, 101, 100, 101 },
>> + {0, 27, 15, 27, 27, 27, 8, 21, 14,
>> + 15, 15, 27, 26, 8, 27, 15, 15,
>> + 15, 14, 15, 26, 20, 15, 14, 27 } };
>> +
>> +
>> +
>> + long lpass[3][25] =
>> + { {0, 7, 67, 9, 14, 10, 3, 4, 10, 36, 34, 11, 12,
>> + 36, 2, 1, 25, 35, 2, 39, 1, 1, 11, 8, 5 },
>> + {0, 40, 40, 53, 70, 55, 7, 22, 6, 21, 19, 64, 68,
>> + 41, 10, 1, 27, 20, 1, 23, 8, 1, 7, 5, 31 },
>> + {0, 28, 46, 37, 38, 40, 21, 20, 9, 26, 25, 46, 48,
>> + 31, 8, 1, 14, 26, 2, 28, 7, 1, 8, 7, 23 } };
>> +
>> + double sums[3][25] =
>> + {
>> + { 0.0,
>> + 5.114652693224671e+04, 1.539721811668385e+03, 1.000742883066363e+01,
>> + 5.999250595473891e-01, 4.548871642387267e+03, 4.375116344729986e+03,
>> + 6.104251075174761e+04, 1.501268005625798e+05, 1.189443609974981e+05,
>> + 7.310369784325296e+04, 3.342910972650109e+07, 2.907141294167248e-05,
>> + 1.202533961842803e+11, 3.165553044000334e+09, 3.943816690352042e+04,
>> + 5.650760000000000e+05, 1.114641772902486e+03, 1.015727037502300e+05,
>> + 5.421816960147207e+02, 3.040644339351239e+07, 1.597308280710199e+08,
>> + 2.938604376566697e+02, 3.549900501563623e+04, 5.000000000000000e+02
>> + },
>> +
>> + { 0.0,
>> + 5.253344778937972e+02, 1.539721811668385e+03, 1.009741436578952e+00,
>> + 5.999250595473891e-01, 4.589031939600982e+01, 8.631675645333210e+01,
>> + 6.345586315784055e+02, 1.501268005625798e+05, 1.189443609974981e+05,
>> + 7.310369784325296e+04, 3.433560407475758e+04, 7.127569130821465e-06,
>> + 9.816387810944345e+10, 3.039983465145393e+07, 3.943816690352042e+04,
>> + 6.480410000000000e+05, 1.114641772902486e+03, 1.015727037502300e+05,
>> + 5.421816960147207e+02, 3.126205178815431e+04, 7.824524877232093e+07,
>> + 2.938604376566697e+02, 3.549900501563623e+04, 5.000000000000000e+01
>> + },
>> +
>> + { 0.0,
>> + 3.855104502494961e+01, 3.953296986903059e+01, 2.699309089320672e-01,
>> + 5.999250595473891e-01, 3.182615248447483e+00, 1.120309393467088e+00,
>> + 2.845720217644024e+01, 2.960543667875003e+03, 2.623968460874250e+03,
>> + 1.651291227698265e+03, 6.551161335845770e+02, 1.943435981130448e-06,
>> + 3.847124199949426e+10, 2.923540598672011e+06, 1.108997288134785e+03,
>> + 5.152160000000000e+05, 2.947368618589360e+01, 9.700646212337040e+02,
>> + 1.268230698051003e+01, 5.987713249475302e+02, 5.009945671204667e+07,
>> + 6.109968728263972e+00, 4.850340602749970e+02, 1.300000000000000e+01
>> + } };
>> +
>> +
>> +
>> + double number_flops[25] = {0, 5., 4., 2., 2., 2., 2., 16., 36., 17.,
>> + 9., 1., 1., 7., 11., 33.,10., 9., 44.,
>> + 6., 26., 2., 17., 11., 1.};
>> +
>> + n = nloops[section][which];
>> + nspan[section][which] = n;
>> + n16 = nloops[section][16];
>> + nflops = number_flops[which];
>> + xflops[which] = (long)nflops;
>> + loop = lpass[section][which];
>> + xloops[section][which] = loop;
>> + loop = loop * mult;
>> + MasterSum = sums[section][which];
>> + count = 0;
>> +
>> + init(which);
>> +
>> + return 0;
>> +}
>> +
>> +/* iqranf procedure - "random" number generator */
>> +void iqranf()
>> +{
>> +
>> + long inset, Mmin, Mmax, nn, i, kk;
>> + double span, spin, realn, per, scale1, qq, dkk, dp, dq;
>> + long seed[3] = { 256, 12491249, 1499352848 };
>> +
>> + nn = 1001;
>> + Mmin = 1;
>> + Mmax = 1001;
>> + kk = seed[section];
>> +
>> + inset= Mmin;
>> + span= Mmax - Mmin;
>> + spin= 16807;
>> + per= 2147483647;
>> + realn= nn;
>> + scale1= 1.00001;
>> + qq= scale1 * (span / realn);
>> + dkk= kk;
>> +
>> + for ( i=0 ; i<nn ; i++)
>> + {
>> + dp= dkk*spin;
>> + dkk= dp - (long)( dp/per)*per;
>> + dq= dkk*span;
>> + ix[i] = inset + (long)( dq/ per);
>> + if ((ix[i] < Mmin) | (ix[i] > Mmax))
>> + {
>> + ix[i] = inset + i + 1 * (long)qq;
>> + }
>> + }
>> +
>> + return;
>> +}
>>
>> Modified: test-suite/trunk/SingleSource/Benchmarks/Makefile
>> URL: http://llvm.org/viewvc/llvm-project/test-suite/trunk/SingleSource/Benchmarks/Makefile?rev=168264&r1=168263&r2=168264&view=diff
>> ==============================================================================
>> --- test-suite/trunk/SingleSource/Benchmarks/Makefile (original)
>> +++ test-suite/trunk/SingleSource/Benchmarks/Makefile Sat Nov 17 12:52:20 2012
>> @@ -1,6 +1,6 @@
>> LEVEL = ../..
>> PARALLEL_DIRS := Dhrystone CoyoteBench Shootout Shootout-C++ Stanford McGill \
>> - Misc Misc-C++ Misc-C++-EH BenchmarkGame Adobe-C++ Polybench Linpack
>> + Misc Misc-C++ Misc-C++-EH BenchmarkGame Adobe-C++ Polybench Linpack LivermoreLoops
>> LDFLAGS += -lm
>>
>> # Disable Polybench tests on ARM for the time being, they are very long running.
>>
>>
>> _______________________________________________
>> llvm-commits mailing list
>> llvm-commits at cs.uiuc.edu
>> http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
More information about the llvm-commits
mailing list