Correctness Checking

docs/sphinx/dev_guide/kernel_class_impl.rst

@@ -52,12 +52,24 @@ The methods in the source file are:
         so these methods are used to describe this.
       * The number of bytes read and written and the number of floating point
         operations (FLOPS) performed for each kernel execution.
-      * The consistency of the checksums of the kernel. The possible values are
-        ``Consistent`` where all the variant tunings always get the same checksum,
-        ``ConsistentPerVariantTuning`` where an individual variant tuning always
-        gets the same checksum but different variant tunings may differ
-        slightly, and ``Inconsistent`` where the checksum of a variant tuning
-        may vary slightly run to run.
+      * The consistency of the checksums of the kernel. If the kernel
+        always produces the same checksum value for all variant tunings then the
+        checksums are ``Consistent``. Most kernels get a different but consistent
+        checksum for each variant tuning so the checksums are
+        ``ConsistentPerVariantTuning``. On the other hand, some kernels have
+        variant tunings that get different checksums on each run of that variant
+        tuning, for example due to the ordering of floating-point atomic add
+        operations, so the checksums are ``Inconsistent``.
+      * The tolerance of the checksums of the kernel. A number of predefined
+        values are available in the ``KernelBase\:\:ChecksumTolerance`` class. If
+        the kernel consistently produces the same checksums then ``zero`` tolerance
+        is used. Most kernels use the ``normal`` tolerance. Some kernels are very
+        simple, for example they have a single floating-point operation per
+        iteration, so they use the ``tight`` tolerance.
+      * The scale factor to use with the checksums of the kernel. This is an
+        arbitrary multiplier on the checksum values used to scale the checksums
+        to a desired range. Mostly used for kernels with floating-point
+        operation complexity that does not scale linearly with problem size.
       * The operational complexity of the kernel.
       * Which RAJA features the kernel exercises.
       * Adding Suite variants and tunings via ``addVariantTunings``. This calls

src/algorithm/ATOMIC.cpp

@@ -34,6 +34,7 @@ ATOMIC::ATOMIC(const RunParams& params)
   setFLOPsPerRep(getActualProblemSize());
 
   setChecksumConsistency(ChecksumConsistency::Inconsistent); // atomics
+  setChecksumTolerance(ChecksumTolerance::normal);
 
   setComplexity(Complexity::N);
 

src/algorithm/HISTOGRAM.cpp

@@ -41,6 +41,7 @@ HISTOGRAM::HISTOGRAM(const RunParams& params)
   setFLOPsPerRep( (std::is_floating_point_v<Data_type> ? 1 : 0) * getActualProblemSize() );
 
   setChecksumConsistency(ChecksumConsistency::Consistent); // integer arithmetic
+  setChecksumTolerance(ChecksumTolerance::zero);
 
   setComplexity(Complexity::N);
 

src/algorithm/MEMCPY.cpp

@@ -34,6 +34,7 @@ MEMCPY::MEMCPY(const RunParams& params)
   setFLOPsPerRep(0);
 
   setChecksumConsistency(ChecksumConsistency::Consistent);
+  setChecksumTolerance(ChecksumTolerance::zero);
 
   setComplexity(Complexity::N);
 

src/algorithm/MEMSET.cpp

@@ -34,6 +34,7 @@ MEMSET::MEMSET(const RunParams& params)
   setFLOPsPerRep(0);
 
   setChecksumConsistency(ChecksumConsistency::Consistent);
+  setChecksumTolerance(ChecksumTolerance::zero);
 
   setComplexity(Complexity::N);
 

src/algorithm/REDUCE_SUM.cpp

@@ -34,6 +34,7 @@ REDUCE_SUM::REDUCE_SUM(const RunParams& params)
   setFLOPsPerRep(getActualProblemSize());
 
   setChecksumConsistency(ChecksumConsistency::Inconsistent); // Reduction may use atomics
+  setChecksumTolerance(ChecksumTolerance::normal);
 
   setComplexity(Complexity::N);
 

src/algorithm/SCAN.cpp

@@ -33,12 +33,12 @@ SCAN::SCAN(const RunParams& params)
   setBytesAtomicModifyWrittenPerRep( 0 );
   setFLOPsPerRep(1 * getActualProblemSize());
 
-  checksum_scale_factor = 1e-2 *
+  setChecksumConsistency(ChecksumConsistency::Inconsistent); // could depend on scheduling, this may be overly conservative
+  setChecksumTolerance(ChecksumTolerance::normal);
+  setChecksumScaleFactor(1e-2 *
                  ( static_cast<Checksum_type>(getDefaultProblemSize()) /
                                               getActualProblemSize() ) /
-                 getActualProblemSize();
-
-  setChecksumConsistency(ChecksumConsistency::Inconsistent); // could depend on scheduling, this may be overly conservative
+                 getActualProblemSize());
 
   setComplexity(Complexity::N);
 
