Rename as the HI64 System Benchmark

As I plan to make major improvements to the code, I am now calling the program the HI64 System Benchmark (Hierarchical Integration 64-Bit) to avoid legal problems caused by the use of the "HINT" trademark. Although I have updated the startup banner to reflect the new name, I intend to continue to attribute the original authors. The version number has been reset to 0.1.0 and a change log has been added. Old files not applicable to this version have been moved to a new subdirectory "old-files".
bwDraco · Oct 1, 2014 · 7f096b1 · 7f096b1
1 parent 0b22bb9
commit 7f096b1
Show file tree

Hide file tree

Showing 13 changed files with 111 additions and 54 deletions.
diff --git a/README.md b/README.md
@@ -1,18 +1,18 @@
-# The HINT Performance Analyzer – 64-Bit Port
+# The HI64 System Benchmark
 
-This is a 64-bit port of the [HINT (Hierarchical INTegration) benchmark][1], originally developed at the Ames Laboratory at the U.S. Department of Energy. It has been modified to take full advantage of modern 64-bit computer systems. This benchmark is unique in that it is designed as a holistic assessment of system performance, including the CPU, caches, main memory, and storage.
+The HI64 System Benchmark (Hierarchical Integration 64-Bit) is a benchmarking tool derived from [HINT][1], originally developed at the Ames Laboratory at the U.S. Department of Energy. It has been modified to take full advantage of modern 64-bit computer systems. This benchmark is designed as a holistic assessment of system performance, including the CPU, caches, main memory, and storage.
 
 ## How it works
 
-HINT assesses system performance by computing the upper and lower bounds of the function `(1/x)/(1+x)` within the interval [0, 1] by dividing the region into many subintervals, using only the fact that the function is always decreasing. The program stores the data for each subinterval in an array called `rect`. The error of this computation is determined by summing for each interval the difference between the upper and lower bounds multiplied by the width of the interval. The reciprocal of the error represents the precision of the computation, referred to as **quality**.
+HI64, like its predecessor, assesses system performance by computing the upper and lower bounds of the function `(1/x)/(1+x)` within the interval [0, 1] by dividing the region into many subintervals, using only the fact that the function is always decreasing. The program stores the data for each subinterval in an array called `rect`. The error of this computation is determined by summing for each interval the difference between the upper and lower bounds multiplied by the width of the interval. The reciprocal of the error represents the precision of the computation, referred to as **quality**.
 
-The benchmark consists of a series of trials, each of which consists of a number of runs of the above computation using a certain number of subintervals. Each subsequent trial uses more subintervals, increasing the precision of the result along with the amount of CPU time and memory required. For each trial, HINT keeps track of the amount of time and memory required to complete the computation, as well as the quality of the result and other information. Based on this information, a value called **quality improvements per second** (**QUIPS**) is computed, representing the computer's performance for that trial. The QUIPS attained by a computer over time as the benchmark progresses can be used for in-depth assessment of the performance characteristics of the system.
+The benchmark consists of a series of trials, each of which consists of a number of runs of the above computation using a certain number of subintervals. Each subsequent trial uses more subintervals, increasing the precision of the result along with the amount of CPU time and memory required. For each trial, the program keeps track of the amount of time and memory required to complete the computation, as well as the quality of the result and other information. Based on this information, a value called **quality improvements per second** (**QUIPS**) is computed, representing the computer's performance for that trial. The QUIPS attained by a computer over time as the benchmark progresses can be used for in-depth assessment of the performance characteristics of the system.
 
 The benchmark runs continuously until a substantial drop in performance occurs. This typically occurs when the computer runs out of main memory and resorts to disk paging to complete the computation, resulting in a dramatic slowdown and an attendant drop in QUIPS. Specifically, the benchmark stops when the QUIPS for the previous trial drops belows a predefined ratio of the peak QUIPS attained during the benchmark or when the slowest run in a trial takes longer than a predefined amount of time. (More details on how to set these limits follow.)
 
 ## Configuration
 
-Settings for HINT are defined at build time, through a combination of compiler options and macros defined in `hint.h`.
+Settings for HI64 are defined at build time, through a combination of compiler options and macros defined in `hint.h`.
 
 *TODO*: Add configuration information for each item 
 
