Enhance clock

Author: EntityFX

src/lua/benchmarkBase.lua

@@ -5,14 +5,24 @@ BenchmarkBase = class(function(b, writer, printToConsole)
  b.ratio = 1.0
  b.name = "BenchmarkBase"
  b.output = writer
+ b.clockBefore = 0
+ b.clockAfter = 0
+ b.clockDiff = 0
+ b.elapsed = 0
 end)
 
 BenchmarkBase.IterrationsRatio = 1;
 
 function BenchmarkBase:bench()
+ self.clockBefore = 0
+ self.clockAfter = 0
+ self.clockDiff = 0
  self:beforeBench()
- local start = os.clock()
+ self.clockBefore = clock()
  local res = self:benchImplementation()
+ self.clockAfter = clock()
+ self.elapsed = math.floor(self.clockAfter - self.clockBefore)
+
  local result = self:populateResult(self:buildResult(start), res)
  self:doOutput(result)
  self:afterBench(result)
@@ -53,13 +63,12 @@ function BenchmarkBase:benchImplementation()
 end
 
 function BenchmarkBase:buildResult(start)
- local elapsed = math.floor((os.clock() - start) * 1000)
  local tElapsed = 0
 
- if elapsed == 0 then
+ if self.elapsed == 0 then
  tElapsed = 1000
  else
- tElapsed = elapsed
+ tElapsed = self.elapsed
  end
 
  local elapsedSeconds = tElapsed / 1000

src/lua/dhrystone/dhrystone.lua

@@ -10,6 +10,10 @@ Dhrystone2 = class(function(d, printToConsole)
  d.Char2Glob = "\\"
  d.Array1Glob = {}
  d.Array2Glob = {}
+
+ d.elapsed = 0
+ d.startClock = 0
+ d.endClock = 0
 end)
 
 Dhrystone2.LOOPS = 20000000
@@ -33,6 +37,10 @@ function Dhrystone2:bench(loops)
  loops = Dhrystone2.LOOPS 
  end
 
+ self.startClock = 0
+ self.endClock = 0
+ self.elapsed = 0
+
  self.output:writeLine("##########################################")
  self.output:writeLine("")
  self.output:writeLine("Dhrystone Benchmark, Version 2.1 (Language: Lua)")
@@ -249,7 +257,7 @@ function Dhrystone2:Proc0(loops)
  local IntLoc2 = 0
  local IntLoc3 = 0
 
- local start = os.clock()
+ self.startClock = clock()
 
  for i=0,loops - 1 do
  self:Proc5()
@@ -284,7 +292,10 @@ function Dhrystone2:Proc0(loops)
  IntLoc1 = self:Proc2(IntLoc1)
  end
 
- local benchtime = (os.clock() - start) * 1000
+ self.endClock = clock()
+ self.elapsed = (self.endClock - self.startClock)
+
+ local benchtime = self.elapsed
  local loopsPerBenchtime = 0
  if ((benchtime == 0)) then
  loopsPerBenchtime = 0;

src/lua/generic/callBenchmarkBase.lua

@@ -11,7 +11,7 @@ function CallBenchmarBase:doCall(i, b)
 end
 
 function CallBenchmarBase:doCallBench()
- local start = os.clock()
+ local start = clock()
  local elapsed1 = 0
  local elapsed2 = 0
  local i = 0
@@ -23,14 +23,15 @@ function CallBenchmarBase:doCallBench()
  a = z + z1 + 0.5;
  end
 
- elapsed1 = (os.clock() - start) * 1000
+ elapsed1 = clock() - start
  a = 0.0;
  i = 0;
- start = os.clock()
+
+ start = clock()
  for i=1,self.iterrations do
  a = self:doCall(a, 0.01)
  end
- elapsed2 = (os.clock() - start) * 1000
+ elapsed2 = clock() - start
 
  self.output:write("Elapsed No Call: %d", math.floor(elapsed1))
  self.output:writeLine()

src/lua/generic/memoryBenchmark.lua

@@ -4,7 +4,7 @@ MemoryBenchmark = class(MemoryBenchmarkBase, function(a, writer, printToConsole)
 end)
 
 function MemoryBenchmark:benchImplementation()
- return self:benchRandomMemory()
+ return self:benchMemory()
 end
 
 function MemoryBenchmark:populateResult(benchResult, memoryBenchmarkResult)

src/lua/generic/memoryBenchmarkBase.lua

