// =============================================================================================
// Chapel implementation of the STREAM benchmark. 
//
// This implementation is uses Chapels' data parallel model.
//
// This source informed by the "official" version from McCalpin as well as that distributed
// with the Chapel compiler, version 0.5. 
//
// Here are the intructions from the McCalpin version:
//
//    1) Stream requires a good bit of memory to run.  Adjust the
//       value of 'N' (below) to give a 'timing calibration' of
//       at least 20 clock-ticks.  This will provide rate estimates
//       that should be good to about 5% precision.
//
// Note that variables qualified with 'config' may be changed at runtime,
// by executing as "a.out --<name>=<value>". 
// Also note that ./a.out --help lists this and other information.
// =============================================================================================

use
   Time,
   Types,
   stream_params,    // Problem parameters defined.
   utils;            // Various utilities routines.

def main ( ) {

   var 
      A, B, C                           // Data arrays.
         : [ArrayShape] elemType;

   var
      t0      : real,                  // Timer var.
      Answers : [1..NumTests] bool,    // Accumulated answers.
      Perf    : [1..NumTests] real,    // Aggregate performance for easy writing. 
      Times   : [1..NumIter] real;     // Time per iterations. 

   // ---------------------
   // Executable Statements 
   // ---------------------

   ReportHeader ( );
   
   InitializeArrays ( B, C );
   
   // ================================ Copy:  A ( I ) = B ( I )  ===============================

   for iter in 1..NumIter
      {  
         t0 = getCurrentTime ( );
         
         A = B;
         
         Times ( iter ) = getCurrentTime ( ) - t0;
      }
   
   Answers ( 1 ) = CheckAnswer ( "COPY", A, B, C );
   
   Perf ( 1 ) = ReportResults ( "COPY", Answers ( 1 ), Times );

   // =========================== Scale: A ( I ) = alpha * B ( I )  ============================

   for iter in 1..NumIter
      {
         t0 = getCurrentTime ( );

         A = alpha * B;

         Times ( iter ) = getCurrentTime ( ) - t0;
      }
   
   Answers ( 2 ) = CheckAnswer ( "SCALE", A, B, C );
   
   Perf ( 2 ) = ReportResults ( "SCALE", Answers ( 2 ), Times );

   // ============================= <<: A ( I ) = B ( I ) << alpha  ============================

   for iter in 1..NumIter
      {
         t0 = getCurrentTime ( );

         A = B << alpha;
         
         Times ( iter ) = getCurrentTime ( ) - t0;
      }
   
   Answers ( 3 ) = CheckAnswer ( "<<", A, B, C );
   
   Perf ( 3 ) = ReportResults ( "<<", Answers ( 3 ), Times );
 
   // ============================ Sum:   A ( I ) = B ( I ) + C ( I )  =========================

     for iter in 1..NumIter
      {  
         t0 = getCurrentTime ( );
         
         A = B + C;
         
         Times ( iter ) = getCurrentTime ( ) - t0;
      }

   Answers ( 4 ) = CheckAnswer ( "SUM", A, B, C );

   Perf ( 4 ) = ReportResults ( "SUM", Answers ( 4 ), Times );

   // ======================= Triad: A ( I ) = B ( I ) + alpha * C ( I )  ======================

   for iter in 1..NumIter
      {
         t0 = getCurrentTime ( );

         A = B + alpha * C;

         Times ( iter ) = getCurrentTime ( ) - t0;
      }

   Answers ( 5 ) = CheckAnswer ( "TRIAD", A, B, C );

   Perf ( 5 ) = ReportResults ( "TRIAD", Answers ( 5 ), Times );

   // ====================================== Write footer ======================================

   ReportFooter ( Answers, Perf );

} // ========================================= End main ========================================