[Home] [Version 2] [Run it Now] [Download] [Results] [FAQ] [About] [Resources] [Credits]

SciMark is a composite Java benchmark measuring the performance of numerical codes occurring in scientific and engineering applications. It consists of five computational kernels: FFT, Gauss-Seidel relaxation, Sparse matrix-multiply, Monte Carlo integration, and dense LU factorization.

These kernels are chosen to provide an indication of how well the underlying JVM/JITs perform on applications utilizing these types of algorithms. The problems sizes are purposely chosen to be small in order to isolate the effects of memory hierarchy and focus on internal JVM/JIT and CPU issues. A larger version of the benchmark (SciMark 2.0 LARGE) addresses performance of the memory subsystem with out-of-cache problem sizes.

Computational Kernels

• Fast Fourier Transform (FFT) performs a one-dimensional forward transform of 4K complex numbers. This kernel exercises complex arithmetic, shuffling, non-constant memory references and trigonometric functions. The first section performs the bit-reversal portion (no flops) and the second performs the actual Nlog(N) computational steps.

  The data size for the LARGE version of the benchmark is 2^20 (=1048576) complex numbers.

• Jacobi Successive Over-relaxation (SOR) on a 100x100 grid exercises typical access patterns in finite difference applications, for example, solving Laplace's equation in 2D with Drichlet boundary conditions. The algorithm excercises basic "grid averaging" memory patterns, where each A(i,j) is assigned an average weighting of its four nearest neighbors.

  The inner loops of the kernel look like

   for (int i=1; i < Mm1; i++)
   {
      double[] Gi = G[i];
      double[] Gim1 = G[i-1];
      double[] Gip1 = G[i+1];
      for (int j=1; j < Nm1; j++)
          Gi[j] = omega_over_four * (Gim1[j] + Gip1[j] + Gi[j-1] 
                      + Gi[j+1]) + one_minus_omega * Gi[j];
   }
  

  Note that we do some hand-optimizing by aliasing the rows of G[][] to streamline the array accesses in the update expression.

  The data size for the LARGE version of the benchmark uses a 1,000x1,000 grid.

• Monte Carlo integration approximates the value of Pi by computing the integral of the quarter circle y = sqrt(1 - x^2) on [0,1]. It chooses random points with the unit square and compute the ratio of those within the circle. The algorithm exercises random-number generators, synchronized function calls, and function inlining.

  (Note that this kernel uses only scalars, hence the LARGE version of the benchmark is identical.)

• Sparse matrix multiply uses an unstructured sparse matrix stored in compressed-row format with a prescribed sparsity structure. This kernel exercises indirection addressing and non-regular memory references. A 1,000 x 1,000 sparse matrix with 5,000 nonzeros is used, with the following storage pattern:

  **---------------.
  ***              |
  * * *            |
  ** *  *          |
  ** **   *        |
  ** * *    *      |
  * *  * *    *    |
  *  *  *  *    *  |
  *   *  *   *    *|
  *---*---*----*---*
  

  That is, each row has approximately 5 nonzeros, evenly spaced between the first column and the diagonal.

  The data size for the LARGE version of the benchmark uses a 100,000 x 100,000 matrix with 1,000,000 nonzeros.

• dense LU matrix factorization Computes the LU factorization of a dense 100x100 matrix using partial pivoting. Exercises linear algebra kernels (BLAS) and dense matrix operations. The algorithm is the right-looking version of LU with rank-1 updates.

  The data size for the LARGE version of the benchmark uses a 1,000 x 1,000 matrix.

Commercial equipment and software is referred to on these pages in order to precisely document experimental measurements. Mention of these products does not imply recommendation or endorsement by the National Institute of Standards and Technology, nor does it imply that the products so identified are necessarily the best available for that purpose.