@@ -22,7 +22,7 @@ Settings for HINT are defined at build time, through a combination of compiler o
 
 ## More information
 
-More details can be found in the original README.txt file inside the "serial" directory. This file will be updated with more technical information as the project progresses.
+More details can be found in the README.original.txt file inside the "serial" directory. This file will be updated with more technical information as the project progresses.
 
 
   [1]: http://hint.byu.edu/ 
diff --git a/serial/CHANGES.md b/serial/CHANGES.md
@@ -0,0 +1,5 @@
+# Change log for the HI64 System Benchmark
+
+## 0.1.0 (October 1, 2014)
+
+First release under the HI64 name.
diff --git a/serial/README.md b/serial/README.md
@@ -0,0 +1,28 @@
+# The HINT Performance Analyzer – 64-Bit Port
+
+This is a 64-bit port of the [HINT (Hierarchical INTegration) benchmark][1], originally developed at the Ames Laboratory at the U.S. Department of Energy. It has been modified to take full advantage of modern 64-bit computer systems. This benchmark is unique in that it is designed as a holistic assessment of system performance, including the CPU, caches, main memory, and storage.
+
+## How it works
+
+HINT assesses system performance by computing the upper and lower bounds of the function `(1/x)/(1+x)` within the interval [0, 1] by dividing the region into many subintervals, using only the fact that the function is always decreasing. The program stores the data for each subinterval in an array called `rect`. The error of this computation is determined by summing for each interval the difference between the upper and lower bounds multiplied by the width of the interval. The reciprocal of the error represents the precision of the computation, referred to as **quality**.
+
+The benchmark consists of a series of trials, each of which consists of a number of runs of the above computation using a certain number of subintervals. Each subsequent trial uses more subintervals, increasing the precision of the result along with the amount of CPU time and memory required. For each trial, HINT keeps track of the amount of time and memory required to complete the computation, as well as the quality of the result and other information. Based on this information, a value called **quality improvements per second** (**QUIPS**) is computed, representing the computer's performance for that trial. The QUIPS attained by a computer over time as the benchmark progresses can be used for in-depth assessment of the performance characteristics of the system.
+
+The benchmark runs continuously until a substantial drop in performance occurs. This typically occurs when the computer runs out of main memory and resorts to disk paging to complete the computation, resulting in a dramatic slowdown and an attendant drop in QUIPS. Specifically, the benchmark stops when the QUIPS for the previous trial drops belows a predefined ratio of the peak QUIPS attained during the benchmark or when the slowest run in a trial takes longer than a predefined amount of time. (More details on how to set these limits follow.)
+
+## Configuration
+
+Settings for HINT are defined at build time, through a combination of compiler options and macros defined in `hint.h`.
+
+*TODO*: Add configuration information for each item 
+
+## Interpreting output
+
+*TODO*
+
+## More information
+
+More details can be found in the original README.txt file inside the "serial" directory. This file will be updated with more technical information as the project progresses.
+
+
+  [1]: http://hint.byu.edu/ 
diff --git a/serial/hint.c → serial/hi64.c b/serial/hint.c → serial/hi64.c
@@ -1,8 +1,10 @@
 /******************************************************************************/
-/* "HINT" -- Hierarchical INTegration.                                        */
-/* Copyright (C) 1994 by Iowa State University Research Foundation, Inc.      */
-/* Modified 2003 by Moritz Franosch ([email protected])                       */
-/* Further modified 2014 by Brian "DragonLord" Wong                           */
+/* HI64 System Benchmark                                                      */
+/* 64-bit benchmark derived from Hierarchical INTegration (HINT)              */
+/* Originally developed at Ames Laboratory, U.S. Department of Energy         */
+/* Portions Copyright (C) 1994 Iowa State University Research Foundation, Inc.*/
+/* Portions Copyright (C) 2003 by Moritz Franosch                             */
+/* Portions Copyright (C) 2014 by Brian "DragonLord" Wong                     */
 /*                                                                            */
 /* This program is free software; you can redistribute it and/or modify       */
 /* it under the terms of the GNU General Public License as published by       */
