Hello community, here is the log from the commit of package stream for openSUSE:Factory:NonFree checked in at 2016-11-01 09:59:55 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory:NonFree/stream (Old) and /work/SRC/openSUSE:Factory:NonFree/.stream.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "stream" Changes: -------- New Changes file: --- /dev/null 2016-10-27 01:54:32.792041256 +0200 +++ /work/SRC/openSUSE:Factory:NonFree/.stream.new/stream.changes 2016-11-01 09:59:56.000000000 +0100 @@ -0,0 +1,5 @@ +------------------------------------------------------------------- +Sun Oct 23 15:51:03 UTC 2016 - [email protected] + +- Initial package for version 5.10 + New: ---- HISTORY.txt LICENSE.txt READ.ME mysecond.c stream.c stream.changes stream.f stream.spec ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ stream.spec ++++++ # # spec file for package stream # # Copyright (c) 2016 SUSE LINUX GmbH, Nuernberg, Germany. # # All modifications and additions to the file contributed by third parties # remain the property of their copyright owners, unless otherwise agreed # upon. The license for this file, and modifications and additions to the # file, is the same license as for the pristine package itself (unless the # license for the pristine package is not an Open Source License, in which # case the license is the MIT License). An "Open Source License" is a # license that conforms to the Open Source Definition (Version 1.9) # published by the Open Source Initiative. # Please submit bugfixes or comments via http://bugs.opensuse.org/ # Name: stream Version: 5.10 Release: 0 License: SUSE-NonFree Summary: Memory bandwidth benchmark Url: https://www.cs.virginia.edu/stream/ Group: System/Benchmark Source0: https://www.cs.virginia.edu/stream/FTP/Code/stream.c Source1: https://www.cs.virginia.edu/stream/FTP/Code/mysecond.c Source2: https://www.cs.virginia.edu/stream/FTP/Code/stream.f Source3: https://www.cs.virginia.edu/stream/FTP/Code/LICENSE.txt Source4: https://www.cs.virginia.edu/stream/FTP/Code/HISTORY.txt Source5: https://www.cs.virginia.edu/stream/FTP/Code/READ.ME BuildRequires: gcc-fortran BuildRoot: %{_tmppath}/%{name}-%{version}-build %description STREAM is the de facto industry standard benchmark for measuring sustained memory bandwidth. %prep %setup -qTc cp \ %{SOURCE3} \ %{SOURCE4} \ %{SOURCE5} . %build # C version cc %{optflags} -fopenmp %{SOURCE0} -o stream_c # Fortran version gfortran %{optflags} -fopenmp %{SOURCE1} %{SOURCE2} -o stream_f %install install -D -p -m 0755 stream_c \ %{buildroot}%{_bindir}/stream_c install -D -p -m 0755 stream_f \ %{buildroot}%{_bindir}/stream_f %files %defattr(-,root,root) %doc LICENSE.txt HISTORY.txt READ.ME %{_bindir}/stream_c %{_bindir}/stream_f %changelog ++++++ HISTORY.txt ++++++ ------------------------------------------------------------------------- Revisions as of Thu, Jan 17, 2013 3:50:01 PM Version 5.10 of stream.c has been released. This version includes improved validation code and will automatically use 64-bit array indices on 64-bit systems to allow very large arrays. ------------------------------------------------------------------------- Revisions as of Thu Feb 19 08:16:57 CST 2009 Note that the codes in the "Versions" subdirectory should be considered obsolete -- the versions of stream.c and stream.f in this main directory include the OpenMP directives and structure for creating "TUNED" versions. Only the MPI version in the "Versions" subdirectory should be of any interest, and I have not recently checked that version for errors or compliance with the current versions of stream.c and stream.f. I added a simple Makefile to this directory. It works under Cygwin on my Windows XP box (using gcc and g77). A user suggested a sneaky trick for "mysecond.c" -- instead of using the #ifdef UNDERSCORE to generate the function name that the Fortran compiler expects, the new version simply defines both "mysecond()" and "mysecond_()", so it should automagically link with most Fortran compilers. ------------------------------------------------------------------------- Revisions as of Wed Nov 17 09:15:37 CST 2004 The most recent "official" versions have been renamed "stream.f" and "stream.c" -- all other versions have been moved to the "Versions" subdirectory. The "official" timer (was "second_wall.c") has been renamed "mysecond.c". This is embedded in the C version ("stream.c"), but still needs to be externally linked to the FORTRAN version ("stream.f"). ------------------------------------------------------------------------- Revisions as of Tue May 27 11:51:23 CDT 2003 Copyright and License info added to stream_d.f, stream_mpi.f, and stream_tuned.f ------------------------------------------------------------------------- Revisions as of Tue Apr 8 10:26:48 CDT 2003 I changed the name of the timer interface from "second" to "mysecond" and removed the dummy argument in all versions of the source code (but not the "Contrib" versions). ------------------------------------------------------------------------- Revisions as of Mon Feb 25 06:48:14 CST 2002 Added an OpenMP version of stream_d.c, called stream_d_omp.c. This is still not up to date with the Fortran version, which includes error checking and advanced data flow to prevent overoptimization, but it is a good start.... ------------------------------------------------------------------------- Revisions as of Tue Jun 4 16:31:31 EDT 1996 I have fixed an "off-by-one" error in the RMS time calculation in stream_d.f. This was already corrected in stream_d.c. No results are invalidated, since I use minimum time instead of RMS time anyway.... ------------------------------------------------------------------------- Revisions as of Fri Dec 8 14:49:56 EST 1995 I have renamed the timer routines to: second_cpu.c second_wall.c second_cpu.f All have a function interface named 'second' which returns a double precision floating point number. It should be possible to link second_wall.c with stream_d.f without too much trouble, though the details will depend on your environment. If anyone builds versions of these timers for machines running the Macintosh O/S or DOS/Windows, I would appreciate getting a copy. To clarify: * For single-user machines, the wallclock timer is preferred. * For parallel machines, the wallclock timer is required. * For time-shared systems, the cpu timer is more reliable, though less accurate. ------------------------------------------------------------------------- Revisions as of Wed Oct 25 09:40:32 EDT 1995 (1) NOTICE to C users: stream_d.c has been updated to version 4.0 (beta), and should be functionally identical to stream_d.f Two timers are provided --- second_cpu.c and second_wall.c second_cpu.c measures cpu time, while second_wall.c measures elapsed (real) time. For single-user machines, the wallclock timer is preferred. For parallel machines, the wallclock timer is required. For time-shared systems, the cpu timer is more reliable, though less accurate. (2) cstream.c has been removed -- use stream_d.c (3) stream_wall.f has been removed --- to do parallel aggregate bandwidth runs, comment out the definition of FUNCTION SECOND in stream_d.f and compile/link with second_wall.c (4) stream_offset has been deprecated. It is still here and usable, but stream_d.f is the "standard" version. There are easy hooks in stream_d.f to change the array offsets if you want to. (5) The rules of the game are clarified as follows: The reference case uses array sizes of 2,000,000 elements and no additional offsets. I would like to see results for this case. But, you are free to use any array size and any offset you want, provided that the arrays are each bigger than the last-level of cache. The output will show me what parameters you chose. I expect that I will report just the best number, but if there is a serious discrepancy between the reference case and the "best" case, I reserve the right to report both. Of course, I also reserve the right to reject any results that I do not trust.... -- John D. McCalpin, Ph.D. [email protected] ++++++ LICENSE.txt ++++++ *======================================================================= *----------------------------------------------------------------------- * Copyright 1991-2003: John D. McCalpin *----------------------------------------------------------------------- * License: * 1. You are free to use this program and/or to redistribute * this program. * 2. You are free to modify this program for your own use, * including commercial use, subject to the publication * restrictions in item 3. * 3. You are free to publish results obtained from running this * program, or from works that you derive from this program, * with the following limitations: * 3a. In order to be referred to as "STREAM benchmark results", * published results must be in conformance to the STREAM * Run Rules, (briefly reviewed below) published at * http://www.cs.virginia.edu/stream/ref.html * and incorporated herein by reference. * As the copyright holder, John McCalpin retains the * right to determine conformity with the Run Rules. * 3b. Results based on modified source code or on runs not in * accordance with the STREAM Run Rules must be clearly * labelled whenever they are published. Examples of * proper labelling include: * "tuned STREAM benchmark results" * "based on a variant of the STREAM benchmark code" * Other comparable, clear and reasonable labelling is * acceptable. * 3c. Submission of results to the STREAM benchmark web site * is encouraged, but not required. * 4. Use of this program or creation of derived works based on this * program constitutes acceptance of these licensing restrictions. * 5. Absolutely no warranty is expressed or implied. *----------------------------------------------------------------------- ++++++ READ.ME ++++++ =============================================== STREAM is the de facto industry standard benchmark for measuring sustained memory bandwidth. Documentation for STREAM is on the web at: http://www.cs.virginia.edu/stream/ref.html =============================================== NEWS =============================================== UPDATE: October 28 2014: "stream_mpi.c" released in the Versions directory. Based on Version 5.10 of stream.c, stream_mpi.c brings the following new features: * MPI implementation that *distributes* the arrays across all MPI ranks. (The older Fortran version of STREAM in MPI *replicates* the arrays across all MPI ranks.) * Data is allocated using "posix_memalign" rather than using static arrays. Different compiler flags may be needed for both portability and optimization. See the READ.ME file in the Versions directory for more details. * Error checking and timing done by all ranks and gathered by rank 0 for processing and output. * Timing code uses barriers to ensure correct operation even when multiple MPI ranks run on shared memory systems. NOTE: MPI is not a preferred implementation for STREAM, which is intended to measure memory bandwidth in shared-memory systems. In stream_mpi, the MPI calls are only used to properly synchronize the timers (using MPI_Barrier) and to gather timing and error data, so the performance should scale linearly with the size of the cluster. But it may be useful, and was an interesting exercise to develop and debug. =============================================== UPDATE: January 17 2013: Version 5.10 of stream.c is finally available! There are no changes to what is being measured, but a number of long-awaited improvements have been made: * Updated validation code does not suffer from accumulated roundoff error for large arrays. * Defining the preprocessor variable "VERBOSE" when compiling will (1) cause the code to print the measured average relative absolute error (rather than simply printing "Solution Validates", and (2) print the first 10 array entries with relative error exceeding the error tolerance. * Array index variables have been upgraded from "int" to "ssize_t" to allow arrays with more than 2 billion elements on 64-bit systems. * Substantial improvements to the comments in the source on how to configure/compile/run the benchmark. * The proprocessor variable controlling the array size has been changed from "N" to "STREAM_ARRAY_SIZE". * A new preprocessor variable "STREAM_TYPE" can be used to override the data type from the default "double" to "float". This mechanism could also be used to change to non-floating-point types, but several "printf" statements would need to have their formats changed to accomodate the modified data type. * Some small changes in output, including printing array sizes is GiB as well as MiB. * Change to the default output format to print fewer decimals for the bandwidth and more decimals for the min/max/avg execution times. =============================================== UPDATE: February 19 2009: The most recent "official" versions have been renamed "stream.f" and "stream.c" -- all other versions have been moved to the "Versions" subdirectory and should be considered obsolete. The "official" timer (was "second_wall.c") has been renamed "mysecond.c". This is embedded in the C version ("stream.c"), but still needs to be externally linked to the FORTRAN version ("stream.f"). The new version defines entry points both with and without trailing underscores, so it *should* link automagically with any Fortran compiler. =============================================== STREAM is a project of "Dr. Bandwidth": John D. McCalpin, Ph.D. [email protected] =============================================== The STREAM web and ftp sites are currently hosted at the Department of Computer Science at the University of Virginia under the generous sponsorship of Professor Bill Wulf and Professor Alan Batson. =============================================== ++++++ mysecond.c ++++++ /* A gettimeofday routine to give access to the wall clock timer on most UNIX-like systems. This version defines two entry points -- with and without appended underscores, so it *should* automagically link with FORTRAN */ #include <sys/time.h> double mysecond() { /* struct timeval { long tv_sec; long tv_usec; }; struct timezone { int tz_minuteswest; int tz_dsttime; }; */ struct timeval tp; struct timezone tzp; int i; i = gettimeofday(&tp,&tzp); return ( (double) tp.tv_sec + (double) tp.tv_usec * 1.e-6 ); } double mysecond_() {return mysecond();} ++++++ stream.c ++++++ /*-----------------------------------------------------------------------*/ /* Program: STREAM */ /* Revision: $Id: stream.c,v 5.10 2013/01/17 16:01:06 mccalpin Exp mccalpin $ */ /* Original code developed by John D. McCalpin */ /* Programmers: John D. McCalpin */ /* Joe R. Zagar */ /* */ /* This program measures memory transfer rates in MB/s for simple */ /* computational kernels coded in C. */ /*-----------------------------------------------------------------------*/ /* Copyright 1991-2013: John D. McCalpin */ /*-----------------------------------------------------------------------*/ /* License: */ /* 1. You are free to use this program and/or to redistribute */ /* this program. */ /* 2. You are free to modify this program for your own use, */ /* including commercial use, subject to the publication */ /* restrictions in item 3. */ /* 3. You are free to publish results obtained from running this */ /* program, or from works that you derive from this program, */ /* with the following limitations: */ /* 3a. In order to be referred to as "STREAM benchmark results", */ /* published results must be in conformance to the STREAM */ /* Run Rules, (briefly reviewed below) published at */ /* http://www.cs.virginia.edu/stream/ref.html */ /* and incorporated herein by reference. */ /* As the copyright holder, John McCalpin retains the */ /* right to determine conformity with the Run Rules. */ /* 3b. Results based on modified source code or on runs not in */ /* accordance with the STREAM Run Rules must be clearly */ /* labelled whenever they are published. Examples of */ /* proper labelling include: */ /* "tuned STREAM benchmark results" */ /* "based on a variant of the STREAM benchmark code" */ /* Other comparable, clear, and reasonable labelling is */ /* acceptable. */ /* 3c. Submission of results to the STREAM benchmark web site */ /* is encouraged, but not required. */ /* 4. Use of this program or creation of derived works based on this */ /* program constitutes acceptance of these licensing restrictions. */ /* 5. Absolutely no warranty is expressed or implied. */ /*-----------------------------------------------------------------------*/ # include <stdio.h> # include <unistd.h> # include <math.h> # include <float.h> # include <limits.h> # include <sys/time.h> /*----------------------------------------------------------------------- * INSTRUCTIONS: * * 1) STREAM requires different amounts of memory to run on different * systems, depending on both the system cache size(s) and the * granularity of the system timer. * You should adjust the value of 'STREAM_ARRAY_SIZE' (below) * to meet *both* of the following criteria: * (a) Each array must be at least 4 times the size of the * available cache memory. I don't worry about the difference * between 10^6 and 2^20, so in practice the minimum array size * is about 3.8 times the cache size. * Example 1: One Xeon E3 with 8 MB L3 cache * STREAM_ARRAY_SIZE should be >= 4 million, giving * an array size of 30.5 MB and a total memory requirement * of 91.5 MB. * Example 2: Two Xeon E5's with 20 MB L3 cache each (using OpenMP) * STREAM_ARRAY_SIZE should be >= 20 million, giving * an array size of 153 MB and a total memory requirement * of 458 MB. * (b) The size should be large enough so that the 'timing calibration' * output by the program is at least 20 clock-ticks. * Example: most versions of Windows have a 10 millisecond timer * granularity. 20 "ticks" at 10 ms/tic is 200 milliseconds. * If the chip is capable of 10 GB/s, it moves 2 GB in 200 msec. * This means the each array must be at least 1 GB, or 128M elements. * * Version 5.10 increases the default array size from 2 million * elements to 10 million elements in response to the increasing * size of L3 caches. The new default size is large enough for caches * up to 20 MB. * Version 5.10 changes the loop index variables from "register int" * to "ssize_t", which allows array indices >2^32 (4 billion) * on properly configured 64-bit systems. Additional compiler options * (such as "-mcmodel=medium") may be required for large memory runs. * * Array size can be set at compile time without modifying the source * code for the (many) compilers that support preprocessor definitions * on the compile line. E.g., * gcc -O -DSTREAM_ARRAY_SIZE=100000000 stream.c -o stream.100M * will override the default size of 10M with a new size of 100M elements * per array. */ #ifndef STREAM_ARRAY_SIZE # define STREAM_ARRAY_SIZE 10000000 #endif /* 2) STREAM runs each kernel "NTIMES" times and reports the *best* result * for any iteration after the first, therefore the minimum value * for NTIMES is 2. * There are no rules on maximum allowable values for NTIMES, but * values larger than the default are unlikely to noticeably * increase the reported performance. * NTIMES can also be set on the compile line without changing the source * code using, for example, "-DNTIMES=7". */ #ifdef NTIMES #if NTIMES<=1 # define NTIMES 10 #endif #endif #ifndef NTIMES # define NTIMES 10 #endif /* Users are allowed to modify the "OFFSET" variable, which *may* change the * relative alignment of the arrays (though compilers may change the * effective offset by making the arrays non-contiguous on some systems). * Use of non-zero values for OFFSET can be especially helpful if the * STREAM_ARRAY_SIZE is set to a value close to a large power of 2. * OFFSET can also be set on the compile line without changing the source * code using, for example, "-DOFFSET=56". */ #ifndef OFFSET # define OFFSET 0 #endif /* * 3) Compile the code with optimization. Many compilers generate * unreasonably bad code before the optimizer tightens things up. * If the results are unreasonably good, on the other hand, the * optimizer might be too smart for me! * * For a simple single-core version, try compiling with: * cc -O stream.c -o stream * This is known to work on many, many systems.... * * To use multiple cores, you need to tell the compiler to obey the OpenMP * directives in the code. This varies by compiler, but a common example is * gcc -O -fopenmp stream.c -o stream_omp * The environment variable OMP_NUM_THREADS allows runtime control of the * number of threads/cores used when the resulting "stream_omp" program * is executed. * * To run with single-precision variables and arithmetic, simply add * -DSTREAM_TYPE=float * to the compile line. * Note that this changes the minimum array sizes required --- see (1) above. * * The preprocessor directive "TUNED" does not do much -- it simply causes the * code to call separate functions to execute each kernel. Trivial versions * of these functions are provided, but they are *not* tuned -- they just * provide predefined interfaces to be replaced with tuned code. * * * 4) Optional: Mail the results to [email protected] * Be sure to include info that will help me understand: * a) the computer hardware configuration (e.g., processor model, memory type) * b) the compiler name/version and compilation flags * c) any run-time information (such as OMP_NUM_THREADS) * d) all of the output from the test case. * * Thanks! * *-----------------------------------------------------------------------*/ # define HLINE "-------------------------------------------------------------\n" # ifndef MIN # define MIN(x,y) ((x)<(y)?(x):(y)) # endif # ifndef MAX # define MAX(x,y) ((x)>(y)?(x):(y)) # endif #ifndef STREAM_TYPE #define STREAM_TYPE double #endif static STREAM_TYPE a[STREAM_ARRAY_SIZE+OFFSET], b[STREAM_ARRAY_SIZE+OFFSET], c[STREAM_ARRAY_SIZE+OFFSET]; static double avgtime[4] = {0}, maxtime[4] = {0}, mintime[4] = {FLT_MAX,FLT_MAX,FLT_MAX,FLT_MAX}; static char *label[4] = {"Copy: ", "Scale: ", "Add: ", "Triad: "}; static double bytes[4] = { 2 * sizeof(STREAM_TYPE) * STREAM_ARRAY_SIZE, 2 * sizeof(STREAM_TYPE) * STREAM_ARRAY_SIZE, 3 * sizeof(STREAM_TYPE) * STREAM_ARRAY_SIZE, 3 * sizeof(STREAM_TYPE) * STREAM_ARRAY_SIZE }; extern double mysecond(); extern void checkSTREAMresults(); #ifdef TUNED extern void tuned_STREAM_Copy(); extern void tuned_STREAM_Scale(STREAM_TYPE scalar); extern void tuned_STREAM_Add(); extern void tuned_STREAM_Triad(STREAM_TYPE scalar); #endif #ifdef _OPENMP extern int omp_get_num_threads(); #endif int main() { int quantum, checktick(); int BytesPerWord; int k; ssize_t j; STREAM_TYPE scalar; double t, times[4][NTIMES]; /* --- SETUP --- determine precision and check timing --- */ printf(HLINE); printf("STREAM version $Revision: 5.10 $\n"); printf(HLINE); BytesPerWord = sizeof(STREAM_TYPE); printf("This system uses %d bytes per array element.\n", BytesPerWord); printf(HLINE); #ifdef N printf("***** WARNING: ******\n"); printf(" It appears that you set the preprocessor variable N when compiling this code.\n"); printf(" This version of the code uses the preprocesor variable STREAM_ARRAY_SIZE to control the array size\n"); printf(" Reverting to default value of STREAM_ARRAY_SIZE=%llu\n",(unsigned long long) STREAM_ARRAY_SIZE); printf("***** WARNING: ******\n"); #endif printf("Array size = %llu (elements), Offset = %d (elements)\n" , (unsigned long long) STREAM_ARRAY_SIZE, OFFSET); printf("Memory per array = %.1f MiB (= %.1f GiB).\n", BytesPerWord * ( (double) STREAM_ARRAY_SIZE / 1024.0/1024.0), BytesPerWord * ( (double) STREAM_ARRAY_SIZE / 1024.0/1024.0/1024.0)); printf("Total memory required = %.1f MiB (= %.1f GiB).\n", (3.0 * BytesPerWord) * ( (double) STREAM_ARRAY_SIZE / 1024.0/1024.), (3.0 * BytesPerWord) * ( (double) STREAM_ARRAY_SIZE / 1024.0/1024./1024.)); printf("Each kernel will be executed %d times.\n", NTIMES); printf(" The *best* time for each kernel (excluding the first iteration)\n"); printf(" will be used to compute the reported bandwidth.\n"); #ifdef _OPENMP printf(HLINE); #pragma omp parallel { #pragma omp master { k = omp_get_num_threads(); printf ("Number of Threads requested = %i\n",k); } } #endif #ifdef _OPENMP k = 0; #pragma omp parallel #pragma omp atomic k++; printf ("Number of Threads counted = %i\n",k); #endif /* Get initial value for system clock. */ #pragma omp parallel for for (j=0; j<STREAM_ARRAY_SIZE; j++) { a[j] = 1.0; b[j] = 2.0; c[j] = 0.0; } printf(HLINE); if ( (quantum = checktick()) >= 1) printf("Your clock granularity/precision appears to be " "%d microseconds.\n", quantum); else { printf("Your clock granularity appears to be " "less than one microsecond.\n"); quantum = 1; } t = mysecond(); #pragma omp parallel for for (j = 0; j < STREAM_ARRAY_SIZE; j++) a[j] = 2.0E0 * a[j]; t = 1.0E6 * (mysecond() - t); printf("Each test below will take on the order" " of %d microseconds.\n", (int) t ); printf(" (= %d clock ticks)\n", (int) (t/quantum) ); printf("Increase the size of the arrays if this shows that\n"); printf("you are not getting at least 20 clock ticks per test.\n"); printf(HLINE); printf("WARNING -- The above is only a rough guideline.\n"); printf("For best results, please be sure you know the\n"); printf("precision of your system timer.\n"); printf(HLINE); /* --- MAIN LOOP --- repeat test cases NTIMES times --- */ scalar = 3.0; for (k=0; k<NTIMES; k++) { times[0][k] = mysecond(); #ifdef TUNED tuned_STREAM_Copy(); #else #pragma omp parallel for for (j=0; j<STREAM_ARRAY_SIZE; j++) c[j] = a[j]; #endif times[0][k] = mysecond() - times[0][k]; times[1][k] = mysecond(); #ifdef TUNED tuned_STREAM_Scale(scalar); #else #pragma omp parallel for for (j=0; j<STREAM_ARRAY_SIZE; j++) b[j] = scalar*c[j]; #endif times[1][k] = mysecond() - times[1][k]; times[2][k] = mysecond(); #ifdef TUNED tuned_STREAM_Add(); #else #pragma omp parallel for for (j=0; j<STREAM_ARRAY_SIZE; j++) c[j] = a[j]+b[j]; #endif times[2][k] = mysecond() - times[2][k]; times[3][k] = mysecond(); #ifdef TUNED tuned_STREAM_Triad(scalar); #else #pragma omp parallel for for (j=0; j<STREAM_ARRAY_SIZE; j++) a[j] = b[j]+scalar*c[j]; #endif times[3][k] = mysecond() - times[3][k]; } /* --- SUMMARY --- */ for (k=1; k<NTIMES; k++) /* note -- skip first iteration */ { for (j=0; j<4; j++) { avgtime[j] = avgtime[j] + times[j][k]; mintime[j] = MIN(mintime[j], times[j][k]); maxtime[j] = MAX(maxtime[j], times[j][k]); } } printf("Function Best Rate MB/s Avg time Min time Max time\n"); for (j=0; j<4; j++) { avgtime[j] = avgtime[j]/(double)(NTIMES-1); printf("%s%12.1f %11.6f %11.6f %11.6f\n", label[j], 1.0E-06 * bytes[j]/mintime[j], avgtime[j], mintime[j], maxtime[j]); } printf(HLINE); /* --- Check Results --- */ checkSTREAMresults(); printf(HLINE); return 0; } # define M 20 int checktick() { int i, minDelta, Delta; double t1, t2, timesfound[M]; /* Collect a sequence of M unique time values from the system. */ for (i = 0; i < M; i++) { t1 = mysecond(); while( ((t2=mysecond()) - t1) < 1.0E-6 ) ; timesfound[i] = t1 = t2; } /* * Determine the minimum difference between these M values. * This result will be our estimate (in microseconds) for the * clock granularity. */ minDelta = 1000000; for (i = 1; i < M; i++) { Delta = (int)( 1.0E6 * (timesfound[i]-timesfound[i-1])); minDelta = MIN(minDelta, MAX(Delta,0)); } return(minDelta); } /* A gettimeofday routine to give access to the wall clock timer on most UNIX-like systems. */ #include <sys/time.h> double mysecond() { struct timeval tp; struct timezone tzp; int i; i = gettimeofday(&tp,&tzp); return ( (double) tp.tv_sec + (double) tp.tv_usec * 1.e-6 ); } #ifndef abs #define abs(a) ((a) >= 0 ? (a) : -(a)) #endif void checkSTREAMresults () { STREAM_TYPE aj,bj,cj,scalar; STREAM_TYPE aSumErr,bSumErr,cSumErr; STREAM_TYPE aAvgErr,bAvgErr,cAvgErr; double epsilon; ssize_t j; int k,ierr,err; /* reproduce initialization */ aj = 1.0; bj = 2.0; cj = 0.0; /* a[] is modified during timing check */ aj = 2.0E0 * aj; /* now execute timing loop */ scalar = 3.0; for (k=0; k<NTIMES; k++) { cj = aj; bj = scalar*cj; cj = aj+bj; aj = bj+scalar*cj; } /* accumulate deltas between observed and expected results */ aSumErr = 0.0; bSumErr = 0.0; cSumErr = 0.0; for (j=0; j<STREAM_ARRAY_SIZE; j++) { aSumErr += abs(a[j] - aj); bSumErr += abs(b[j] - bj); cSumErr += abs(c[j] - cj); // if (j == 417) printf("Index 417: c[j]: %f, cj: %f\n",c[j],cj); // MCCALPIN } aAvgErr = aSumErr / (STREAM_TYPE) STREAM_ARRAY_SIZE; bAvgErr = bSumErr / (STREAM_TYPE) STREAM_ARRAY_SIZE; cAvgErr = cSumErr / (STREAM_TYPE) STREAM_ARRAY_SIZE; if (sizeof(STREAM_TYPE) == 4) { epsilon = 1.e-6; } else if (sizeof(STREAM_TYPE) == 8) { epsilon = 1.e-13; } else { printf("WEIRD: sizeof(STREAM_TYPE) = %lu\n",sizeof(STREAM_TYPE)); epsilon = 1.e-6; } err = 0; if (abs(aAvgErr/aj) > epsilon) { err++; printf ("Failed Validation on array a[], AvgRelAbsErr > epsilon (%e)\n",epsilon); printf (" Expected Value: %e, AvgAbsErr: %e, AvgRelAbsErr: %e\n",aj,aAvgErr,abs(aAvgErr)/aj); ierr = 0; for (j=0; j<STREAM_ARRAY_SIZE; j++) { if (abs(a[j]/aj-1.0) > epsilon) { ierr++; #ifdef VERBOSE if (ierr < 10) { printf(" array a: index: %ld, expected: %e, observed: %e, relative error: %e\n", j,aj,a[j],abs((aj-a[j])/aAvgErr)); } #endif } } printf(" For array a[], %d errors were found.\n",ierr); } if (abs(bAvgErr/bj) > epsilon) { err++; printf ("Failed Validation on array b[], AvgRelAbsErr > epsilon (%e)\n",epsilon); printf (" Expected Value: %e, AvgAbsErr: %e, AvgRelAbsErr: %e\n",bj,bAvgErr,abs(bAvgErr)/bj); printf (" AvgRelAbsErr > Epsilon (%e)\n",epsilon); ierr = 0; for (j=0; j<STREAM_ARRAY_SIZE; j++) { if (abs(b[j]/bj-1.0) > epsilon) { ierr++; #ifdef VERBOSE if (ierr < 10) { printf(" array b: index: %ld, expected: %e, observed: %e, relative error: %e\n", j,bj,b[j],abs((bj-b[j])/bAvgErr)); } #endif } } printf(" For array b[], %d errors were found.\n",ierr); } if (abs(cAvgErr/cj) > epsilon) { err++; printf ("Failed Validation on array c[], AvgRelAbsErr > epsilon (%e)\n",epsilon); printf (" Expected Value: %e, AvgAbsErr: %e, AvgRelAbsErr: %e\n",cj,cAvgErr,abs(cAvgErr)/cj); printf (" AvgRelAbsErr > Epsilon (%e)\n",epsilon); ierr = 0; for (j=0; j<STREAM_ARRAY_SIZE; j++) { if (abs(c[j]/cj-1.0) > epsilon) { ierr++; #ifdef VERBOSE if (ierr < 10) { printf(" array c: index: %ld, expected: %e, observed: %e, relative error: %e\n", j,cj,c[j],abs((cj-c[j])/cAvgErr)); } #endif } } printf(" For array c[], %d errors were found.\n",ierr); } if (err == 0) { printf ("Solution Validates: avg error less than %e on all three arrays\n",epsilon); } #ifdef VERBOSE printf ("Results Validation Verbose Results: \n"); printf (" Expected a(1), b(1), c(1): %f %f %f \n",aj,bj,cj); printf (" Observed a(1), b(1), c(1): %f %f %f \n",a[1],b[1],c[1]); printf (" Rel Errors on a, b, c: %e %e %e \n",abs(aAvgErr/aj),abs(bAvgErr/bj),abs(cAvgErr/cj)); #endif } #ifdef TUNED /* stubs for "tuned" versions of the kernels */ void tuned_STREAM_Copy() { ssize_t j; #pragma omp parallel for for (j=0; j<STREAM_ARRAY_SIZE; j++) c[j] = a[j]; } void tuned_STREAM_Scale(STREAM_TYPE scalar) { ssize_t j; #pragma omp parallel for for (j=0; j<STREAM_ARRAY_SIZE; j++) b[j] = scalar*c[j]; } void tuned_STREAM_Add() { ssize_t j; #pragma omp parallel for for (j=0; j<STREAM_ARRAY_SIZE; j++) c[j] = a[j]+b[j]; } void tuned_STREAM_Triad(STREAM_TYPE scalar) { ssize_t j; #pragma omp parallel for for (j=0; j<STREAM_ARRAY_SIZE; j++) a[j] = b[j]+scalar*c[j]; } /* end of stubs for the "tuned" versions of the kernels */ #endif ++++++ stream.f ++++++ *======================================================================= * Program: STREAM * Programmer: John D. McCalpin * RCS Revision: $Id: stream.f,v 5.6 2005/10/04 00:20:48 mccalpin Exp mccalpin $ *----------------------------------------------------------------------- * Copyright 1991-2003: John D. McCalpin *----------------------------------------------------------------------- * License: * 1. You are free to use this program and/or to redistribute * this program. * 2. You are free to modify this program for your own use, * including commercial use, subject to the publication * restrictions in item 3. * 3. You are free to publish results obtained from running this * program, or from works that you derive from this program, * with the following limitations: * 3a. In order to be referred to as "STREAM benchmark results", * published results must be in conformance to the STREAM * Run Rules, (briefly reviewed below) published at * http://www.cs.virginia.edu/stream/ref.html * and incorporated herein by reference. * As the copyright holder, John McCalpin retains the * right to determine conformity with the Run Rules. * 3b. Results based on modified source code or on runs not in * accordance with the STREAM Run Rules must be clearly * labelled whenever they are published. Examples of * proper labelling include: * "tuned STREAM benchmark results" * "based on a variant of the STREAM benchmark code" * Other comparable, clear and reasonable labelling is * acceptable. * 3c. Submission of results to the STREAM benchmark web site * is encouraged, but not required. * 4. Use of this program or creation of derived works based on this * program constitutes acceptance of these licensing restrictions. * 5. Absolutely no warranty is expressed or implied. *----------------------------------------------------------------------- * This program measures sustained memory transfer rates in MB/s for * simple computational kernels coded in FORTRAN. * * The intent is to demonstrate the extent to which ordinary user * code can exploit the main memory bandwidth of the system under * test. *======================================================================= * The STREAM web page is at: * http://www.streambench.org * * Most of the content is currently hosted at: * http://www.cs.virginia.edu/stream/ * * BRIEF INSTRUCTIONS: * 0) See http://www.cs.virginia.edu/stream/ref.html for details * 1) STREAM requires a timing function called mysecond(). * Several examples are provided in this directory. * "CPU" timers are only allowed for uniprocessor runs. * "Wall-clock" timers are required for all multiprocessor runs. * 2) The STREAM array sizes must be set to size the test. * The value "N" must be chosen so that each of the three * arrays is at least 4x larger than the sum of all the last- * level caches used in the run, or 1 million elements, which- * ever is larger. * ------------------------------------------------------------ * Note that you are free to use any array length and offset * that makes each array 4x larger than the last-level cache. * The intent is to determine the *best* sustainable bandwidth * available with this simple coding. Of course, lower values * are usually fairly easy to obtain on cached machines, but * by keeping the test to the *best* results, the answers are * easier to interpret. * You may put the arrays in common or not, at your discretion. * There is a commented-out COMMON statement below. * Fortran90 "allocatable" arrays are fine, too. * ------------------------------------------------------------ * 3) Compile the code with full optimization. Many compilers * generate unreasonably bad code before the optimizer tightens * things up. If the results are unreasonably good, on the * other hand, the optimizer might be too smart for me * Please let me know if this happens. * 4) Mail the results to [email protected] * Be sure to include: * a) computer hardware model number and software revision * b) the compiler flags * c) all of the output from the test case. * Please let me know if you do not want your name posted along * with the submitted results. * 5) See the web page for more comments about the run rules and * about interpretation of the results. * * Thanks, * Dr. Bandwidth *========================================================================= * PROGRAM stream * IMPLICIT NONE C .. Parameters .. INTEGER n,offset,ndim,ntimes PARAMETER (n=2000000,offset=0,ndim=n+offset,ntimes=10) C .. C .. Local Scalars .. DOUBLE PRECISION scalar,t INTEGER j,k,nbpw,quantum C .. C .. Local Arrays .. DOUBLE PRECISION maxtime(4),mintime(4),avgtime(4), $ times(4,ntimes) INTEGER bytes(4) CHARACTER label(4)*11 C .. C .. External Functions .. DOUBLE PRECISION mysecond INTEGER checktick,realsize EXTERNAL mysecond,checktick,realsize !$ INTEGER omp_get_num_threads !$ EXTERNAL omp_get_num_threads C .. C .. Intrinsic Functions .. C INTRINSIC dble,max,min,nint,sqrt C .. C .. Arrays in Common .. DOUBLE PRECISION a(ndim),b(ndim),c(ndim) C .. C .. Common blocks .. * COMMON a,b,c C .. C .. Data statements .. DATA avgtime/4*0.0D0/,mintime/4*1.0D+36/,maxtime/4*0.0D0/ DATA label/'Copy: ','Scale: ','Add: ', $ 'Triad: '/ DATA bytes/2,2,3,3/ C .. * --- SETUP --- determine precision and check timing --- nbpw = realsize() PRINT *,'----------------------------------------------' PRINT *,'STREAM Version $Revision: 5.6 $' PRINT *,'----------------------------------------------' WRITE (*,FMT=9010) 'Array size = ',n WRITE (*,FMT=9010) 'Offset = ',offset WRITE (*,FMT=9020) 'The total memory requirement is ', $ 3*nbpw*n/ (1024*1024),' MB' WRITE (*,FMT=9030) 'You are running each test ',ntimes,' times' WRITE (*,FMT=9030) '--' WRITE (*,FMT=9030) 'The *best* time for each test is used' WRITE (*,FMT=9030) '*EXCLUDING* the first and last iterations' !$OMP PARALLEL !$OMP MASTER PRINT *,'----------------------------------------------' !$ PRINT *,'Number of Threads = ',OMP_GET_NUM_THREADS() !$OMP END MASTER !$OMP END PARALLEL PRINT *,'----------------------------------------------' !$OMP PARALLEL PRINT *,'Printing one line per active thread....' !$OMP END PARALLEL !$OMP PARALLEL DO DO 10 j = 1,n a(j) = 2.0d0 b(j) = 0.5D0 c(j) = 0.0D0 10 CONTINUE t = mysecond() !$OMP PARALLEL DO DO 20 j = 1,n a(j) = 0.5d0*a(j) 20 CONTINUE t = mysecond() - t PRINT *,'----------------------------------------------------' quantum = checktick() WRITE (*,FMT=9000) $ 'Your clock granularity/precision appears to be ',quantum, $ ' microseconds' PRINT *,'----------------------------------------------------' * --- MAIN LOOP --- repeat test cases NTIMES times --- scalar = 0.5d0*a(1) DO 70 k = 1,ntimes t = mysecond() a(1) = a(1) + t !$OMP PARALLEL DO DO 30 j = 1,n c(j) = a(j) 30 CONTINUE t = mysecond() - t c(n) = c(n) + t times(1,k) = t t = mysecond() c(1) = c(1) + t !$OMP PARALLEL DO DO 40 j = 1,n b(j) = scalar*c(j) 40 CONTINUE t = mysecond() - t b(n) = b(n) + t times(2,k) = t t = mysecond() a(1) = a(1) + t !$OMP PARALLEL DO DO 50 j = 1,n c(j) = a(j) + b(j) 50 CONTINUE t = mysecond() - t c(n) = c(n) + t times(3,k) = t t = mysecond() b(1) = b(1) + t !$OMP PARALLEL DO DO 60 j = 1,n a(j) = b(j) + scalar*c(j) 60 CONTINUE t = mysecond() - t a(n) = a(n) + t times(4,k) = t 70 CONTINUE * --- SUMMARY --- DO 90 k = 2,ntimes DO 80 j = 1,4 avgtime(j) = avgtime(j) + times(j,k) mintime(j) = min(mintime(j),times(j,k)) maxtime(j) = max(maxtime(j),times(j,k)) 80 CONTINUE 90 CONTINUE WRITE (*,FMT=9040) DO 100 j = 1,4 avgtime(j) = avgtime(j)/dble(ntimes-1) WRITE (*,FMT=9050) label(j),n*bytes(j)*nbpw/mintime(j)/1.0D6, $ avgtime(j),mintime(j),maxtime(j) 100 CONTINUE PRINT *,'----------------------------------------------------' CALL checksums (a,b,c,n,ntimes) PRINT *,'----------------------------------------------------' 9000 FORMAT (1x,a,i6,a) 9010 FORMAT (1x,a,i10) 9020 FORMAT (1x,a,i4,a) 9030 FORMAT (1x,a,i3,a,a) 9040 FORMAT ('Function',5x,'Rate (MB/s) Avg time Min time Max time' $ ) 9050 FORMAT (a,4 (f10.4,2x)) END *------------------------------------- * INTEGER FUNCTION dblesize() * * A semi-portable way to determine the precision of DOUBLE PRECISION * in Fortran. * Here used to guess how many bytes of storage a DOUBLE PRECISION * number occupies. * INTEGER FUNCTION realsize() * IMPLICIT NONE C .. Local Scalars .. DOUBLE PRECISION result,test INTEGER j,ndigits C .. C .. Local Arrays .. DOUBLE PRECISION ref(30) C .. C .. External Subroutines .. EXTERNAL confuse C .. C .. Intrinsic Functions .. INTRINSIC abs,acos,log10,sqrt C .. C Test #1 - compare single(1.0d0+delta) to 1.0d0 10 DO 20 j = 1,30 ref(j) = 1.0d0 + 10.0d0** (-j) 20 CONTINUE DO 30 j = 1,30 test = ref(j) ndigits = j CALL confuse(test,result) IF (test.EQ.1.0D0) THEN GO TO 40 END IF 30 CONTINUE GO TO 50 40 WRITE (*,FMT='(a)') $ '----------------------------------------------' WRITE (*,FMT='(1x,a,i2,a)') 'Double precision appears to have ', $ ndigits,' digits of accuracy' IF (ndigits.LE.8) THEN realsize = 4 ELSE realsize = 8 END IF WRITE (*,FMT='(1x,a,i1,a)') 'Assuming ',realsize, $ ' bytes per DOUBLE PRECISION word' WRITE (*,FMT='(a)') $ '----------------------------------------------' RETURN 50 PRINT *,'Hmmmm. I am unable to determine the size.' PRINT *,'Please enter the number of Bytes per DOUBLE PRECISION', $ ' number : ' READ (*,FMT=*) realsize IF (realsize.NE.4 .AND. realsize.NE.8) THEN PRINT *,'Your answer ',realsize,' does not make sense.' PRINT *,'Try again.' PRINT *,'Please enter the number of Bytes per ', $ 'DOUBLE PRECISION number : ' READ (*,FMT=*) realsize END IF PRINT *,'You have manually entered a size of ',realsize, $ ' bytes per DOUBLE PRECISION number' WRITE (*,FMT='(a)') $ '----------------------------------------------' END SUBROUTINE confuse(q,r) * IMPLICIT NONE C .. Scalar Arguments .. DOUBLE PRECISION q,r C .. C .. Intrinsic Functions .. INTRINSIC cos C .. r = cos(q) RETURN END * A semi-portable way to determine the clock granularity * Adapted from a code by John Henning of Digital Equipment Corporation * INTEGER FUNCTION checktick() * IMPLICIT NONE C .. Parameters .. INTEGER n PARAMETER (n=20) C .. C .. Local Scalars .. DOUBLE PRECISION t1,t2 INTEGER i,j,jmin C .. C .. Local Arrays .. DOUBLE PRECISION timesfound(n) C .. C .. External Functions .. DOUBLE PRECISION mysecond EXTERNAL mysecond C .. C .. Intrinsic Functions .. INTRINSIC max,min,nint C .. i = 0 10 t2 = mysecond() IF (t2.EQ.t1) GO TO 10 t1 = t2 i = i + 1 timesfound(i) = t1 IF (i.LT.n) GO TO 10 jmin = 1000000 DO 20 i = 2,n j = nint((timesfound(i)-timesfound(i-1))*1d6) jmin = min(jmin,max(j,0)) 20 CONTINUE IF (jmin.GT.0) THEN checktick = jmin ELSE PRINT *,'Your clock granularity appears to be less ', $ 'than one microsecond' checktick = 1 END IF RETURN * PRINT 14, timesfound(1)*1d6 * DO 20 i=2,n * PRINT 14, timesfound(i)*1d6, * & nint((timesfound(i)-timesfound(i-1))*1d6) * 14 FORMAT (1X, F18.4, 1X, i8) * 20 CONTINUE END SUBROUTINE checksums(a,b,c,n,ntimes) * IMPLICIT NONE C .. C .. Arguments .. DOUBLE PRECISION a(*),b(*),c(*) INTEGER n,ntimes C .. C .. Local Scalars .. DOUBLE PRECISION aa,bb,cc,scalar,suma,sumb,sumc,epsilon INTEGER k C .. C Repeat the main loop, but with scalars only. C This is done to check the sum & make sure all C iterations have been executed correctly. aa = 2.0D0 bb = 0.5D0 cc = 0.0D0 aa = 0.5D0*aa scalar = 0.5d0*aa DO k = 1,ntimes cc = aa bb = scalar*cc cc = aa + bb aa = bb + scalar*cc END DO aa = aa*DBLE(n-2) bb = bb*DBLE(n-2) cc = cc*DBLE(n-2) C Now sum up the arrays, excluding the first and last C elements, which are modified using the timing results C to confuse aggressive optimizers. suma = 0.0d0 sumb = 0.0d0 sumc = 0.0d0 !$OMP PARALLEL DO REDUCTION(+:suma,sumb,sumc) DO 110 j = 2,n-1 suma = suma + a(j) sumb = sumb + b(j) sumc = sumc + c(j) 110 CONTINUE epsilon = 1.D-6 IF (ABS(suma-aa)/suma .GT. epsilon) THEN PRINT *,'Failed Validation on array a()' PRINT *,'Target Sum of a is = ',aa PRINT *,'Computed Sum of a is = ',suma ELSEIF (ABS(sumb-bb)/sumb .GT. epsilon) THEN PRINT *,'Failed Validation on array b()' PRINT *,'Target Sum of b is = ',bb PRINT *,'Computed Sum of b is = ',sumb ELSEIF (ABS(sumc-cc)/sumc .GT. epsilon) THEN PRINT *,'Failed Validation on array c()' PRINT *,'Target Sum of c is = ',cc PRINT *,'Computed Sum of c is = ',sumc ELSE PRINT *,'Solution Validates!' ENDIF END