@@ -2,16 +2,23 @@ MemoryBenchmarkBase = class(BenchmarkBase, function(a, writer, printToConsole)
  BenchmarkBase.init(a, writer, printToConsole)
  a.iterrations = 500000
  a.ratio = 1
+ a.beforeClockMemory = 0
+ a.afterClockMemory = 0
+ a.elapsedClockMemory = 0
 end)
 
-function MemoryBenchmarkBase:benchRandomMemory()
- local int4k = self:measureArrayRandomRead(1024)
+function MemoryBenchmarkBase:benchMemory()
+ self.beforeClockMemory = 0
+ self.afterClockMemory = 0
+ self.elapsedClockMemory = 0
+
+ local int4k = self:measureArrayRead(1024)
  self.output:writeLine("int 4k: %.2f MB/s", int4k.mbPerSec)
- local int512k = self:measureArrayRandomRead(131072)
+ local int512k = self:measureArrayRead(131072)
  self.output:writeLine("int 512k: %.2f MB/s", int512k.mbPerSec)
- local int8m = self:measureArrayRandomRead(2097152)
+ local int8m = self:measureArrayRead(2097152)
  self.output:writeLine("int 8M: %.2f MB/s", int8m.mbPerSec)
- local int32m = self:measureArrayRandomRead(32 * 1024 * 1024 / 4)
+ local int32m = self:measureArrayRead(32 * 1024 * 1024 / 4)
  self.output:writeLine("int 32M: %.2f MB/s", int32m.mbPerSec)
 
  local long4k = self:measureArrayRandomLongRead(1024)
@@ -36,7 +43,7 @@ function MemoryBenchmarkBase:benchRandomMemory()
  }
 end
 
-function MemoryBenchmarkBase:measureArrayRandomRead(size)
+function MemoryBenchmarkBase:measureArrayRead(size)
  local blockSize = 16
  local I = {}
 
@@ -49,6 +56,7 @@ function MemoryBenchmarkBase:measureArrayRandomRead(size)
  if k0 == 0 then k1 = 1 else k1 = k0 end
  local iterInternal = self.iterrations / k1
  if iterInternal == 0 then iterInternal = 1 end
+
  for idx=0,endA,blockSize do
  I[0] = array[idx]
  I[1] = array[idx + 1]
@@ -67,7 +75,8 @@ function MemoryBenchmarkBase:measureArrayRandomRead(size)
  I[14] = array[idx + 14]
  I[15] = array[idx + 15]
  end
- local start = os.clock() * 1000
+
+ self.beforeClockMemory = clock()
  for i=0,iterInternal-1 do
  for idx=0,endA,blockSize do
  I[0] = array[idx]
@@ -88,7 +97,13 @@ function MemoryBenchmarkBase:measureArrayRandomRead(size)
  I[15] = array[idx + 15]
  end
  end