@@ -59,7 +59,7 @@ void SCAN::setUp(VariantID vid, size_t RAJAPERF_UNUSED_ARG(tune_idx))
 
 void SCAN::updateChecksum(VariantID vid, size_t tune_idx)
 {
-  checksum[vid][tune_idx] += calcChecksum(m_y, getActualProblemSize(), checksum_scale_factor, vid);
+  checksum[vid][tune_idx] += calcChecksum(m_y, getActualProblemSize(), vid);
 }
 
 void SCAN::tearDown(VariantID vid, size_t RAJAPERF_UNUSED_ARG(tune_idx))

src/algorithm/SORT.cpp

@@ -33,7 +33,8 @@ SORT::SORT(const RunParams& params)
   setBytesAtomicModifyWrittenPerRep( 0 );
   setFLOPsPerRep(0);
 
-  setChecksumConsistency(ChecksumConsistency::Consistent); //  // sort is not stable but values are equal if equivalent
+  setChecksumConsistency(ChecksumConsistency::Consistent); // sort is not stable but values are equal if equivalent
+  setChecksumTolerance(ChecksumTolerance::zero);
 
   setComplexity(Complexity::N_logN);
 

src/algorithm/SORTPAIRS.cpp

@@ -34,6 +34,7 @@ SORTPAIRS::SORTPAIRS(const RunParams& params)
   setFLOPsPerRep(0);
 
   setChecksumConsistency(ChecksumConsistency::Inconsistent); // sort is not stable and could depend on scheduling
+  setChecksumTolerance(ChecksumTolerance::normal);
 
   setComplexity(Complexity::N_logN);
 

src/apps/CONVECTION3DPA.cpp

@@ -52,6 +52,7 @@ CONVECTION3DPA::CONVECTION3DPA(const RunParams& params)
                          ));
 
   setChecksumConsistency(ChecksumConsistency::ConsistentPerVariantTuning);
+  setChecksumTolerance(ChecksumTolerance::normal);
 
   setComplexity(Complexity::N);
 

src/apps/DEL_DOT_VEC_2D.cpp

@@ -44,6 +44,7 @@ DEL_DOT_VEC_2D::DEL_DOT_VEC_2D(const RunParams& params)
   setFLOPsPerRep(54 * m_domain->n_real_zones);
 
   setChecksumConsistency(ChecksumConsistency::ConsistentPerVariantTuning);
+  setChecksumTolerance(ChecksumTolerance::normal);
 
   setComplexity(Complexity::N);
 

src/apps/DIFFUSION3DPA.cpp

@@ -53,6 +53,7 @@ DIFFUSION3DPA::DIFFUSION3DPA(const RunParams& params)
                          3 * DPA_D1D * DPA_D1D * DPA_D1D));
 
   setChecksumConsistency(ChecksumConsistency::ConsistentPerVariantTuning);
+  setChecksumTolerance(ChecksumTolerance::normal);
 
   setComplexity(Complexity::N);
 

src/apps/EDGE3D.cpp

@@ -58,11 +58,11 @@ EDGE3D::EDGE3D(const RunParams& params)
 
   setFLOPsPerRep(number_of_elements * flops_per_element);
 
-  m_checksum_scale_factor = 0.001 *
-              ( static_cast<Checksum_type>(getDefaultProblemSize()) /
-                                           getActualProblemSize() );
-
   setChecksumConsistency(ChecksumConsistency::ConsistentPerVariantTuning);
+  setChecksumTolerance(ChecksumTolerance::normal);
+  setChecksumScaleFactor(0.001 *
+              ( static_cast<Checksum_type>(getDefaultProblemSize()) /
+                                           getActualProblemSize() ));
 
   setComplexity(Complexity::N);
 
@@ -92,7 +92,7 @@ void EDGE3D::setUp(VariantID vid, size_t RAJAPERF_UNUSED_ARG(tune_idx))
 
 void EDGE3D::updateChecksum(VariantID vid, size_t tune_idx)
 {
-  checksum[vid][tune_idx] += calcChecksum(m_sum, m_array_length, m_checksum_scale_factor, vid  );
+  checksum[vid][tune_idx] += calcChecksum(m_sum, m_array_length, vid  );
 }
 
 void EDGE3D::tearDown(VariantID vid, size_t RAJAPERF_UNUSED_ARG(tune_idx))

