component istream

export Executable

N : ZZ32 = 2000000
tim = array[\RR64\](5)

timeDiffMS(start:ZZ64, fin:ZZ64): RR64 =
    (fin-start) / 10^9

hline() : () = 
     println("****************************************")

bench[\Elt extends Number\](z:Elt,o:Elt,t:Elt,s:Elt) :() = do

  st : ZZ64 = 0
  fin : ZZ64 = 0

  a = array[\Elt\](N)
  a.fill(o)

  b = array[\Elt\](N)
  b.fill(t)

  c = array[\Elt\](N)
  c.fill(z)

  d = array[\Elt\](N)
  d.fill(o)

  e = array[\Elt\](N)
  e.fill(z)

(*
  typecase s of
    ZZ64 => println("--ZZ64")
    ZZ32 => println("--ZZ32")
    RR64 => println("--RR64")
  end
*)

(* copy *)
  st := nanoTime()
  for i <- 0#N do
      c[i] := a[i] 
  end
  fin := nanoTime()
  tim[0] := timeDiffMS(st,fin)

(* scale *)
  st := nanoTime()
  for i <- 0#N do
      b[i] := s c[i]
  end
  fin := nanoTime()
  tim[1] := timeDiffMS(st,fin)

(* add *)
  st := nanoTime()
  for i <- 0#N do
      c[i] := a[i] + b[i]
  end
  fin := nanoTime()
  tim[2] := timeDiffMS(st,fin)

(* triad *)
  st := nanoTime()
  for i <- 0#N do
      a[i] := b[i] + s c[i]
  end
  fin := nanoTime()
  tim[3] := timeDiffMS(st,fin)

(* sscale *)
typecase s of ZZ64 =>
  st := nanoTime()
  for i <- 0#N do
      e[i] := d[i] LSHIFT s
  end
  fin := nanoTime()
  tim[4] := timeDiffMS(st,fin)

  RR64 => println("RR64")
end


(* checkSTREAMresults *)
if s=/=3 then

  aj: Elt = o
  bj: Elt = t
  cj: Elt = z
  scalar: Elt = s
   
  println("1-"aj" "bj" "cj" "scalar)

  aj := t aj

  println("1a-"aj" "bj" "cj" "scalar)

  for k <- seq(0#10) do
      cj := aj
      bj := scalar cj
      cj := aj + bj
      aj := bj + scalar cj
      println(k"    "aj" "bj" "cj)
  end

  println("2-"aj" "bj" "cj" "scalar)

  aj := aj N
  bj := bj N
  cj := cj N

  println("3-"aj" "bj" "cj" "scalar)

  asum:Elt = z
  bsum:Elt = z
  csum:Elt = z

  println("4-"asum" "bsum" "csum)

  for j <- 0#N atomic do
      asum += a[j]
      bsum += b[j]
      csum += c[j]
  end

  println(aj" "bj" "cj)
  println(asum" "bsum" "csum)

  end

end

run(args:String...) :() = do

  numtests : ZZ32 = 0
  testid:String[5] = ["Copy" "Scale" "Add" "Triad" "Sscale"]
  bytesize = array[\RR64\](5)

  bytesize[0] := 2 4 N
  bytesize[1] := 2 4 N
  bytesize[2] := 3 4 N
  bytesize[3] := 3 4 N
  bytesize[4] := 2 4 N

  Offset : ZZ32 = 0

  my_zero_l : ZZ32 = 0
  my_one_l : ZZ32 = 1
  my_two_l : ZZ32 = 2
  my_three_l : ZZ32 = 3

  println("The data type is 32-bit int")
  println("This system uses 4 bytes per Element being tested")
  println("Array size = "N", Offset = "Offset)
  println("Total memory required = "(3.0 4 N / 1048576.0)" MB.")

  bench[\ZZ32\](my_zero_l,my_one_l,my_two_l,my_three_l)

  numtests := 5 

  println("Function     Rate (MB/s) Avg time")
  for i <- seq(0#numtests) do
      ttt = bytesize[i] / (tim[i] 10^6)
      println(testid[i]"   "ttt"   "tim[i])
  end
  hline()

  my_zero_ll : ZZ64 = 0
  my_one_ll : ZZ64 = 1
  my_two_ll : ZZ64 = 2
  my_three_ll : ZZ64 = 3

  println("The data type is 64-bit int")
  println("This system uses 8 bytes per Element being tested")
  println("Array size = "N", Offset = "Offset)
  println("Total memory required = "(3.0 8 N / 1048576.0)" MB.")

  bench[\ZZ64\](my_zero_ll,my_one_ll,my_two_ll,my_three_ll)

  println("Function     Rate (MB/s) Avg time")
  for i <- seq(0#numtests) do
      ttt = 2  bytesize[i] / (tim[i] 10^6)
      println(testid[i]"   "ttt"   "tim[i])
  end
  hline()

  my_zero_d : RR64 = 0.0
  my_one_d : RR64 = 1.0
  my_two_d : RR64 = 2.0
  my_three_d : RR64 = 3.0

  println("The data type is double")
  println("This system uses 8 bytes per Element being tested")
  println("Array size = "N", Offset = "Offset)
  println("Total memory required = "(3.0 8 N / 1048576.0)" MB.")

  bench[\RR64\](my_zero_d,my_one_d,my_two_d,my_three_d)

  numtests := 4

  println("Function     Rate (MB/s) Avg time")
  for i <- seq(0#numtests) do
      ttt = 2  bytesize[i] / (tim[i] 10^6)
      println(testid[i]"   "ttt"   "tim[i])
  end
  hline()

(*
  my_zero_f : RR32 = 0.0
  my_one_f : RR32 = 1.0
  my_two_f : RR32 = 2.0
  my_three_f : RR32 = 3.0

  bench[\RR32\](my_zero_f,my_one_f,my_two_f,my_three_f)
*)

end

end