- local elapsed = math.floor(os.clock() * 1000 - start)
+ self.afterClockMemory = clock()
+ self.elapsedClockMemory = self.afterClockMemory - self.beforeClockMemory
+ if (self.elapsedClockMemory == 0) then
+ self.elapsedClockMemory = 1
+ end
+
+ local elapsed = math.floor(self.elapsedClockMemory)
  return { mbPerSec = (iterInternal * #array * 8.0 / (elapsed / 1000.0) / 1024 / 1024), res = I }
 end
 
@@ -115,7 +130,8 @@ function MemoryBenchmarkBase:measureArrayRandomLongRead(size)
  I[6] = array[idx + 6]
  I[7] = array[idx + 7]
  end
- local start = os.clock() * 1000
+
+ self.beforeClockMemory = clock()
  for i=0,iterInternal-1 do
  for idx=0,endA,blockSize do
  I[0] = array[idx]
@@ -128,6 +144,12 @@ function MemoryBenchmarkBase:measureArrayRandomLongRead(size)
  I[7] = array[idx + 7]
  end
  end
- local elapsed = math.floor(os.clock() * 1000 - start)
+ self.afterClockMemory = clock()
+ self.elapsedClockMemory = self.afterClockMemory - self.beforeClockMemory
+ if (self.elapsedClockMemory == 0) then
+ self.elapsedClockMemory = 1
+ end
+
+ local elapsed = math.floor(self.elapsedClockMemory)
  return { mbPerSec = (iterInternal * #array * 8.0 / (elapsed / 1000.0) / 1024 / 1024), res = I }
 end

src/lua/generic/randomMemoryBenchmarkBase.lua

@@ -2,9 +2,16 @@ RandomMemoryBenchmarkBase = class(BenchmarkBase, function(a, writer, printToCons
  BenchmarkBase.init(a, writer, printToConsole)
  a.iterrations = 500000
  a.ratio = 2
+ a.beforeClockMemory = 0
+ a.afterClockMemory = 0
+ a.elapsedClockMemory = 0
 end)
 
 function RandomMemoryBenchmarkBase:benchRandomMemory()
+ self.beforeClockMemory = 0
+ self.afterClockMemory = 0
+ self.elapsedClockMemory = 0
+
  local int4k = self:measureArrayRandomRead(1024)
  self.output:writeLine("Random int 4k: %.2f MB/s", int4k.mbPerSec)
  local int512k = self:measureArrayRandomRead(131072)
@@ -47,13 +54,21 @@ function RandomMemoryBenchmarkBase:measureArrayRandomRead(size)
  for idx=0,endA do
  I = array[idx]
  end
- local start = os.clock() * 1000
+
+ self.beforeClockMemory = clock()
  for i=0,iterInternal-1 do
  for key,idx in ipairs(indexes) 
  do
  I = array[idx]
  end
  end
- local elapsed = math.floor(os.clock() * 1000 - start)
+
+ self.afterClockMemory = clock()
+ self.elapsedClockMemory = self.afterClockMemory - self.beforeClockMemory
+ if (self.elapsedClockMemory == 0) then
+ self.elapsedClockMemory = 1
+ end
+
+ local elapsed = math.floor(self.elapsedClockMemory)
  return { mbPerSec = (iterInternal * #array * 8.0 / (elapsed / 1000.0) / 1024 / 1024), res = I }
 end

src/lua/linpack/linpack.lua

@@ -17,9 +17,9 @@ end
 
 function Linpack:second()
  if self.second_orig == -1 then
- self.second_orig = os.clock()
+ self.second_orig = clock() / 1000.0
  end
- return os.clock()
+ return clock() / 1000.0
 end
 
 function Linpack:run_benchmark(array_size)

src/lua/main.lua

@@ -40,18 +40,18 @@ local writer = Writer("Output.log")
 BenchmarkBase.IterrationsRatio = 0.1
 
 benchmarks = {
- ArithemticsBenchmark(writer, true),
- MathBenchmark(writer, true),
- CallBenchmark(writer, true),
- IfElseBenchmark(writer, true),
- StringManipulation(writer, true),
- MemoryBenchmark(writer, true),
- RandomMemoryBenchmark(writer, true),
- Scimark2Benchmark(writer, true),
+ -- ArithemticsBenchmark(writer, true),
+ -- MathBenchmark(writer, true),
+ -- CallBenchmark(writer, true),
+ -- IfElseBenchmark(writer, true),
+ -- StringManipulation(writer, true),
+ -- MemoryBenchmark(writer, true),
+ -- RandomMemoryBenchmark(writer, true),
+ -- Scimark2Benchmark(writer, true),
  DhrystoneBenchmark(writer, true),
- WhetstoneBenchmark(writer, true),
- LinpackBenchmark(writer, true),
- HashBenchmark(writer, true)
+ -- WhetstoneBenchmark(writer, true),
+ -- LinpackBenchmark(writer, true),
+ -- HashBenchmark(writer, true)
 }
 
 writer:writeHeader("Warmup")

src/lua/scimark2/scimark2.lua

@@ -91,13 +91,22 @@ function Scimark2:bench(isLarge)
 end
 
 function Scimark2:measure(min_time, name, ...)
+ local clockBefore = 0
+ local clockAfter = 0
+ local tm = 0
  math.randomseed( os.time() )
  local run = Kernel[name](...)
  local cycles = 1
  repeat
- local tm = os.clock()
+ clockBefore = clock() / 1000.0
  local flops = run(cycles, ...)
- tm = os.clock() - tm
+ clockAfter = clock() / 1000.0
+ tm = clockAfter - clockBefore
+
+ if (tm == 0) then
+ tm = 1
+ end
+
  if tm >= min_time then
  local res = flops / tm * 1.0e-6
  local p1, p2 = ...

src/lua/utils.lua

@@ -99,15 +99,28 @@ end
 -- Returns the sum of a sequence of values
 function sum(x)
  local s = 0
- for _, v in ipairs(x) do s = s + v end
+ for _, v in ipairs(x) do
+ s = s + v 
+ end
  return s
 end
+
+function clock()
+ local clk = os.clock() * 1000
+ return clk
+end
+
+function clockSeconds()
+ return clock() / 1000.0
+end
 
 -- Calculates the arithmetic mean of a set of values
 -- x : an array of values
 -- returns : the arithmetic mean
 function arithmetic_mean(x)
- return (sum(x) / #x)
+ local s = sum(x)
+ local len = #x
+ return (s / len)
 end
 
 function compareTo(str1, str2)