src/apps/EDGE3D.hpp

@@ -441,8 +441,6 @@ class EDGE3D : public KernelBase
 
   ADomain* m_domain;
   Index_type m_array_length;
-
-  Real_type m_checksum_scale_factor;
 };
 
 } // end namespace apps

src/apps/ENERGY.cpp

@@ -54,6 +54,7 @@ ENERGY::ENERGY(const RunParams& params)
                   ) * getActualProblemSize());
 
   setChecksumConsistency(ChecksumConsistency::ConsistentPerVariantTuning);
+  setChecksumTolerance(ChecksumTolerance::normal);
 
   setComplexity(Complexity::N);
 

src/apps/FEMSWEEP.cpp

@@ -65,9 +65,9 @@ FEMSWEEP::FEMSWEEP(const RunParams& params)
                   m_ne * m_na * m_ng );           // for all elements, angles, and groups
 
   // The checksum is inaccurate starting at the 10's digit for: AMD CPU and older clang versions on NVIDIA GPUs.
-  checksum_scale_factor = 0.0000000001;
-
   setChecksumConsistency(ChecksumConsistency::ConsistentPerVariantTuning);
+  setChecksumTolerance(ChecksumTolerance::normal);
+  setChecksumScaleFactor(0.0000000001);
 
   setComplexity(Complexity::N);
 
@@ -106,7 +106,7 @@ void FEMSWEEP::setUp(VariantID vid, size_t RAJAPERF_UNUSED_ARG(tune_idx))
 
 void FEMSWEEP::updateChecksum(VariantID vid, size_t tune_idx)
 {
-  checksum[vid][tune_idx] += calcChecksum(m_Xdat, m_Xlen, checksum_scale_factor , vid);
+  checksum[vid][tune_idx] += calcChecksum(m_Xdat, m_Xlen, vid);
 }
 
 void FEMSWEEP::tearDown(VariantID vid, size_t RAJAPERF_UNUSED_ARG(tune_idx))

src/apps/FIR.cpp

@@ -36,11 +36,11 @@ FIR::FIR(const RunParams& params)
   setBytesAtomicModifyWrittenPerRep( 0 );
   setFLOPsPerRep((2 * m_coefflen) * getActualProblemSize());
 
-  checksum_scale_factor = 0.0001 *
-              ( static_cast<Checksum_type>(getDefaultProblemSize()) /
-                                           getActualProblemSize() );
-
   setChecksumConsistency(ChecksumConsistency::ConsistentPerVariantTuning);
+  setChecksumTolerance(ChecksumTolerance::normal);
+  setChecksumScaleFactor(0.0001 *
+              ( static_cast<Checksum_type>(getDefaultProblemSize()) /
+                                           getActualProblemSize() ));
 
   setComplexity(Complexity::N);
 
@@ -61,7 +61,7 @@ void FIR::setUp(VariantID vid, size_t RAJAPERF_UNUSED_ARG(tune_idx))
 
 void FIR::updateChecksum(VariantID vid, size_t tune_idx)
 {
-  checksum[vid][tune_idx] += calcChecksum(m_out, getActualProblemSize(), checksum_scale_factor , vid);
+  checksum[vid][tune_idx] += calcChecksum(m_out, getActualProblemSize(), vid);
 }
 
 void FIR::tearDown(VariantID vid, size_t RAJAPERF_UNUSED_ARG(tune_idx))

src/apps/INTSC_HEXHEX.cpp

@@ -73,6 +73,7 @@ INTSC_HEXHEX::INTSC_HEXHEX(const RunParams& params)
   setFLOPsPerRep(n_std_intsc * flops_per_intsc);
 
   setChecksumConsistency(ChecksumConsistency::ConsistentPerVariantTuning);
+  setChecksumTolerance(ChecksumTolerance::normal);
 
   setComplexity(Complexity::N);
 

src/apps/INTSC_HEXRECT.cpp

@@ -81,6 +81,7 @@ INTSC_HEXRECT::INTSC_HEXRECT(const RunParams& params)
   setFLOPsPerRep(n_intsc * flops_per_intsc);
 
   setChecksumConsistency(ChecksumConsistency::ConsistentPerVariantTuning);
+  setChecksumTolerance(ChecksumTolerance::normal);
 
   setComplexity(Complexity::N);
 

src/apps/LTIMES.cpp

@@ -49,11 +49,11 @@ LTIMES::LTIMES(const RunParams& params)
   setBytesAtomicModifyWrittenPerRep( 0 );
   setFLOPsPerRep(2 * m_num_z * m_num_g * m_num_m * m_num_d);
 
