scalar2.d

/**
 * Demo: scalar2.d
 * Purpose: Compare with scalar.d and scalar.cpp
 *     Used uninitializedArray to avoid default inits for scalars in xs
 *
 *   Changes with little or no performance effect:
 *     Factored out printing code and replaced writefln with writeln
 *     Replaced platform-dependent types (array.length) with typeof and auto statements.
 *     Changed imports to be selective
 *     Used pow operator (^^) instead of manual multiplication for final step of calculating average
 *     Removed the size_type and replaced appropriately with the index_type alias
 *
 *     Source was compiled with `rdmd --compiler=ldc2 -O3 -boundscheck=off scalar2.d`.
 * Authors: Erich Gubler (@erichdongubler)
 * Date: 3/30/2015
 */
import std.stdio : writeln;
import std.datetime : Clock, Duration;
import std.array : uninitializedArray;
import std.random : uniform;

alias result_type = long;
alias value_type = int;
alias vector_t = value_type[];
alias index_type = typeof(vector_t.init.length);// Make index integrals portable - Linux is ulong, Win8.1 is uint

immutable long N = 20000;
immutable int size = 10;

// Replaced for loops with appropriate foreach versions
value_type scalar_product(in ref vector_t x, in ref vector_t y) { // "in" is the same as "const" here
  value_type res = 0;
  for(index_type i = 0; i < size; ++i)
    res += x[i] * y[i];
  return res;
}

int main() {
  auto tm_before = Clock.currTime;
  auto countElapsed(in string taskName) { // Factor out printing code
    writeln(taskName, ": ", Clock.currTime - tm_before);
    tm_before = Clock.currTime;
  }

  // 1. allocate and fill randomly many short vectors
  vector_t[] xs = uninitializedArray!(vector_t[])(N);// Avoid default inits of inner arrays
  for(index_type i = 0; i < N; ++i)
    xs[i] = uninitializedArray!(vector_t)(size);// Avoid more default inits of values
  countElapsed("allocation");

  for(index_type i = 0; i < N; ++i)
    for(index_type j = 0; j < size; ++j)
      xs[i][j] = uniform(-1000, 1000);
  countElapsed("random");

  // 2. compute all pairwise scalar products:
  result_type avg = 0;
  for(index_type i = 0; i < N; ++i)
    for(index_type j = 0; j < N; ++j)
      avg += scalar_product(xs[i], xs[j]);
  avg /= N ^^ 2;// Replace manual multiplication with pow operator
  writeln("result: ", avg);
  countElapsed("scalar products");

  return 0;
}