@@ -11,15 +13,15 @@
 /* Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.    */
 /*                                                                            */
 /* Files needed for use:                                                      */
-/*     * hint.c             ---- Driver source                                */
-/*     * hkernel.c          ---- Kernel source                                */
-/*     * hint.h             ---- General include file                         */
-/*     * typedefs.h         ---- Include file for DSIZE and ISIZE             */
-/*     * README             ---- These are the rules. Follow them!!!          */
+/*     * hi64.c            ---- Driver source                                 */
+/*     * hkernel.c         ---- Kernel source                                 */
+/*     * hi64.h            ---- General include file                          */
+/*     * typedefs.h        ---- Include file for DSIZE and ISIZE              */
+/*     * README.md         ---- Benchmark documentation and usage information */
 /******************************************************************************/
 
-/* Refer to hint.h and typedefs.h for all-capitalized definitions.            */
-#include       "hint.h"    
+/* Refer to hi64.h and typedefs.h for all-capitalized definitions.            */
+#include       "hi64.h"    
 
 int main(int argc, char *argv[])
 {
@@ -71,18 +73,20 @@ int main(int argc, char *argv[])
 
     char*   suffix;       /* Suffix for data.suffix directory                 */
 
-    printf("\n*** The  HINT  PERFORMANCE ANALYZER ***\n");
-    printf("        Version 1.0  June 1994\n");
-    printf("   John L. Gustafson & Quinn O. Snell\n");
-    printf("     Scalable Computing Laboratory\n");
-    printf("         Iowa State University\n\n");
-    printf("Copyright (C) 1994");
+    printf("\nHI64 System Benchmark, Version 0.1.0 (October 1, 2014)\n");
+    printf("Derived from HINT originally developed by");
+    printf(" John L. Gustafson & Quinn O. Snell,\n");
+    printf("Scalable Computing Laboratory, Iowa State University\n\n");
+    printf("Portions Copyright (C) 1994");
     printf(" Iowa State University Research Foundation, Inc.\n");
     printf("Portions Copyright (C) 2003 Moritz Franosch\n");
-    printf("Portions Copyright (C) 2014 Brian \"DragonLord\" Wong\n");
-    printf("Updated for use with 64-bit systems - ");
-    printf("see README.txt for usage information\n");
-    printf("________________________________________________________\n");
+    printf("Portions Copyright (C) 2014 Brian \"DragonLord\" Wong\n\n");
+    printf("This program is licensed under the GNU GPL; see COPYING.txt.\n");
+    printf("NO WARRANTY OF ANY KIND IS PROVIDED, including any implied");
+    printf(" warranty of\nmerchantability or fitness for a particular");
+    printf(" purpose.\n\n");
+    printf("See README.md for usage and technical information.\n");
+    printf("---------------------------------------------------------\n");
 	printf("RECT is %d bytes\n",sizeof(RECT));
 
 #ifdef DEBUG

diff --git a/serial/hint.h → serial/hi64.h b/serial/hint.h → serial/hi64.h
@@ -1,16 +1,23 @@
 /******************************************************************************/
-/* "HINT" -- Hierarchical INTegration.                                        */
-/* Copyright (C) 1994 by Iowa State University Research Foundation, Inc.      */
-/* Modified 2003 by Moritz Franosch ([email protected])                       */
-/* Further modified 2014 by Brian "DragonLord" Wong                           */
-/* Licensed under the GNU General Public License (any version)                */
+/* HI64 System Benchmark                                                      */
+/* 64-bit benchmark derived from Hierarchical INTegration (HINT)              */
+/* Originally developed at Ames Laboratory, U.S. Department of Energy         */
+/* Portions Copyright (C) 1994 Iowa State University Research Foundation, Inc.*/
+/* Portions Copyright (C) 2003 by Moritz Franosch                             */
+/* Portions Copyright (C) 2014 by Brian "DragonLord" Wong                     */
+/*                                                                            */
+/* This program is free software; you can redistribute it and/or modify       */
+/* it under the terms of the GNU General Public License as published by       */
+/* the Free Software Foundation.  You should have received a copy of the      */
+/* GNU General Public License along with this program; if not, write to the   */
+/* Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.    */
 /*                                                                            */
 /* Files needed for use:                                                      */
-/*     * hint.c             ---- Driver source                                */
-/*     * hkernel.c          ---- Kernel source                                */
-/*     * hint.h             ---- General include file                         */
-/*     * typedefs.h         ---- Include file for DSIZE and ISIZE             */
-/*     * README             ---- These are the rules. Follow them!!!          */
+/*     * hi64.c            ---- Driver source                                 */
+/*     * hkernel.c         ---- Kernel source                                 */
+/*     * hi64.h            ---- General include file                          */
+/*     * typedefs.h        ---- Include file for DSIZE and ISIZE              */
+/*     * README.md         ---- Benchmark documentation and usage information */
 /******************************************************************************/
 
 #include       <stdio.h>
@@ -75,7 +82,6 @@
 
 /******************************************************************************/
 /*      Adjustable Defines                                                    */
-/*      These may be adjusted according to the HINT rules.                    */
 /******************************************************************************/
 #define ADVANCE    1.2589  /* Multiplier. We use roughly 1 decibel step size. */
                            /* Closer to 1.0 takes longer to run, but might    */
@@ -97,7 +103,7 @@
 #define MXPROC     32      /* Maximum number of processors to use in shared   */                           /* memory configuration. Adjust as necessary.      */
 
 /******************************************************************************/
-/*      Non - Adjustable Defines                                              */
+/*      Non-Adjustable Defines                                              */
 /******************************************************************************/
 #define DSREFS     90
 #define ISREFS     10

diff --git a/serial/hkernel.c b/serial/hkernel.c
@@ -1,6 +1,10 @@
 /******************************************************************************/
-/* "HINT" -- Hierarchical INTegration.                                        */
-/* Copyright (C) 1994 by Iowa State University Research Foundation, Inc.      */
+/* HI64 System Benchmark                                                      */
+/* 64-bit benchmark derived from Hierarchical INTegration (HINT)              */
+/* Originally developed at Ames Laboratory, U.S. Department of Energy         */
+/* Portions Copyright (C) 1994 Iowa State University Research Foundation, Inc.*/
+/* Portions Copyright (C) 2003 by Moritz Franosch                             */
+/* Portions Copyright (C) 2014 by Brian "DragonLord" Wong                     */
 /*                                                                            */
 /* This program is free software; you can redistribute it and/or modify       */
 /* it under the terms of the GNU General Public License as published by       */
@@ -9,14 +13,14 @@
 /* Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.    */
 /*                                                                            */
 /* Files needed for use:                                                      */
-/*     * hint.c             ---- Driver source                                */
-/*     * hkernel.c          ---- Kernel source                                */
-/*     * hint.h             ---- General include file                         */
-/*     * typedefs.h         ---- Include file for DSIZE and ISIZE             */
-/*     * README             ---- These are the rules. Follow them!!!          */
+/*     * hi64.c            ---- Driver source                                 */
+/*     * hkernel.c         ---- Kernel source                                 */
+/*     * hi64.h            ---- General include file                          */
+/*     * typedefs.h        ---- Include file for DSIZE and ISIZE              */
+/*     * README.md         ---- Benchmark documentation and usage information */
 /******************************************************************************/
 
-#include "hint.h"
+#include "hi64.h"
 
 DSIZE
 Hint(DSIZE *scx, DSIZE *scy, DSIZE *dmax, ISIZE *mcnt, RECT *rect, 

diff --git a/serial/Makefile → serial/old-files/Makefile b/serial/Makefile → serial/old-files/Makefile
diff --git a/serial/Makefile.sgi → serial/old-files/Makefile.sgi b/serial/Makefile.sgi → serial/old-files/Makefile.sgi
diff --git a/serial/Makefile.sun → serial/old-files/Makefile.sun b/serial/Makefile.sun → serial/old-files/Makefile.sun
diff --git a/serial/README.txt → serial/old-files/README b/serial/README.txt → serial/old-files/README
diff --git a/serial/run.pl → serial/old-files/run.pl b/serial/run.pl → serial/old-files/run.pl
diff --git a/serial/run.sh → serial/old-files/run.sh b/serial/run.sh → serial/old-files/run.sh