-  checksum_scale_factor = 0.001 *
-              ( static_cast<Checksum_type>(getDefaultProblemSize()) /
-                                           getActualProblemSize() );
-
   setChecksumConsistency(ChecksumConsistency::ConsistentPerVariantTuning); // Change to Inconsistent if internal reductions use atomics
+  setChecksumTolerance(ChecksumTolerance::normal);
+  setChecksumScaleFactor(0.001 *
+              ( static_cast<Checksum_type>(getDefaultProblemSize()) /
+                                           getActualProblemSize() ));
 
   setComplexity(Complexity::N);
 
@@ -77,7 +77,7 @@ void LTIMES::setUp(VariantID vid, size_t RAJAPERF_UNUSED_ARG(tune_idx))
 
 void LTIMES::updateChecksum(VariantID vid, size_t tune_idx)
 {
-  checksum[vid][tune_idx] += calcChecksum(m_phidat, m_philen, checksum_scale_factor , vid);
+  checksum[vid][tune_idx] += calcChecksum(m_phidat, m_philen, vid);
 }
 
 void LTIMES::tearDown(VariantID vid, size_t RAJAPERF_UNUSED_ARG(tune_idx))

src/apps/LTIMES_NOVIEW.cpp

@@ -49,11 +49,11 @@ LTIMES_NOVIEW::LTIMES_NOVIEW(const RunParams& params)
   setBytesAtomicModifyWrittenPerRep( 0 );
   setFLOPsPerRep(2 * m_num_z * m_num_g * m_num_m * m_num_d);
 
-  checksum_scale_factor = 0.001 *
-              ( static_cast<Checksum_type>(getDefaultProblemSize()) /
-                                           getActualProblemSize() );
-
   setChecksumConsistency(ChecksumConsistency::ConsistentPerVariantTuning); // Change to Inconsistent if internal reductions use atomics
+  setChecksumTolerance(ChecksumTolerance::normal);
+  setChecksumScaleFactor(0.001 *
+              ( static_cast<Checksum_type>(getDefaultProblemSize()) /
+                                           getActualProblemSize() ));
 
   setComplexity(Complexity::N);
 
@@ -76,7 +76,7 @@ void LTIMES_NOVIEW::setUp(VariantID vid, size_t RAJAPERF_UNUSED_ARG(tune_idx))
 
 void LTIMES_NOVIEW::updateChecksum(VariantID vid, size_t tune_idx)
 {
-  checksum[vid][tune_idx] += calcChecksum(m_phidat, m_philen, checksum_scale_factor , vid);
+  checksum[vid][tune_idx] += calcChecksum(m_phidat, m_philen, vid);
 }
 
 void LTIMES_NOVIEW::tearDown(VariantID vid, size_t RAJAPERF_UNUSED_ARG(tune_idx))

src/apps/MASS3DEA.cpp

@@ -45,6 +45,7 @@ MASS3DEA::MASS3DEA(const RunParams& params)
   setFLOPsPerRep(m_NE * 7 * ea_mat_entries);
 
   setChecksumConsistency(ChecksumConsistency::ConsistentPerVariantTuning);
+  setChecksumTolerance(ChecksumTolerance::normal);
 
   setComplexity(Complexity::N);
 

src/apps/MASS3DPA.cpp

@@ -49,6 +49,7 @@ MASS3DPA::MASS3DPA(const RunParams& params)
                          2 * MPA_Q1D * MPA_D1D * MPA_D1D * MPA_D1D + MPA_D1D * MPA_D1D * MPA_D1D));
 
   setChecksumConsistency(ChecksumConsistency::ConsistentPerVariantTuning);
+  setChecksumTolerance(ChecksumTolerance::normal);
 
   setComplexity(Complexity::N);
 

src/apps/MASSVEC3DPA.cpp

@@ -56,6 +56,7 @@ MASSVEC3DPA::MASSVEC3DPA(const RunParams &params)
                   2 * MVPA_Q1D * MVPA_D1D * MVPA_D1D * MVPA_D1D));
 
   setChecksumConsistency(ChecksumConsistency::ConsistentPerVariantTuning);
+  setChecksumTolerance(ChecksumTolerance::normal);
 
   setComplexity(Complexity::N);
 

src/apps/MATVEC_3D_STENCIL.cpp

@@ -79,11 +79,11 @@ MATVEC_3D_STENCIL::MATVEC_3D_STENCIL(const RunParams& params)
   const size_t adds = 26;
   setFLOPsPerRep((multiplies + adds) * getItsPerRep());
 
-  checksum_scale_factor = 1.0 *
-              ( static_cast<Checksum_type>(getDefaultProblemSize()) /
-                                           getActualProblemSize() );
-
   setChecksumConsistency(ChecksumConsistency::ConsistentPerVariantTuning);
+  setChecksumTolerance(ChecksumTolerance::normal);
+  setChecksumScaleFactor(1.0 *
+              ( static_cast<Checksum_type>(getDefaultProblemSize()) /
+                                           getActualProblemSize() ));
 
   setComplexity(Complexity::N);
 
@@ -138,7 +138,7 @@ void MATVEC_3D_STENCIL::setUp(VariantID vid, size_t RAJAPERF_UNUSED_ARG(tune_idx
 
 void MATVEC_3D_STENCIL::updateChecksum(VariantID vid, size_t tune_idx)
 {
-  checksum[vid].at(tune_idx) += calcChecksum(m_b, m_zonal_array_length, checksum_scale_factor , vid);
+  checksum[vid].at(tune_idx) += calcChecksum(m_b, m_zonal_array_length, vid);
 }
 
 void MATVEC_3D_STENCIL::tearDown(VariantID vid, size_t RAJAPERF_UNUSED_ARG(tune_idx))

src/apps/NODAL_ACCUMULATION_3D.cpp

@@ -45,11 +45,11 @@ NODAL_ACCUMULATION_3D::NODAL_ACCUMULATION_3D(const RunParams& params)
   setBytesAtomicModifyWrittenPerRep( 1*sizeof(Real_type) * m_domain->n_real_nodes );
   setFLOPsPerRep(9 * getItsPerRep());
 
-  checksum_scale_factor = 0.001 *
-              ( static_cast<Checksum_type>(getDefaultProblemSize()) /
-                                           getActualProblemSize() );
-
   setChecksumConsistency(ChecksumConsistency::Inconsistent);
+  setChecksumTolerance(ChecksumTolerance::normal);
+  setChecksumScaleFactor(0.001 *
+              ( static_cast<Checksum_type>(getDefaultProblemSize()) /
+                                           getActualProblemSize() ));
 
   setComplexity(Complexity::N);
 
@@ -77,7 +77,7 @@ void NODAL_ACCUMULATION_3D::setUp(VariantID vid, size_t RAJAPERF_UNUSED_ARG(tune
 
 void NODAL_ACCUMULATION_3D::updateChecksum(VariantID vid, size_t tune_idx)
 {
-  checksum[vid].at(tune_idx) += calcChecksum(m_x, m_nodal_array_length, checksum_scale_factor , vid);
+  checksum[vid].at(tune_idx) += calcChecksum(m_x, m_nodal_array_length, vid);
 }
 
 void NODAL_ACCUMULATION_3D::tearDown(VariantID vid, size_t RAJAPERF_UNUSED_ARG(tune_idx))

src/apps/PRESSURE.cpp

@@ -38,6 +38,7 @@ PRESSURE::PRESSURE(const RunParams& params)
                   ) * getActualProblemSize());
 
   setChecksumConsistency(ChecksumConsistency::ConsistentPerVariantTuning);
+  setChecksumTolerance(ChecksumTolerance::normal);
 
   setComplexity(Complexity::N);
 

src/apps/VOL3D.cpp

@@ -43,11 +43,11 @@ VOL3D::VOL3D(const RunParams& params)
   setBytesAtomicModifyWrittenPerRep( 0 );
   setFLOPsPerRep(72 * (m_domain->lpz+1 - m_domain->fpz));
 
-  checksum_scale_factor = 0.001 *
-              ( static_cast<Checksum_type>(getDefaultProblemSize()) /
-                                           getActualProblemSize() );
-
   setChecksumConsistency(ChecksumConsistency::ConsistentPerVariantTuning);
+  setChecksumTolerance(ChecksumTolerance::normal);
+  setChecksumScaleFactor(0.001 *
+              ( static_cast<Checksum_type>(getDefaultProblemSize()) /
+                                           getActualProblemSize() ));
 
   setComplexity(Complexity::N);
 
@@ -79,7 +79,7 @@ void VOL3D::setUp(VariantID vid, size_t RAJAPERF_UNUSED_ARG(tune_idx))
 
 void VOL3D::updateChecksum(VariantID vid, size_t tune_idx)
 {
-  checksum[vid][tune_idx] += calcChecksum(m_vol, m_array_length, checksum_scale_factor , vid);
+  checksum[vid][tune_idx] += calcChecksum(m_vol, m_array_length, vid);
 }
 
 void VOL3D::tearDown(VariantID vid, size_t RAJAPERF_UNUSED_ARG(tune_idx))