Rate counter: Difference between revisions
(Ada implementation) |
(Added Chipmunk Basic) |
||
(92 intermediate revisions by 45 users not shown) | |||
Line 8: | Line 8: | ||
* Report at least three distinct times. |
* Report at least three distinct times. |
||
Be aware of the precision and accuracy limitations of your timing mechanisms, and document them if you can. |
<br>Be aware of the precision and accuracy limitations of your timing mechanisms, and document them if you can. |
||
'''See also:''' [[System time]], [[Time a function]] |
'''See also:''' [[System time]], [[Time a function]] |
||
=={{header|Action!}}== |
|||
{{libheader|Action! Tool Kit}} |
|||
<syntaxhighlight lang="action!">INCLUDE "D2:REAL.ACT" ;from the Action! Tool Kit |
|||
DEFINE PTR="CARD" |
|||
CARD FUNC GetFrame() |
|||
BYTE RTCLOK1=$13,RTCLOK2=$14 |
|||
CARD res |
|||
BYTE lsb=res,msb=res+1 |
|||
lsb=RTCLOK2 |
|||
msb=RTCLOK1 |
|||
RETURN (res) |
|||
CARD FUNC FramesToMs(CARD frames) |
|||
BYTE PALNTSC=$D014 |
|||
CARD res |
|||
IF PALNTSC=15 THEN |
|||
res=frames*60 |
|||
ELSE |
|||
res=frames*50 |
|||
FI |
|||
RETURN (res) |
|||
CARD FUNC ItersPerSecond(CARD timeMs,iters) |
|||
REAL rTime,rIters,r1000,tmp |
|||
CARD res |
|||
IntToReal(timeMs,tmp) |
|||
IntToReal(iters,rIters) |
|||
IntToReal(1000,r1000) |
|||
RealDiv(tmp,r1000,rTime) |
|||
RealDiv(rIters,rTime,tmp) |
|||
res=RealToInt(tmp) |
|||
RETURN (res) |
|||
;jump addr is stored in X and A registers |
|||
PROC Action=*(PTR jumpAddr) |
|||
DEFINE STX="$8E" |
|||
DEFINE STA="$8D" |
|||
DEFINE JSR="$20" |
|||
DEFINE RTS="$60" |
|||
[STX Action+8 |
|||
STA Action+7 |
|||
JSR $00 $00 |
|||
RTS] |
|||
PROC Benchmark(PTR ARRAY actions,times BYTE count CARD iters) |
|||
BYTE i |
|||
CARD j,beg,end,diff,diffMs |
|||
PTR act |
|||
FOR i=0 TO count-1 |
|||
DO |
|||
act=actions(i) |
|||
beg=GetFrame() |
|||
FOR j=0 TO iters-1 |
|||
DO |
|||
Action(act) |
|||
OD |
|||
end=GetFrame() |
|||
diff=end-beg |
|||
times(i)=FramesToMs(diff) |
|||
OD |
|||
RETURN |
|||
PROC Action1() |
|||
RETURN |
|||
PROC Action2() |
|||
INT a=[12345],b=[23456],c |
|||
c=a+b |
|||
RETURN |
|||
PROC Action3() |
|||
INT i=[12345] |
|||
CHAR ARRAY s(6) |
|||
StrI(i,s) |
|||
RETURN |
|||
PROC Main() |
|||
DEFINE COUNT="3" |
|||
DEFINE ITERS="10000" |
|||
PTR ARRAY actions(COUNT) |
|||
CARD ARRAY times(COUNT),prec,rate |
|||
BYTE i |
|||
Put(125) PutE() ;clear the screen |
|||
prec=FramesToMs(1) |
|||
PrintF("Iteration count: %U%E",ITERS) |
|||
PrintF("Clock precision: %U ms%E%E",prec) |
|||
actions(0)=Action1 |
|||
actions(1)=Action2 |
|||
actions(2)=Action3 |
|||
Benchmark(actions,times,COUNT,ITERS) |
|||
FOR i=0 TO COUNT-1 |
|||
DO |
|||
rate=ItersPerSecond(times(i),iters) |
|||
PrintF("Action%B: %U ms, %U times per sec%E",i+1,times(i),rate) |
|||
OD |
|||
RETURN</syntaxhighlight> |
|||
{{out}} |
|||
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Rate_counter.png Screenshot from Atari 8-bit computer] |
|||
<pre> |
|||
Iteration count: 10000 |
|||
Clock precision: 50 ms |
|||
Action1: 1400 ms, 7143 times per sec |
|||
Action2: 2000 ms, 5000 times per sec |
|||
Action3: 47800 ms, 209 times per sec |
|||
</pre> |
|||
=={{header|Ada}}== |
=={{header|Ada}}== |
||
Launch 6 jobs in parallel and record the elapsed time for each job. |
Launch 6 jobs in parallel and record the elapsed time for each job. A variant |
||
to get CPU times would use the package Ada.Execution_Time (Ada05).<br> |
|||
of measure is given by the value of System.Tick; on Windows value is 10 ms. |
The precision of measure is given by the value of System.Tick; on Windows value is 10 ms. |
||
<syntaxhighlight lang="ada">with System; use System; |
|||
<lang Ada> |
|||
with |
with Ada.Text_IO; use Ada.Text_IO; |
||
with Ada. |
with Ada.Calendar; use Ada.Calendar; |
||
with Ada. |
with Ada.Unchecked_Deallocation; use Ada; |
||
with Interfaces; |
|||
with Ada.Synchronous_Task_Control; use Ada.Synchronous_Task_Control; |
|||
procedure Rate_Counter is |
procedure Rate_Counter is |
||
Line 37: | Line 153: | ||
type Job_Ptr is access Job; |
type Job_Ptr is access Job; |
||
procedure Free is new Unchecked_Deallocation (Job, Job_Ptr); |
|||
Jobs : array (Job_Index) of Job_Ptr; |
Jobs : array (Job_Index) of Job_Ptr; |
||
Done : Natural := 0; |
|||
array (Job_Index) of |
Completed : array (Job_Index) of Boolean := (others => False); |
||
Completed : array (Job_Index) of Boolean := (others => False); |
|||
Start_T, Stop_T : array (Job_Index) of Calendar.Time; |
|||
type Timings is array (Job_Index) of Calendar.Time; |
|||
Done : Natural := 0; |
|||
Start_T, Stop_T : Timings; |
|||
task body Job is |
task body Job is |
||
Anchor : |
Anchor : Interfaces.Integer_32; |
||
pragma Volatile (Anchor); -- necessary to avoid compiler optimization. |
pragma Volatile (Anchor); -- necessary to avoid compiler optimization. |
||
begin |
begin |
||
accept Start |
accept Start; |
||
Set_False (Flags (ID)); |
|||
for I in Interfaces.Integer_32'Range loop -- the job to do |
|||
end Start; |
|||
-- the job to do / could be replaced by |
|||
for I in Long_Integer'First .. Long_Integer'Last loop |
|||
Anchor := I; |
Anchor := I; |
||
end loop; |
end loop; |
||
Set_True (Flags (ID)); |
|||
end Job; |
end Job; |
||
Line 69: | Line 182: | ||
Jobs (J).Start; -- priority settings necessary to regain control. |
Jobs (J).Start; -- priority settings necessary to regain control. |
||
end loop; |
end loop; |
||
-- Polling for the results |
-- Polling for the results / also possible to use a protected type. |
||
while not (Done = Job_Nbr) loop |
while not (Done = Job_Nbr) loop |
||
for J in Job_Index'Range loop |
for J in Job_Index'Range loop |
||
if not Completed (J) and then |
if not Completed (J) and then Jobs (J)'Terminated then |
||
Stop_T (J) := Calendar.Clock; -- get the end time |
Stop_T (J) := Calendar.Clock; -- get the end time |
||
Put ("Job #" & Job_Index'Image (J) & " is finished. It took "); |
Put ("Job #" & Job_Index'Image (J) & " is finished. It took "); |
||
Duration_IO.Put (Stop_T (J) - Start_T (J), Fore => 3, Aft => 2); |
Duration_IO.Put (Stop_T (J) - Start_T (J), Fore => 3, Aft => 2); |
||
Put_Line (" seconds."); |
Put_Line (" seconds."); |
||
Done := Done + 1; |
|||
Completed (J) := True; |
Completed (J) := True; |
||
Done := Done + 1; |
|||
end if; |
end if; |
||
end loop; |
end loop; |
||
delay System.Tick; -- according to the precision of the system clock |
delay System.Tick; -- according to the precision of the system clock |
||
end loop; |
end loop; |
||
Duration_IO.Put (System.Tick, Fore => 1, Aft => 6); |
|||
Put_Line (" seconds is the precision of System clock."); |
|||
for J in Job_Index'Range loop |
|||
end Rate_Counter;</lang> |
|||
Free (Jobs (J)); -- no GC in Ada, clean-up is explicit |
|||
end loop; |
|||
end Rate_Counter;</syntaxhighlight> |
|||
Output :<pre style="overflow: auto; height: 5em;"> |
|||
Job # 1 is finished. It took 44.49 seconds. |
|||
Output on a Linux 64 bits system: |
|||
Job # 3 is finished. It took 44.43 seconds. |
|||
<pre style="overflow: auto; height: 5em;"> |
|||
Job # 5 is finished. It took 44.32 seconds. |
|||
Job # |
Job # 1 is finished. It took 57.93 seconds. |
||
Job # |
Job # 5 is finished. It took 58.27 seconds. |
||
Job # 6 is finished. It took |
Job # 6 is finished. It took 58.27 seconds. |
||
Job # 4 is finished. It took 60.42 seconds. |
|||
Job # 3 is finished. It took 60.98 seconds. |
|||
Job # 2 is finished. It took 61.12 seconds. |
|||
0.000001 seconds is the precision of System clock. |
|||
</pre> |
|||
=={{header|Arturo}}== |
|||
<syntaxhighlight lang="arturo">cube: function [z]-> |
|||
z * z * z |
|||
loop 1..10 'x [ |
|||
benchmark -> |
|||
loop 1..400 'o -> cube 5 |
|||
]</syntaxhighlight> |
|||
{{out}} |
|||
<pre>[benchmark] time: 0.231ms |
|||
[benchmark] time: 0.231ms |
|||
[benchmark] time: 0.213ms |
|||
[benchmark] time: 0.184ms |
|||
[benchmark] time: 0.141ms |
|||
[benchmark] time: 0.175ms |
|||
[benchmark] time: 0.169ms |
|||
[benchmark] time: 0.254ms |
|||
[benchmark] time: 0.174ms |
|||
[benchmark] time: 0.174ms</pre> |
|||
=={{header|AutoHotkey}}== |
|||
===Built in variable=== |
|||
The built in variable [http://ahkscript.org/docs/Variables.htm#TickCount A_TickCount] contains the number of milliseconds since the computer was rebooted. Storing this variable and later comparing it to the current value will measure the time elapsed. A_TickCount has a precision of approximately 10ms. |
|||
<syntaxhighlight lang="autohotkey">SetBatchLines, -1 |
|||
Tick := A_TickCount ; store tickcount |
|||
Loop, 1000000 { |
|||
Random, x, 1, 1000000 |
|||
Random, y, 1, 1000000 |
|||
gcd(x, y) |
|||
} |
|||
t := A_TickCount - Tick ; store ticks elapsed |
|||
MsgBox, % t / 1000 " Seconds elapsed.`n" Round(1 / (t / 1000000000), 0) " Loop iterations per second." |
|||
gcd(a, b) { ; Euclidean GCD |
|||
while b |
|||
t := b, b := Mod(a, b), a := t |
|||
return, a |
|||
}</syntaxhighlight> |
|||
'''Output:''' |
|||
<pre>4.250000 Seconds elapsed. |
|||
235294 Loop iterations per second.</pre> |
|||
===Query Performance Counter=== |
|||
The [http://www.autohotkey.com/board/topic/48063-qpx-delay-based-on-queryperformancecounter/ QPX function] by SKAN wraps the [http://msdn.microsoft.com/en-us/library/windows/desktop/ms644904%28v=vs.85%29.aspx QueryPerformanceCounter] DLL, and is precise to one thousandth of a millisecond. |
|||
<syntaxhighlight lang="autohotkey">SetBatchLines, -1 |
|||
QPX(1) ; start timer |
|||
Loop, 1000000 { |
|||
Random, x, 1, 1000000 |
|||
Random, y, 1, 1000000 |
|||
gcd(x, y) |
|||
} |
|||
t := QPX(0) ; end timer |
|||
MsgBox, % t " Seconds elapsed.`n" Round(1 / (t / 1000000), 0) " Loop iterations per second." |
|||
QPX( N=0 ) { ; Wrapper for QueryPerformanceCounter()by SKAN | CD: 06/Dec/2009 |
|||
Static F,A,Q,P,X ; www.autohotkey.com/forum/viewtopic.php?t=52083 | LM: 10/Dec/2009 |
|||
If ( N && !P ) |
|||
Return DllCall("QueryPerformanceFrequency",Int64P,F) + (X:=A:=0) + DllCall("QueryPerformanceCounter",Int64P,P) |
|||
DllCall("QueryPerformanceCounter",Int64P,Q), A:=A+Q-P, P:=Q, X:=X+1 |
|||
Return ( N && X=N ) ? (X:=X-1)<<64 : ( N=0 && (R:=A/X/F) ) ? ( R + (A:=P:=X:=0) ) : 1 |
|||
} |
|||
gcd(a, b) { ; Euclidean GCD |
|||
while b |
|||
t := b, b := Mod(a, b), a := t |
|||
return, a |
|||
}</syntaxhighlight> |
|||
'''Output:''' |
|||
<pre>4.428430 Seconds elapsed. |
|||
225814 Loop iterations per second.</pre> |
|||
=={{header|BaCon}}== |
|||
The TIMER builtin returns the elapsed time since start of program run, in milliseconds. |
|||
<syntaxhighlight lang="freebasic">' Rate counter |
|||
FOR i = 1 TO 3 |
|||
GOSUB timeit |
|||
NEXT |
|||
i = 2000 |
|||
GOSUB timeit |
|||
END |
|||
LABEL timeit |
|||
iter = 0 |
|||
starter = TIMER |
|||
WHILE TRUE DO |
|||
INCR iter |
|||
IF TIMER >= starter + i THEN BREAK |
|||
WEND |
|||
PRINT iter, " iterations in ", i, " millisecond", IIF$(i > 1, "s", "") |
|||
RETURN</syntaxhighlight> |
|||
{{out}} |
|||
<pre>prompt$ ./rate-counter |
|||
6169 iterations in 1 millisecond |
|||
16025 iterations in 2 milliseconds |
|||
23977 iterations in 3 milliseconds |
|||
28167202 iterations in 2000 milliseconds</pre> |
|||
=={{header|BASIC256}}== |
|||
{{trans|FreeBASIC}} |
|||
<syntaxhighlight lang="basic256"> |
|||
global i |
|||
subroutine timeit() |
|||
iter = 0 |
|||
starter = msec |
|||
while True |
|||
iter += 1 |
|||
if msec >= starter + i then exit while |
|||
end while |
|||
print iter; " iteraciones en "; i; " milisegundo"; |
|||
if i > 1 then print "s" else print |
|||
end subroutine |
|||
for i = 1 to 3 |
|||
call timeit() |
|||
next i |
|||
i = 200 |
|||
call timeit() |
|||
end |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
660 iteraciones en 1 milisegundo |
|||
932 iteraciones en 2 milisegundos |
|||
1929 iteraciones en 3 milisegundos |
|||
173762 iteraciones en 200 milisegundos |
|||
</pre> |
|||
=={{header|BBC BASIC}}== |
|||
{{works with|BBC BASIC for Windows}} |
|||
<syntaxhighlight lang="bbcbasic"> PRINT "Method 1: Calculate reciprocal of elapsed time:" |
|||
FOR trial% = 1 TO 3 |
|||
start% = TIME |
|||
PROCtasktomeasure |
|||
finish% = TIME |
|||
PRINT "Rate = "; 100 / (finish%-start%) " per second" |
|||
NEXT trial% |
|||
PRINT '"Method 2: Count completed tasks in one second:" |
|||
FOR trial% = 1 TO 3 |
|||
runs% = 0 |
|||
finish% = TIME + 100 |
|||
REPEAT |
|||
PROCtasktomeasure |
|||
IF TIME < finish% runs% += 1 |
|||
UNTIL TIME >= finish% |
|||
PRINT "Rate = "; runs% " per second" |
|||
NEXT trial% |
|||
END |
|||
REM This is an example, replace with the task you want to measure |
|||
DEF PROCtasktomeasure |
|||
LOCAL i% |
|||
FOR i% = 1 TO 1000000 |
|||
NEXT |
|||
ENDPROC</syntaxhighlight> |
|||
'''Sample output:''' |
|||
<pre> |
|||
Method 1: Calculate reciprocal of elapsed time: |
|||
Rate = 9.09090909 per second |
|||
Rate = 9.09090909 per second |
|||
Rate = 9.09090909 per second |
|||
Method 2: Count completed tasks in one second: |
|||
Rate = 9 per second |
|||
Rate = 9 per second |
|||
Rate = 9 per second |
|||
</pre> |
|||
=={{header|C}}== |
=={{header|C}}== |
||
This code stores all of the data of the rate counter and its configuration in an instance of a struct named '''rate_state_s''', and a function named '''tic_rate''' is called on that struct instance every time we complete a job. If a configured time has elapsed, '''tic_rate''' calculates and reports the tic rate, and resets the counter. |
This code stores all of the data of the rate counter and its configuration in an instance of a struct named '''rate_state_s''', and a function named '''tic_rate''' is called on that struct instance every time we complete a job. If a configured time has elapsed, '''tic_rate''' calculates and reports the tic rate, and resets the counter. |
||
< |
<syntaxhighlight lang="c">#include <stdio.h> |
||
#include <time.h> |
#include <time.h> |
||
Line 170: | Line 468: | ||
return 0; |
return 0; |
||
}</ |
}</syntaxhighlight> |
||
=={{header|C++}}== |
=={{header|C++}}== |
||
This code defines the counter as a class, '''CRateState'''. The counter's period is configured as an argument to its constructor, and the rest of the counter state is kept as class members. A member function '''Tick()''' manages updating the counter state, and reports the tic rate if the configured period has elapsed. |
This code defines the counter as a class, '''CRateState'''. The counter's period is configured as an argument to its constructor, and the rest of the counter state is kept as class members. A member function '''Tick()''' manages updating the counter state, and reports the tic rate if the configured period has elapsed. |
||
< |
<syntaxhighlight lang="cpp">#include <iostream> |
||
#include <ctime> |
#include <ctime> |
||
Line 252: | Line 550: | ||
return 0; |
return 0; |
||
}</ |
}</syntaxhighlight> |
||
=={{header|Chipmunk Basic}}== |
|||
{{works with|Chipmunk Basic|3.6.4}} |
|||
<syntaxhighlight lang="vbnet">100 cls |
|||
110 for i = 1 to 3 |
|||
120 gosub 170 |
|||
130 next i |
|||
140 i = 200 |
|||
150 gosub 170 |
|||
160 end |
|||
170 'function timeit |
|||
180 iter = 0 |
|||
190 starter = timer |
|||
200 while true |
|||
210 iter = iter+1 |
|||
220 if timer >= starter+i then exit while |
|||
230 wend |
|||
240 print iter;" iteraciones en ";i;" milisegundo"; |
|||
250 if i > 1 then print "s" else print "" |
|||
260 return</syntaxhighlight> |
|||
=={{header|Common Lisp}}== |
|||
Common Lisp already has a <code>time</code> macro. |
|||
<syntaxhighlight lang="lisp">(time (do some stuff))</syntaxhighlight> will give a timing report about "stuff" on the trace output. We can define something similar with repeats: |
|||
<syntaxhighlight lang="lisp">(defmacro time-this (cnt &rest body) |
|||
(let ((real-t (gensym)) (run-t (gensym))) |
|||
`(let (,real-t ,run-t) |
|||
(setf ,real-t (get-internal-real-time) |
|||
,run-t (get-internal-run-time)) |
|||
(loop repeat ,cnt do ,@body) |
|||
(list (/ (- (get-internal-real-time) ,real-t) |
|||
(coerce internal-time-units-per-second 'float)) |
|||
(/ (- (get-internal-run-time) ,run-t) |
|||
(coerce internal-time-units-per-second 'float))))))</syntaxhighlight> |
|||
Call the <code>time-this</code> macro to excute a loop 99 times: |
|||
<syntaxhighlight lang="lisp">(print (time-this 99 (loop for i below 10000 sum i)))</syntaxhighlight>which gives a pair of numbers, the real time and the run time, both in seconds:<syntaxhighlight lang="text">(0.023 0.022)</syntaxhighlight> |
|||
=={{header|Crystal}}== |
|||
{{trans|Ruby}} |
|||
Testing lookup speed in array versus hash: |
|||
<syntaxhighlight lang="ruby">require "benchmark" |
|||
struct Document |
|||
property :id |
|||
def initialize(@id : Int32) end |
|||
end |
|||
documents_a = [] of Int32 | Document |
|||
documents_h = {} of Int32 => Int32 | Document |
|||
1.upto(10_000) do |n| |
|||
d = Document.new(n) |
|||
documents_a << d |
|||
documents_h[d.id] = d |
|||
end |
|||
searchlist = Array.new(1000){ rand(10_000)+1 } |
|||
Benchmark.bm do |x| |
|||
x.report("array"){searchlist.each{ |el| documents_a.any?{ |d| d == el }} } |
|||
x.report("hash") {searchlist.each{ |el| documents_h.has_key?(el) } } |
|||
end |
|||
puts |
|||
Benchmark.ips do |x| |
|||
x.report("array"){searchlist.each{ |el| documents_a.any?{ |d| d == el }} } |
|||
x.report("hash") {searchlist.each{ |el| documents_h.has_key?(el) } } |
|||
end</syntaxhighlight> |
|||
System: I7-6700HQ, 3.5 GHz, Linux Kernel 5.6.17, Crystal 0.35 |
|||
Run as: $ crystal run ratecounter.cr --release |
|||
{{out}} |
|||
<pre> user system total real |
|||
array 0.006493 0.000736 0.007229 ( 0.007223) |
|||
hash 0.000015 0.000008 0.000023 ( 0.000023) |
|||
array 166.53 ( 6.00ms) (± 1.87%) 0.0B/op 545.27× slower |
|||
hash 90.81k ( 11.01µs) (± 4.16%) 0.0B/op fastest |
|||
</pre> |
|||
=={{header|D}}== |
|||
<syntaxhighlight lang="d"> |
|||
import std.stdio; |
|||
import std.conv; |
|||
import std.datetime.stopwatch; |
|||
int a; |
|||
void f0() {} |
|||
void f1() { auto b = a; } |
|||
void f2() { auto b = to!string(a); } |
|||
void main() |
|||
{ |
|||
auto r = benchmark!(f0, f1, f2)(10_000); |
|||
writeln("Time fx took to run 10,000 times:\n"); |
|||
writeln("f0: ", r[0]); |
|||
writeln("f1: ", r[1]); |
|||
writeln("f2: ", r[2]); |
|||
} |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
Time fx took to run 10,000 times: |
|||
f0: 37 μs and 7 hnsecs |
|||
f1: 56 μs and 2 hnsecs |
|||
f2: 1 ms, 966 μs, and 6 hnsecs |
|||
</pre> |
|||
=={{header|Delphi}}== |
|||
{{libheader| System.SysUtils}} |
|||
{{libheader| System.Diagnostics}} |
|||
{{Trans|D}} |
|||
<syntaxhighlight lang="delphi"> |
|||
program Rate_counter; |
|||
{$APPTYPE CONSOLE} |
|||
uses |
|||
System.SysUtils, |
|||
System.Diagnostics; |
|||
var |
|||
a: Integer; |
|||
function TickToString(Tick: Int64): string; |
|||
var |
|||
ns, us, ms, s, t: Cardinal; |
|||
begin |
|||
Result := ''; |
|||
ns := (Tick mod 10) * 100; |
|||
if ns > 0 then |
|||
Result := format(' %dns', [ns]); |
|||
t := Tick div 10; |
|||
us := t mod 1000; |
|||
if us > 0 then |
|||
Result := format(' %dus', [us]) + Result; |
|||
t := t div 1000; |
|||
ms := t mod 1000; |
|||
if ms > 0 then |
|||
Result := format(' %dms', [ms]) + Result; |
|||
t := t div 1000; |
|||
s := t mod 1000; |
|||
if s > 0 then |
|||
Result := format(' %ds', [s]) + Result; |
|||
end; |
|||
function Benchmark(Fns: TArray<TProc>; times: Cardinal): TArray<string>; |
|||
var |
|||
Stopwatch: TStopwatch; |
|||
fn: TProc; |
|||
i, j: Cardinal; |
|||
begin |
|||
SetLength(result, length(Fns)); |
|||
Stopwatch := TStopwatch.Create; |
|||
for i := 0 to High(Fns) do |
|||
begin |
|||
fn := Fns[i]; |
|||
if not Assigned(fn) then |
|||
Continue; |
|||
Stopwatch.Reset; |
|||
Stopwatch.Start; |
|||
for j := 1 to times do |
|||
fn(); |
|||
Stopwatch.Stop; |
|||
Result[i] := TickToString(Stopwatch.ElapsedTicks); |
|||
end; |
|||
end; |
|||
procedure F0(); |
|||
begin |
|||
end; |
|||
procedure F1(); |
|||
begin |
|||
var b := a; |
|||
end; |
|||
procedure F2(); |
|||
begin |
|||
var b := a.ToString; |
|||
end; |
|||
begin |
|||
writeln('Time fx took to run 10,000 times:'#10); |
|||
var r := Benchmark([F0, F1, F2], 10000); |
|||
for var i := 0 to High(r) do |
|||
writeln('f', i, ': ', r[i]); |
|||
Readln; |
|||
end.</syntaxhighlight> |
|||
{{out}} |
|||
<pre>Time fx took to run 10,000 times: |
|||
f0: 32us 400ns |
|||
f1: 34us 600ns |
|||
f2: 607us 100ns</pre> |
|||
=={{header|E}}== |
=={{header|E}}== |
||
< |
<syntaxhighlight lang="e">def makeLamportSlot := <import:org.erights.e.elib.slot.makeLamportSlot> |
||
The rate counter: |
The rate counter: |
||
Line 278: | Line 783: | ||
return [signal, &rate] |
return [signal, &rate] |
||
}</ |
}</syntaxhighlight> |
||
The test code: |
The test code: |
||
< |
<syntaxhighlight lang="e">/** Dummy task: Retrieve http://localhost/ and return the content. */ |
||
def theJob() { |
def theJob() { |
||
return when (def text := <http://localhost/> <- getText()) -> { |
return when (def text := <http://localhost/> <- getText()) -> { |
||
Line 315: | Line 820: | ||
signal() |
signal() |
||
theJob() |
theJob() |
||
})</ |
})</syntaxhighlight> |
||
=={{header|EasyLang}}== |
|||
[https://easylang.dev/show/#cod=RYzLCsIwEEX3+YpDF+IDyygUV+m/hDZCIA9JB8G/l4SKm8sc5ty7lFgqDxFTMi6H5NQbYIne1XZUt3KxyHhvlMrbMwmTdCnUJfqmNArPLs/7c+9aOo0tFMv22TQkvxdUmPnprxqychMRzhyVKyonDgykbfiPCBY1Pq/mCw== Run it] |
|||
<syntaxhighlight> |
|||
color 700 |
|||
on animate |
|||
clear |
|||
rad += 0.2 |
|||
move 50 50 |
|||
circle rad |
|||
if rad > 50 |
|||
rad = 0 |
|||
. |
|||
t = systime |
|||
if t0 > 0 |
|||
print 1000 * (t - t0) & " ms" |
|||
. |
|||
t0 = t |
|||
end |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
17.00 ms |
|||
17.00 ms |
|||
16.00 ms |
|||
. |
|||
. |
|||
</pre> |
|||
=={{header|Erlang}}== |
|||
Measuring elapsed time is built into the timer module. Doing something during a time period requires code. For normal use the Fun should take a large amount of microseconds, our unit of measurement. |
|||
<syntaxhighlight lang="erlang"> |
|||
-module( rate_counter ). |
|||
-export( [fun_during_seconds/2, task/0] ). |
|||
fun_during_seconds( Fun, Seconds ) -> |
|||
My_pid = erlang:self(), |
|||
Ref = erlang:make_ref(), |
|||
Pid = erlang:spawn( fun() -> fun_during_seconds_loop( My_pid, Fun ) end ), |
|||
timer:send_after( Seconds * 1000, My_pid, {stop, Ref} ), |
|||
N = fun_during_seconds_receive_loop( Ref, Pid, 0 ), |
|||
erlang:exit( Pid, kill ), |
|||
N. |
|||
task() -> |
|||
Results = [timer:tc( fun() -> io:fwrite("Hello, world!~n") end ) || _X <- lists:seq(1, 3)], |
|||
Times = [X || {X, _Returned} <- Results], |
|||
io:fwrite( "Times ~p, average ~p microseconds.~n", [Times, lists:sum(Times) / erlang:length(Times)]), |
|||
N = fun_during_seconds( fun() -> math:sqrt(123) end, 2 ), |
|||
io:fwrite( "Square root of 123, during 2 seconds, was done ~p times.~n", [N] ). |
|||
fun_during_seconds_loop( Pid, Fun ) -> |
|||
Fun(), |
|||
Pid ! {one_time, erlang:self()}, |
|||
fun_during_seconds_loop( Pid, Fun ). |
|||
fun_during_seconds_receive_loop( Ref, Pid, N ) -> |
|||
receive |
|||
{stop, Ref} -> N; |
|||
{one_time, Pid} -> fun_during_seconds_receive_loop( Ref, Pid, N + 1 ) |
|||
end. |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
19> rate_counter:task(). |
|||
Hello, world! |
|||
Hello, world! |
|||
Hello, world! |
|||
Times [54,26,52], average 44.0 microseconds. |
|||
Square root of 123, during 2 seconds, was done 6398906 times. |
|||
</pre> |
|||
=={{header|ERRE}}== |
|||
<syntaxhighlight lang="erre"> |
|||
PROGRAM RATE_COUNTER |
|||
! |
|||
! for rosettacode.org |
|||
! |
|||
! |
|||
! This is an example, replace with the task you want to measure |
|||
! |
|||
PROCEDURE TASK_TO_MEASURE |
|||
LOCAL I |
|||
FOR I=1 TO 1000000 DO |
|||
END FOR |
|||
END PROCEDURE |
|||
BEGIN |
|||
PRINT("Method 1: Calculate reciprocal of elapsed time:") |
|||
FOR TRIAL%=1 TO 3 DO |
|||
START=TIMER |
|||
TASK_TO_MEASURE |
|||
FINISH=TIMER |
|||
PRINT("Rate =";100/(FINISH-START);"per second") |
|||
END FOR |
|||
PRINT("Method 2: Count completed tasks in one minute:") |
|||
FOR TRIAL%=1 TO 3 DO |
|||
RUNS%=0 |
|||
FINISH=TIMER+60 |
|||
REPEAT |
|||
TASK_TO_MEASURE |
|||
IF TIMER<FINISH THEN RUNS%+=1 END IF |
|||
UNTIL TIMER>=FINISH |
|||
PRINT("Rate =";RUNS%;"per minute") |
|||
END FOR |
|||
END PROGRAM |
|||
</syntaxhighlight> |
|||
Time elapsed is measured with TIMER function (taken from computer clock). |
|||
{{out}} |
|||
<pre> |
|||
Method 1: Calculate reciprocal of elapsed time: |
|||
Rate = 25.24655 per second |
|||
Rate = 25.32147 per second |
|||
Rate = 25.6513 per second |
|||
Method 2: Count completed tasks in one minute: |
|||
Rate = 15 per second |
|||
Rate = 15 per second |
|||
Rate = 15 per second |
|||
</pre> |
|||
=={{header|Fortran}}== |
|||
Standard Fortran does not offer facilities for starting another task, nor for monitoring such a task's consumption of cpu time against clock time. However, a program can monitor its ''own'' usage by invoking a suitable routine at appropriate points in its computation, say on each new iteration of its outermost DO-loop, and thus generate progress reports that could also include an estimated time of finishing. This requires access to system timers, usually achieved via invocations of special routines that are often specific to an installation. But F90 introduced the intrinsic <code>CALL CPU_TIME(T)</code> that returns a "processor-dependent approximation of the processor time in seconds" in <code>T</code> a floating-point variable. |
|||
Similarly, an installation may offer local routines to report the date and time, and F90 has introduced an intrinsic that can be invoked as <code>CALL DATE_AND_TIME(VALUES = MARK)</code> where MARK is an eight-element integer array, rather exhaustingly returning year, month, day, minutes from GMT (or UT, ''etc''), hour, minute, second, milliseconds. |
|||
So, in <syntaxhighlight lang="fortran"> DO I = FIRST,LAST |
|||
IF (PROGRESSNOTE((I - FIRST)/(LAST - FIRST + 1.0))) WRITE (6,*) "Reached ",I,", towards ",LAST |
|||
...much computation... |
|||
END DO</syntaxhighlight> |
|||
Function PROGRESSNOTE is invoked at the start of each iteration, with its parameter stating how much progress has been made on a scale of zero to one, with a "zero progress" restarting its timers. The function notes whether sufficient clock time has elapsed since its previous report (more than six seconds, for example) and if so, returns ''true'' after starting an output line with a standard report giving an estimated time to run and an estimated time (and date, if not the current day) of finishing. This line is not terminated; the invoking routine appends its own progress message, tailored to the nature of the task it is working through. For instance, |
|||
<pre> |
|||
Standard progress report|Tailored message. |
|||
ETF + 6·2hrs!@Monday 17/ 7/2017 5:23:25·013am. 0% Dumping Monday 3/ 2/1749. |
|||
ETF + 6·2hrs!@Monday 17/ 7/2017 5:23:37·167am. 0% Dumping Sunday 9/ 3/1749. |
|||
ETF + 6·2hrs!@Monday 17/ 7/2017 5:26:06·383am. 0% Dumping Friday 11/ 4/1749. |
|||
ETF + 6·1hrs!@Monday 17/ 7/2017 5:21:23·397am. 0% Dumping Friday 16/ 5/1749. |
|||
</pre> |
|||
Thus, the human waiting at the computer screen can monitor the rate of progress and know to go for a walk, or not. |
|||
Incidentally, on windows systems at least, frequent invocations of the date and time routine can cause execution to run ''much'' slower, or worse. A loop waiting for the system's DATE_AND_TIME result to attain a specified value will instead cause a crash. |
|||
For another approach, imagine a long-running program, WORKER, that writes various remarks to standard output as it goes, and consider another, TIMESTAMP, that copies from standard input to standard output, prefixing each line with a date and time stamp, perhaps invoked via something like <code>WORKER | TIMESTAMP >Log.txt</code> - the vertical bar an amusing choice to symbolise a horizontal "pipe". When everything finishes, the log file can be analysed to determine the rate of progress. But alas, in the windows world, the stages of a "pipeline" are performed serially, not simultaneously - the vertical bar symbolising this separation. All output from WORKER will be saved in a temporary disc file then when WORKER finishes that file will be fed as input to TIMESTAMP, thereby producing data only on the rate of file input/output. |
|||
=={{header|FreeBASIC}}== |
|||
{{trans|BaCon}} |
|||
<syntaxhighlight lang="freebasic"> |
|||
Dim Shared As Integer i |
|||
Sub timeit |
|||
Dim As Integer iter = 0 |
|||
Dim As Double starter = Timer |
|||
While True |
|||
iter += 1 |
|||
If Timer >= starter + i Then Exit While |
|||
Wend |
|||
Print iter; " iteraciones en"; i; " milisegundo"; Iif(i > 1, "s", "") |
|||
End Sub |
|||
For i = 1 To 3 |
|||
timeit |
|||
Next i |
|||
i = 200 : timeit |
|||
Sleep |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
44804265 iteraciones en 1 milisegundo |
|||
91122566 iteraciones en 2 milisegundos |
|||
137725199 iteraciones en 3 milisegundos |
|||
8426682089 iteraciones en 200 milisegundos |
|||
</pre> |
|||
=={{header|Go}}== |
=={{header|Go}}== |
||
{{trans|C}} |
{{trans|C}} |
||
< |
<syntaxhighlight lang="go">package main |
||
import ( |
import ( |
||
"fmt" |
"fmt" |
||
"rand" |
"math/rand" |
||
"time" |
"time" |
||
) |
) |
||
// |
// representation of time.Time is nanosecond, actual resolution system specific |
||
type rateStateS struct { |
type rateStateS struct { |
||
lastFlush |
lastFlush time.Time |
||
period |
period time.Duration |
||
tickCount int |
tickCount int |
||
} |
} |
||
Line 335: | Line 1,022: | ||
func ticRate(pRate *rateStateS) { |
func ticRate(pRate *rateStateS) { |
||
pRate.tickCount++ |
pRate.tickCount++ |
||
now := time. |
now := time.Now() |
||
if now |
if now.Sub(pRate.lastFlush) >= pRate.period { |
||
// TPS Report |
// TPS Report |
||
tps := 0. |
tps := 0. |
||
if pRate.tickCount > 0 { |
if pRate.tickCount > 0 { |
||
tps = float64(pRate.tickCount) |
tps = float64(pRate.tickCount) / now.Sub(pRate.lastFlush).Seconds() |
||
} |
} |
||
fmt.Println(tps, "tics per second.") |
fmt.Println(tps, "tics per second.") |
||
Line 351: | Line 1,038: | ||
func somethingWeDo() { |
func somethingWeDo() { |
||
time.Sleep(9e7 + rand.Int63n(2e7)) // sleep about .1 second. |
time.Sleep(time.Duration(9e7 + rand.Int63n(2e7))) // sleep about .1 second. |
||
} |
} |
||
func main() { |
func main() { |
||
start := time. |
start := time.Now() |
||
rateWatch := rateStateS{ |
rateWatch := rateStateS{ |
||
lastFlush: start, |
lastFlush: start, |
||
period: |
period: 5 * time.Second, |
||
} |
} |
||
// Loop for twenty seconds |
// Loop for twenty seconds |
||
latest := start |
|||
for latest.Sub(start) < 20*time.Second { |
|||
somethingWeDo() |
somethingWeDo() |
||
ticRate(&rateWatch) |
ticRate(&rateWatch) |
||
latest = time.Now() |
|||
} |
} |
||
}</ |
}</syntaxhighlight> |
||
Output: |
Output: |
||
<pre> |
<pre> |
||
Line 374: | Line 1,063: | ||
9.848572291869138 tics per second. |
9.848572291869138 tics per second. |
||
</pre> |
</pre> |
||
=={{header|Haskell}}== |
|||
This solution returns the time deltas in picosecond resolution. |
|||
<syntaxhighlight lang="haskell"> |
|||
import Control.Monad |
|||
import Control.Concurrent |
|||
import Data.Time |
|||
getTime :: IO DiffTime |
|||
getTime = fmap utctDayTime getCurrentTime |
|||
addSample :: MVar [a] -> a -> IO () |
|||
addSample q v = modifyMVar_ q (return . (v:)) |
|||
timeit :: Int -> IO a -> IO [DiffTime] |
|||
timeit n task = do |
|||
samples <- newMVar [] |
|||
forM_ [0..n] $ \n -> do |
|||
t1 <- getTime |
|||
task |
|||
t2 <- getTime |
|||
addSample samples (t2 - t1) |
|||
readMVar samples |
|||
main = timeit 10 (threadDelay 1000000) |
|||
</syntaxhighlight> |
|||
=={{header|HicEst}}== |
=={{header|HicEst}}== |
||
The script opens a modeless dialog with 3 buttons: "Hits++" to increase Hits, "Count 5 sec" to reset Hits and initialize a delayed call to F5 after 5 sec, "Rate" to display the current rate on the status bar. |
The script opens a modeless dialog with 3 buttons: "Hits++" to increase Hits, "Count 5 sec" to reset Hits and initialize a delayed call to F5 after 5 sec, "Rate" to display the current rate on the status bar. |
||
< |
<syntaxhighlight lang="hicest">CHARACTER prompt='Count "Hits++" for 5 sec, get current rate' |
||
DLG(Button="1:&Hits++", CALL="cb", B="2:&Count 5sec", B="3:&Rate", RC=retcod, TItle=prompt, WIN=hdl) |
DLG(Button="1:&Hits++", CALL="cb", B="2:&Count 5sec", B="3:&Rate", RC=retcod, TItle=prompt, WIN=hdl) |
||
Line 396: | Line 1,112: | ||
SUBROUTINE F5 ! called 5 sec after button "5 sec" |
SUBROUTINE F5 ! called 5 sec after button "5 sec" |
||
WRITE(StatusBar) Hits, "hits last 5 sec" |
WRITE(StatusBar) Hits, "hits last 5 sec" |
||
END</ |
END</syntaxhighlight> |
||
=={{header|J}}== |
=={{header|J}}== |
||
'''Solution'''<br> |
'''Solution'''<br> |
||
< |
<syntaxhighlight lang="j"> x (6!:2) y</syntaxhighlight> |
||
The foreign conjunction <code>6!:2</code> will execute the code <code>y</code> (right argument), <code>x</code> times (left argument) and report the average time in seconds required for one execution. |
The foreign conjunction <code>6!:2</code> will execute the code <code>y</code> (right argument), <code>x</code> times (left argument) and report the average time in seconds required for one execution. |
||
'''Example:''' |
'''Example:''' |
||
< |
<syntaxhighlight lang="j"> list=: 1e6 ?@$ 100 NB. 1 million random integers from 0 to 99 |
||
freqtable=: ~. ,. #/.~ NB. verb to calculate and build frequency table |
freqtable=: ~. ,. #/.~ NB. verb to calculate and build frequency table |
||
20 (6!:2) 'freqtable list' NB. calculate and build frequency table for list, 20 times |
20 (6!:2) 'freqtable list' NB. calculate and build frequency table for list, 20 times |
||
0.00994106</ |
0.00994106</syntaxhighlight> |
||
Note, if instead we want distinct times instead of averaged times we can use a repeated counter for the number of times to execute the code |
Note, if instead we want distinct times instead of averaged times we can use a repeated counter for the number of times to execute the code |
||
< |
<syntaxhighlight lang="j"> 1 1 1 (6!:2) 'freqtable list' |
||
0.0509995 0.0116702 0.0116266</ |
0.0509995 0.0116702 0.0116266</syntaxhighlight> |
||
=={{header|Java}}== |
|||
{{trans|JavaScript}} |
|||
{{works with|Java|8}} |
|||
<syntaxhighlight lang="java">import java.util.function.Consumer; |
|||
public class RateCounter { |
|||
public static void main(String[] args) { |
|||
for (double d : benchmark(10, x -> System.out.print(""), 10)) |
|||
System.out.println(d); |
|||
} |
|||
static double[] benchmark(int n, Consumer<Integer> f, int arg) { |
|||
double[] timings = new double[n]; |
|||
for (int i = 0; i < n; i++) { |
|||
long time = System.nanoTime(); |
|||
f.accept(arg); |
|||
timings[i] = System.nanoTime() - time; |
|||
} |
|||
return timings; |
|||
} |
|||
}</syntaxhighlight> |
|||
<pre>70469.0 |
|||
2047.0 |
|||
1169.0 |
|||
877.0 |
|||
877.0 |
|||
877.0 |
|||
877.0 |
|||
877.0 |
|||
877.0 |
|||
877.0</pre> |
|||
=== Stream based solution === |
|||
{{trans|JavaScript}} |
|||
{{works with|Java|8}} |
|||
<syntaxhighlight lang="java">import java.util.function.IntConsumer; |
|||
import java.util.stream.DoubleStream; |
|||
import static java.lang.System.nanoTime; |
|||
import static java.util.stream.DoubleStream.generate; |
|||
import static java.lang.System.out; |
|||
public interface RateCounter { |
|||
public static void main(final String... arguments) { |
|||
benchmark( |
|||
10, |
|||
x -> out.print(""), |
|||
10 |
|||
) |
|||
.forEach(out::println) |
|||
; |
|||
} |
|||
public static DoubleStream benchmark( |
|||
final int n, |
|||
final IntConsumer consumer, |
|||
final int argument |
|||
) { |
|||
return generate(() -> { |
|||
final long time = nanoTime(); |
|||
consumer.accept(argument); |
|||
return nanoTime() - time; |
|||
}) |
|||
.limit(n) |
|||
; |
|||
} |
|||
}</syntaxhighlight> |
|||
<pre>81431.0 |
|||
3987.0 |
|||
3205.0 |
|||
3081.0 |
|||
3020.0 |
|||
3101.0 |
|||
3040.0 |
|||
3102.0 |
|||
3072.0 |
|||
3060.0</pre> |
|||
=={{header|JavaScript}}== |
=={{header|JavaScript}}== |
||
The ''benchmark'' function below executes a given function n times, calling it with the specified arguments. After execution of all functions, it returns an array with the execution time of each execution, in milliseconds. |
The ''benchmark'' function below executes a given function n times, calling it with the specified arguments. After execution of all functions, it returns an array with the execution time of each execution, in milliseconds. |
||
< |
<syntaxhighlight lang="javascript">function millis() { // Gets current time in milliseconds. |
||
return (new Date()).getTime(); |
return (new Date()).getTime(); |
||
} |
} |
||
Line 430: | Line 1,228: | ||
} |
} |
||
return times; |
return times; |
||
}</ |
}</syntaxhighlight> |
||
=={{header|jq}}== |
|||
'''Works with jq and gojq, that is, the C and Go implementations of jq.''' |
|||
In this entry, the times to compute `x*x*x` are compared with the times to compute `pow(x;3)`. |
|||
Note that jq only has direct access to the system clock ("now"). |
|||
<syntaxhighlight lang=jq> |
|||
def cube: . * . * .; |
|||
def pow3: pow(.; 3); |
|||
def benchmark($n; func; $arg; $calls): |
|||
reduce range(0; $n) as $i ([]; |
|||
now as $_ |
|||
| (range(0; $calls) | ($arg | func)) as $x |
|||
# milliseconds: |
|||
| . + [(now - $_) * 1000 | floor] ) ; |
|||
"Timings (total elapsed time in milliseconds):", |
|||
"cube pow3", |
|||
([benchmark(10; cube; 5; 1e5), benchmark(10; pow3; 5; 1e5)] |
|||
| transpose[] |
|||
| "\(.[0]) \(.[1])" ) |
|||
</syntaxhighlight> |
|||
'''Invocation''': jq -nr -f rate-counter.jq |
|||
{{{output}} |
|||
<pre> |
|||
Timings (total elapsed time in milliseconds): |
|||
cube pow3 |
|||
205 178 |
|||
164 182 |
|||
182 156 |
|||
173 173 |
|||
167 154 |
|||
181 175 |
|||
180 176 |
|||
176 160 |
|||
186 206 |
|||
173 174 |
|||
</pre> |
|||
=={{header|Jsish}}== |
|||
<syntaxhighlight lang="javascript">#!/usr/bin/env jsish |
|||
"use strict"; |
|||
/* Rate counter, timer access, in Jsish */ |
|||
/* System time in milliseconds */ |
|||
var runs = 0, newMs; |
|||
function countJobsIsTheJob() { runs += 1; } |
|||
var milliSeconds = strptime(); |
|||
while ((newMs = strptime()) < (milliSeconds + 1000)) { countJobsIsTheJob(); } |
|||
puts(runs, 'runs in', newMs - milliSeconds, 'ms'); |
|||
/* Builtin times test(callback, runs), result in microseconds */ |
|||
function sleeper() { sleep(10); } |
|||
var timer; |
|||
for (var i = 1; i < 4; i++) { |
|||
timer = times(sleeper, 100); |
|||
puts(timer, 'μs to sleep 10 ms, 100 times'); |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
prompt$ jsish rateCounter.jsi |
|||
81494 runs in 1000 ms |
|||
1019410 μs to sleep 10 ms, 100 times |
|||
1018384 μs to sleep 10 ms, 100 times |
|||
1018984 μs to sleep 10 ms, 100 times</pre> |
|||
=={{header|Julia}}== |
|||
The elapsed() macro in Julia generally is accurate in the nanosecond range. |
|||
<syntaxhighlight lang="julia">dosomething() = sleep(abs(randn())) |
|||
function runNsecondsworthofjobs(N) |
|||
times = Vector{Float64}() |
|||
totaltime = 0 |
|||
runcount = 0 |
|||
while totaltime < N |
|||
t = @elapsed(dosomething()) |
|||
push!(times, t) |
|||
totaltime += t |
|||
runcount += 1 |
|||
end |
|||
println("Ran job $runcount times, for total time of $totaltime seconds.") |
|||
println("Average time per run was $(sum(times)/length(times)) seconds.") |
|||
println("Individual times of the jobs in seconds were:") |
|||
for t in times |
|||
println(" $t") |
|||
end |
|||
end |
|||
runNsecondsworthofjobs(5) |
|||
</syntaxhighlight>{{output}}<pre> Ran job 5 times, for total time of 5.215301074 seconds. |
|||
Average time per run was 1.0430602148 seconds. |
|||
Individual times of the jobs in seconds were: |
|||
1.901202753 |
|||
0.706044625 |
|||
0.485377196 |
|||
0.489283165 |
|||
1.633393335 |
|||
</pre> |
|||
=={{header|Kotlin}}== |
|||
{{trans|JavaScript}} |
|||
<syntaxhighlight lang="scala">// version 1.1.3 |
|||
typealias Func<T> = (T) -> T |
|||
fun cube(n: Int) = n * n * n |
|||
fun <T> benchmark(n: Int, func: Func<T>, arg: T): LongArray { |
|||
val times = LongArray(n) |
|||
for (i in 0 until n) { |
|||
val m = System.nanoTime() |
|||
func(arg) |
|||
times[i] = System.nanoTime() - m |
|||
} |
|||
return times |
|||
} |
|||
fun main(args: Array<String>) { |
|||
println("\nTimings (nanoseconds) : ") |
|||
for (time in benchmark(10, ::cube, 5)) println(time) |
|||
}</syntaxhighlight> |
|||
Sample output: |
|||
<pre> |
|||
154430 |
|||
2100 |
|||
1275 |
|||
1138 |
|||
1063 |
|||
1113 |
|||
1087 |
|||
1088 |
|||
1063 |
|||
1025 |
|||
</pre> |
|||
=={{header|Liberty BASIC}}== |
|||
precision depends on OS. It is 16 (sometines cames as 15) ms for XP and 10 ms for Win2000. |
|||
<syntaxhighlight lang="lb"> |
|||
Print "Rate counter" |
|||
print "Precision: system clock, ms "; |
|||
t0=time$("ms") |
|||
while time$("ms")=t0 'busy loop till click ticks |
|||
wend |
|||
print time$("ms")-t0 |
|||
print |
|||
Print "Run jobs N times, report every time" |
|||
Print "After that, report average time" |
|||
N=10 |
|||
t00=time$("ms") |
|||
for i = 1 to 10 |
|||
scan |
|||
t0=time$("ms") |
|||
'any code we want to measure goes here |
|||
res = testFunc() |
|||
'end of measured code |
|||
t1=time$("ms") |
|||
ElapsedTime = t1-t0 |
|||
print "Job #";i;" Elapsed time, ms ";ElapsedTime, 1000/ElapsedTime; " ticks per second" |
|||
next |
|||
print "---------------------------------" |
|||
print "Average time, ms, is ";(t1-t00)/N, 1000/((t1-t00)/N); " ticks per second" |
|||
print |
|||
print "Run jobs for not less then N seconds (if time up, it'll finish last job)" |
|||
print "After that, report average time" |
|||
NSec=5 |
|||
i = 0 |
|||
t00=time$("ms") |
|||
while time$("ms")<t00+NSec*1000 |
|||
scan |
|||
i = i+1 |
|||
t0=time$("ms") |
|||
'any code we want to measure goes here |
|||
res = testFunc() |
|||
'end of measured code |
|||
t1=time$("ms") |
|||
ElapsedTime = t1-t0 |
|||
print "Job #";i;" Elapsed time, ms ";ElapsedTime, 1000/ElapsedTime; " ticks per second" |
|||
wend |
|||
print "---------------------------------" |
|||
print "Average time, ms, is ";(t1-t00)/i, 1000/((t1-t00)/i); " ticks per second" |
|||
end |
|||
function testFunc() |
|||
s=0 |
|||
for i = 1 to 30000 |
|||
s=s+sin(i)/30000 |
|||
next |
|||
testFunc = s |
|||
end function |
|||
</syntaxhighlight> |
|||
=={{header|Mathematica}}/{{header|Wolfram Language}}== |
|||
The first parameter for both of these functions can be any program code. |
|||
<syntaxhighlight lang="text">jobRateCounted[fn_,Y_Integer]:=First[AbsoluteTiming[Do[fn,{Y}]]/Y; |
|||
SetAttributes[jobRateCounted,HoldFirst] |
|||
jobRatePeriod[fn_,time_]:=Block[{n=0},TimeConstrained[While[True,fn;n++]];n/time]; |
|||
SetAttributes[jobRatePeriod,HoldFirst]</syntaxhighlight> |
|||
=={{header|Nim}}== |
|||
{{trans|Kotlin}} |
|||
<syntaxhighlight lang="nim">import sugar, std/monotimes, times |
|||
type Func[T] = (T) -> T |
|||
func cube(n: int): int = n * n * n |
|||
proc benchmark[T](n: int; f: Func[T]; arg: T): seq[Duration] = |
|||
result.setLen(n) |
|||
for i in 0..<n: |
|||
let m = getMonoTime() |
|||
discard f(arg) |
|||
result[i] = getMonoTime() - m |
|||
echo "Timings (nanoseconds):" |
|||
for time in benchmark(10, cube, 5): |
|||
echo time.inNanoseconds</syntaxhighlight> |
|||
{{out}} |
|||
<pre>Timings (nanoseconds): |
|||
556 |
|||
170 |
|||
88 |
|||
93 |
|||
91 |
|||
93 |
|||
109 |
|||
96 |
|||
91 |
|||
92</pre> |
|||
=={{header|OxygenBasic}}== |
|||
Rate Counter Deluxe, giving start and finish times + duration. The duration is measured in seconds using the system performance counter, resolved to the nearest microsecond. |
|||
<syntaxhighlight lang="oxygenbasic"> |
|||
'======== |
|||
'TIME API |
|||
'======== |
|||
'http://msdn.microsoft.com/en-us/library/windows/desktop/ms724950(v=vs.85).aspx |
|||
extern lib "kernel32.dll" |
|||
type SYSTEMTIME |
|||
WORD wYear |
|||
WORD wMonth |
|||
WORD wDayOfWeek |
|||
WORD wDay |
|||
WORD wHour |
|||
WORD wMinute |
|||
WORD wSecond |
|||
WORD wMilliseconds |
|||
end type |
|||
void GetSystemTime(SYSTEMTIME*t) |
|||
void GetLocalTime(SYSTEMTIME*t) |
|||
void QueryPerformanceCounter(quad*c) |
|||
void QueryPerformanceFrequency(quad*freq) |
|||
void Sleep(sys millisecods) |
|||
end extern |
|||
String WeekDay[7]={"Sunday","Monday","Tuesday","Wednesday", |
|||
"Thursday","Friday","Saturday"} |
|||
String MonthName[12]={"January","February","March","April","May","June", |
|||
"July","August","September","October","November","December"} |
|||
'============== |
|||
Class Jobrecord |
|||
'============== |
|||
has SYSTEMTIME stt |
|||
has SYSTEMTIME fin |
|||
quad countA |
|||
quad CountB |
|||
quad freq |
|||
sys serial |
|||
method pad(string s) as string |
|||
method=s |
|||
if len(method)<2 then method="0"+method |
|||
end method |
|||
method ShowDateTime(sys a,f) as string |
|||
SYSTEMTIME *t |
|||
if a then |
|||
@t=@fin |
|||
else |
|||
@t=@stt |
|||
end if |
|||
' |
|||
String month=pad(str t.wMonth) |
|||
String day=pad(str t.wDay) |
|||
if f=0 then |
|||
return "" t.wYear "-" month "-" day " "+ |
|||
pad(t.wHour) ":" pad(t.wMinute) ":" pad(t.wSecond) ":" t.wMilliSeconds |
|||
elseif f=1 |
|||
return WeekDay[t.wDayOfWeek+1 and 7 ] " " + |
|||
MonthName[t.wMonth and 31] " " day " " t.wYear |
|||
end if |
|||
end method |
|||
method Start() |
|||
QueryPerformanceCounter countA |
|||
QueryPerformanceFrequency freq |
|||
serial++ |
|||
GetLocalTime stt |
|||
end method |
|||
method Finish() |
|||
GetLocalTime fin |
|||
QueryPerformanceCounter countB |
|||
end method |
|||
method ShowDuration() as string |
|||
return str((countB-countA)/freq,6) 'seconds with microsecond resolution |
|||
end method |
|||
method report() as string |
|||
string tab=chr(9), cr=chr(13)+chr(10) |
|||
method="Job:" tab serial cr + |
|||
"Duration:" tab ShowDuration() cr + |
|||
"Start: " tab ShowDateTime(0,0) cr + |
|||
"Finish:" tab ShowDateTime(1,0) cr + |
|||
ShowDateTime(1,1) cr |
|||
end method |
|||
end class |
|||
'#recordof JobRecord |
|||
'==== |
|||
'TEST |
|||
'==== |
|||
JobRecord JR |
|||
JR.start |
|||
sleep 100 'JOB! |
|||
JR.finish |
|||
print JR.Report |
|||
'putfile "s.txt",JR.Report |
|||
' |
|||
'Job: 1 |
|||
'Duration: 0.099026 |
|||
'Start: 2012-07-01 00:52:36:874 |
|||
'Finish: 2012-07-01 00:52:36:974 |
|||
'Sunday July 01 2012 |
|||
</syntaxhighlight> |
|||
=={{header|PARI/GP}}== |
=={{header|PARI/GP}}== |
||
< |
<syntaxhighlight lang="parigp">a=0; |
||
b=0; |
b=0; |
||
for(n=1,20000000, |
for(n=1,20000000, |
||
Line 442: | Line 1,605: | ||
a=a+gettime(); |
a=a+gettime(); |
||
if(a>60000,print(b);a=0;b=0) |
if(a>60000,print(b);a=0;b=0) |
||
)</ |
)</syntaxhighlight> |
||
=={{header|Perl}}== |
=={{header|Perl}}== |
||
The [http://perldoc.perl.org/Benchmark.html Benchmark] module can rate code per time, or per loops executed: |
The [http://perldoc.perl.org/Benchmark.html Benchmark] module can rate code per time, or per loops executed: |
||
< |
<syntaxhighlight lang="perl">use Benchmark; |
||
timethese COUNT,{ 'Job1' => &job1, 'Job2' => &job2 }; |
timethese COUNT,{ 'Job1' => &job1, 'Job2' => &job2 }; |
||
Line 457: | Line 1,620: | ||
{ |
{ |
||
...job2 code... |
...job2 code... |
||
}</ |
}</syntaxhighlight> |
||
A negative COUNT will run each job for at least COUNT seconds.<br> |
A negative COUNT will run each job for at least COUNT seconds.<br> |
||
A positive COUNT will run each job COUNT times. |
A positive COUNT will run each job COUNT times. |
||
=={{header|Phix}}== |
|||
On windows, time() advances in ~0.015s increments, whereas on linux it is ~0.0000016s. |
|||
<!--<syntaxhighlight lang="phix">--> |
|||
<span style="color: #008080;">procedure</span> <span style="color: #000000;">task_to_measure</span><span style="color: #0000FF;">()</span> |
|||
<span style="color: #7060A8;">sleep</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0.1</span><span style="color: #0000FF;">)</span> |
|||
<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span> |
|||
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"method 1: calculate reciprocal of elapsed time:\n"</span><span style="color: #0000FF;">)</span> |
|||
<span style="color: #008080;">for</span> <span style="color: #000000;">trial</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">3</span> <span style="color: #008080;">do</span> |
|||
<span style="color: #004080;">atom</span> <span style="color: #000000;">t</span><span style="color: #0000FF;">=</span><span style="color: #7060A8;">time</span><span style="color: #0000FF;">()</span> |
|||
<span style="color: #000000;">task_to_measure</span><span style="color: #0000FF;">()</span> |
|||
<span style="color: #000000;">t</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">time</span><span style="color: #0000FF;">()-</span><span style="color: #000000;">t</span> |
|||
<span style="color: #004080;">string</span> <span style="color: #000000;">r</span> <span style="color: #0000FF;">=</span> <span style="color: #008080;">iff</span><span style="color: #0000FF;">(</span><span style="color: #000000;">t</span><span style="color: #0000FF;">?</span><span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"%g"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">/</span><span style="color: #000000;">t</span><span style="color: #0000FF;">):</span><span style="color: #008000;">"inf"</span><span style="color: #0000FF;">)</span> |
|||
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"rate = %s per second\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">r</span><span style="color: #0000FF;">})</span> |
|||
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span> |
|||
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"method 2: count completed tasks in one second:\n"</span><span style="color: #0000FF;">)</span> |
|||
<span style="color: #008080;">for</span> <span style="color: #000000;">trial</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">3</span> <span style="color: #008080;">do</span> |
|||
<span style="color: #004080;">integer</span> <span style="color: #000000;">runs</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span> |
|||
<span style="color: #004080;">atom</span> <span style="color: #000000;">finish</span><span style="color: #0000FF;">=</span><span style="color: #7060A8;">time</span><span style="color: #0000FF;">()+</span><span style="color: #000000;">1</span> |
|||
<span style="color: #008080;">while</span> <span style="color: #004600;">true</span> <span style="color: #008080;">do</span> |
|||
<span style="color: #000000;">task_to_measure</span><span style="color: #0000FF;">()</span> |
|||
<span style="color: #008080;">if</span> <span style="color: #7060A8;">time</span><span style="color: #0000FF;">()>=</span><span style="color: #000000;">finish</span> <span style="color: #008080;">then</span> <span style="color: #008080;">exit</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span> |
|||
<span style="color: #000000;">runs</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span> |
|||
<span style="color: #008080;">end</span> <span style="color: #008080;">while</span> |
|||
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"rate = %d per second\n"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">runs</span><span style="color: #0000FF;">)</span> |
|||
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span> |
|||
<!--</syntaxhighlight>--> |
|||
{{out}} |
|||
Of course it fails to achieve the perfect 10/s, due to the overhead of call/ret/time/printf etc. |
|||
<pre> |
|||
method 1: calculate reciprocal of elapsed time: |
|||
rate = 9.17431 per second |
|||
rate = 9.09091 per second |
|||
rate = 9.17431 per second |
|||
method 2: count completed tasks in one second: |
|||
rate = 9 per second |
|||
rate = 9 per second |
|||
rate = 9 per second |
|||
</pre> |
|||
=={{header|Phixmonti}}== |
|||
<syntaxhighlight lang="phixmonti">100000 var iterations |
|||
2 4 2 tolist |
|||
for |
|||
msec var a |
|||
iterations |
|||
for |
|||
over 2 power + drop |
|||
endfor |
|||
msec a - var dif |
|||
"take " print dif print " secs" print |
|||
" or " print iterations dif / print " sums per second" print nl |
|||
endfor</syntaxhighlight> |
|||
=={{header|PicoLisp}}== |
=={{header|PicoLisp}}== |
||
Line 465: | Line 1,683: | ||
microseconds. This can be used, for example, to measure the time between two key |
microseconds. This can be used, for example, to measure the time between two key |
||
strokes |
strokes |
||
< |
<syntaxhighlight lang="picolisp">(prin "Hit a key ... ") |
||
(key) |
(key) |
||
(prinl) |
(prinl) |
||
Line 472: | Line 1,690: | ||
(key) |
(key) |
||
(prinl) |
(prinl) |
||
(prinl "This took " (format (- (usec) Usec) 6) " seconds") )</ |
(prinl "This took " (format (- (usec) Usec) 6) " seconds") )</syntaxhighlight> |
||
Output: |
Output: |
||
<pre>Hit a key ... |
<pre>Hit a key ... |
||
Line 479: | Line 1,697: | ||
The [http://software-lab.de/doc/refB.html#bench bench] benchmark function could |
The [http://software-lab.de/doc/refB.html#bench bench] benchmark function could |
||
also be used. Here we measure the time until a key is pressed |
also be used. Here we measure the time until a key is pressed |
||
<lang |
<syntaxhighlight lang="picolisp">(bench (key))</syntaxhighlight> |
||
<pre>1.761 sec |
<pre>1.761 sec |
||
-> "a"</pre> |
-> "a"</pre> |
||
=={{header|PowerShell}}== |
|||
<syntaxhighlight lang="powershell"> |
|||
[datetime]$start = Get-Date |
|||
[int]$count = 3 |
|||
[timespan[]]$times = for ($i = 0; $i -lt $count; $i++) |
|||
{ |
|||
Measure-Command {0..999999 | Out-Null} |
|||
} |
|||
[datetime]$end = Get-Date |
|||
$rate = [PSCustomObject]@{ |
|||
StartTime = $start |
|||
EndTime = $end |
|||
Duration = ($end - $start).TotalSeconds |
|||
TimesRun = $count |
|||
AverageRunTime = ($times.TotalSeconds | Measure-Object -Average).Average |
|||
} |
|||
$rate | Format-List |
|||
</syntaxhighlight> |
|||
{{Out}} |
|||
<pre> |
|||
StartTime : 10/27/2016 3:33:16 PM |
|||
EndTime : 10/27/2016 3:33:30 PM |
|||
Duration : 13.9062588 |
|||
TimesRun : 3 |
|||
AverageRunTime : 4.63301593333333 |
|||
</pre> |
|||
=={{header|PureBasic}}== |
=={{header|PureBasic}}== |
||
===Counting frequence of an event=== |
===Counting frequence of an event=== |
||
< |
<syntaxhighlight lang="purebasic">Procedure.d TimesPSec(Reset=#False) |
||
Static starttime, cnt |
Static starttime, cnt |
||
Protected Result.d, dt |
Protected Result.d, dt |
||
Line 519: | Line 1,769: | ||
EndIf |
EndIf |
||
Until Event=#PB_Event_CloseWindow |
Until Event=#PB_Event_CloseWindow |
||
EndIf</ |
EndIf</syntaxhighlight> |
||
===Counting events for a time period=== |
===Counting events for a time period=== |
||
< |
<syntaxhighlight lang="purebasic">Procedure DummyThread(arg) |
||
Define.d dummy=#PI*Pow(arg,2)/4 |
Define.d dummy=#PI*Pow(arg,2)/4 |
||
EndProcedure |
EndProcedure |
||
Line 534: | Line 1,784: | ||
msg$="We got "+Str(cnt)+" st."+Chr(10)+StrF(cnt/10,2)+" threads per sec." |
msg$="We got "+Str(cnt)+" st."+Chr(10)+StrF(cnt/10,2)+" threads per sec." |
||
MessageRequester("Counting threads in 10 sec",msg$)</ |
MessageRequester("Counting threads in 10 sec",msg$)</syntaxhighlight> |
||
=={{header|Python}}== |
=={{header|Python}}== |
||
< |
<syntaxhighlight lang="python">import subprocess |
||
import time |
import time |
||
Line 594: | Line 1,844: | ||
taskTimer( int(sys.argv[1]), sys.argv[2:]) |
taskTimer( int(sys.argv[1]), sys.argv[2:]) |
||
main()</ |
main()</syntaxhighlight> |
||
Usage Example: |
Usage Example: |
||
First argument is the number of times to iterate. Additional arguments are command to execute. |
First argument is the number of times to iterate. Additional arguments are command to execute. |
||
<pre>C:>rateCounter.py 20 md5.exe</pre> |
<pre>C:>rateCounter.py 20 md5.exe</pre> |
||
=={{header| |
=={{header|Racket}}== |
||
<syntaxhighlight lang="racket"> |
|||
<lang rexx>/*REXX program reports on the time 4 different tasks take (wall clock)*/ |
|||
#lang racket |
|||
;; Racket has a useful `time*' macro that does just what's requested: |
|||
time.='' /*nullify times for all tasks. */ |
|||
;; run some expression N times, and produce timing results |
|||
(require unstable/time) |
|||
;; Sample use: |
|||
/*----------------------------------------------------------------------*/ |
|||
(define (fib n) (if (<= n 1) n (+ (fib (- n 1)) (fib (- n 2))))) |
|||
call time 'Reset' /*reset the REXX timer. */ |
|||
(time* 10 (fib 38)) |
|||
/*show pi in hexadecimal to */ |
|||
/*2,000 decimal places. */ |
|||
task.1='base(pi,16)' |
|||
call '$CALC' task.1 /*perform task number one. */ |
|||
time.1=time('Elapsed') /*save the time used by task 1. */ |
|||
/*----------------------------------------------------------------------*/ |
|||
call time 'Reset' /*reset the REXX timer. */ |
|||
/*get primes # 40000-->40800 and */ |
|||
/*show their differences. */ |
|||
task.2='diffs[prime(40k,40.8k)] ;;; group 20' |
|||
call '$CALC' task.2 /*perform task number two. */ |
|||
time.2=time('Elapsed') /*save the time used by task 2. */ |
|||
/*----------------------------------------------------------------------*/ |
|||
call time 'Reset' /*reset the REXX timer. */ |
|||
/*show the Collatz sequence for */ |
|||
/*a stupidly big number. */ |
|||
task.3='collatz(38**8) ;;; Horizontal' |
|||
call '$CALC' task.3 /*perform task number three. */ |
|||
time.3=time('Elapsed') /*save the time used by task 3. */ |
|||
/*----------------------------------------------------------------------*/ |
|||
call time 'Reset' /*reset the REXX timer. */ |
|||
/*plot SIN in ½ degree increments*/ |
|||
/*using 9 decimal digits (¬ 60).*/ |
|||
task.4='sind(-180,+180,0.5) ;;; Plot DIGits 9' |
|||
call '$CALC' task.4 /*perform task number four. */ |
|||
time.4=time('Elapsed') /*save the time used by task 4. */ |
|||
/*----------------------------------------------------------------------*/ |
|||
;; But of course, can be used to measure external processes too: |
|||
say |
|||
(time* 10 (system "sleep 1")) |
|||
</syntaxhighlight> |
|||
Sample output: |
|||
do j=1 while time.j\=='' |
|||
<pre> |
|||
say 'time used for task' j "was" right(format(time.j,,0),4) 'seconds.' |
|||
; run #1... -> 39088169 |
|||
end |
|||
; run #2... -> 39088169 |
|||
; run #3... -> 39088169 |
|||
; run #4... -> 39088169 |
|||
; run #5... -> 39088169 |
|||
; run #6... -> 39088169 |
|||
; run #7... -> 39088169 |
|||
; run #8... -> 39088169 |
|||
; run #9... -> 39088169 |
|||
; run #10... -> 39088169 |
|||
; 10 runs, 2 best/worst removed, 6 left for average: |
|||
; cpu time: 778ms = 778ms + 0ms gc; real time: 780ms |
|||
39088169 |
|||
; run #1... -> #t |
|||
; run #2... -> #t |
|||
; run #3... -> #t |
|||
; run #4... -> #t |
|||
; run #5... -> #t |
|||
; run #6... -> #t |
|||
; run #7... -> #t |
|||
; run #8... -> #t |
|||
; run #9... -> #t |
|||
; run #10... -> #t |
|||
; 10 runs, 2 best/worst removed, 6 left for average: |
|||
; cpu time: 3ms = 3ms + 0ms gc; real time: 1007ms |
|||
#t |
|||
</pre> |
|||
=={{header|Raku}}== |
|||
say</lang> |
|||
(formerly Perl 6) |
|||
Output (of the tasks as well as the above REXX timer program): |
|||
<syntaxhighlight lang="raku" line>sub runrate($N where $N > 0, &todo) { |
|||
<pre style="height:50ex;overflow:scroll"> |
|||
my $n = $N; |
|||
╔═════════════╗ |
|||
║ base(pi,16) ║ |
|||
my $start = now; |
|||
╚═════════════╝ |
|||
todo() while --$n; |
|||
my $end = now; |
|||
say "Start time: ", DateTime.new($start).Str; |
|||
say "End time: ", DateTime.new($end).Str; |
|||
my $elapsed = $end - $start; |
|||
say "Elapsed time: $elapsed seconds"; |
|||
say "Rate: { ($N / $elapsed).fmt('%.2f') } per second\n"; |
|||
} |
|||
sub factorial($n) { (state @)[$n] //= $n < 2 ?? 1 !! $n * factorial($n-1) } |
|||
runrate 100_000, { state $n = 1; factorial($n++) } |
|||
runrate 100_000, { state $n = 1; factorial($n++) }</syntaxhighlight> |
|||
{{out}} |
|||
<pre>Start time: 2023-04-19T08:23:50.276418Z |
|||
End time: 2023-04-19T08:23:54.716864Z |
|||
Elapsed time: 4.440445313 seconds |
|||
Rate: 22520.26 per second |
|||
Start time: 2023-04-19T08:23:54.726913Z |
|||
End time: 2023-04-19T08:23:54.798238Z |
|||
Elapsed time: 0.071324057 seconds |
|||
Rate: 1402051.48 per second |
|||
</pre> |
|||
The <tt>Instant</tt> type in Perl 6 is defined to be based on TAI seconds, and represented with rational numbers that are more than sufficiently accurate to represent your clock's accuracy. The actual accuracy will depend on your clock's accuracy (even if you don't have an atomic clock in your kitchen, your smartphone can track various orbiting atomic clocks, right?) modulo the vagaries of returning the atomic time (or unreasonable facsimile) via system calls and library APIs. |
|||
=={{header|REXX}}== |
|||
Programming note: The '''$CALC''' (REXX) program which is invoked below is a general purpose calculator which supports a multitude |
|||
<br>of functions (over 1,500), and can show the results in many different formats (some of which are shown here). |
|||
<syntaxhighlight lang="rexx">/*REXX program reports on the amount of elapsed time 4 different tasks use (wall clock).*/ |
|||
time.= /*nullify times for all the tasks below*/ |
|||
/*──────────────────────────────────────────────────────────────────────────────────────*/ |
|||
call time 'Reset' /*reset the REXX (elapsed) clock timer.*/ |
|||
/*show pi in hex to 2,000 dec. digits.*/ |
|||
task.1= 'base(pi,16) ;;; lowercase digits 2k echoOptions' |
|||
call '$CALC' task.1 /*perform task number one (via $CALC).*/ |
|||
time.1=time('E') /*get and save the time used by task 1.*/ |
|||
/*──────────────────────────────────────────────────────────────────────────────────────*/ |
|||
call time 'Reset' /*reset the REXX (elapsed) clock timer.*/ |
|||
/*get primes 40000 ──► 40800 and */ |
|||
/*show their differences. */ |
|||
task.2= 'diffs[ prime(40k, 40.8k) ] ;;; GRoup 20' |
|||
call '$CALC' task.2 /*perform task number two (via $CALC).*/ |
|||
time.2=time('E') /*get and save the time used by task 2.*/ |
|||
/*──────────────────────────────────────────────────────────────────────────────────────*/ |
|||
call time 'Reset' /*reset the REXX (elapsed) clock timer.*/ |
|||
/*show the Collatz sequence for a */ |
|||
/*stupidly gihugeic number. */ |
|||
task.3= 'Collatz(38**8) ;;; Horizontal' |
|||
call '$CALC' task.3 /*perform task number three (via $CALC)*/ |
|||
time.3=time('E') /*get and save the time used by task 3.*/ |
|||
/*──────────────────────────────────────────────────────────────────────────────────────*/ |
|||
call time 'Reset' /*reset the REXX (elapsed) clock timer.*/ |
|||
/*plot SINE in ½ degree increments.*/ |
|||
/*using five decimal digits (¬ 60). */ |
|||
task.4= 'sinD(-180, +180, 0.5) ;;; Plot DIGits 5 echoOptions' |
|||
call '$CALC' task.4 /*perform task number four (via $CALC).*/ |
|||
time.4=time('E') /*get and save the time used by task 4.*/ |
|||
/*──────────────────────────────────────────────────────────────────────────────────────*/ |
|||
say |
|||
do j=1 while time.j\=='' |
|||
say 'time used for task' j "was" right(format(time.j,,0),4) 'seconds.' |
|||
end /*j*/ |
|||
/*stick a fork in it, we're all done. */</syntaxhighlight> |
|||
'''output''' (of the tasks as well as the above REXX timer program): |
|||
(The terminal screen size used was '''60''' deep x '''100''' wide.) |
|||
3.243F6A8885A308D313198A2E03707344A4093822299F31D0082EFA98EC4E6C89452821E638D01 |
|||
<pre style="height:140ex"> |
|||
377BE5466CF34E90C6CC0AC29B7C97C50DD3F84D5B5B54709179216D5D98979FB1BD1310BA698DF |
|||
╔════════════════════════════════════════════════╗ |
|||
B5AC2FFD72DBD01ADFB7B8E1AFED6A267E96BA7C9045F12C7F9924A19947B3916CF70801F2E2858 |
|||
║ base(pi,16);;; lowercase digits 2k echoOptions ║ |
|||
EFC16636920D871574E69A458FEA3F4933D7E0D95748F728EB658718BCD5882154AEE7B54A41DC2 |
|||
╚════════════════════════════════════════════════╝ |
|||
5A59B59C30D5392AF26013C5D1B023286085F0CA417918B8DB38EF8E79DCB0603A180E6C9E0E8BB |
|||
3.243f6a8885a308d313198a2e03707344a4093822299f31d0082efa98ec4e6c89452821e638d01377be5466cf34e90c6cc |
|||
01E8A3ED71577C1BD314B2778AF2FDA55605C60E65525F3AA55AB945748986263E8144055CA396A |
|||
0ac29b7c97c50dd3f84d5b5b54709179216d5d98979fb1bd1310ba698dfb5ac2ffd72dbd01adfb7b8e1afed6a267e96ba7c |
|||
2AAB10B6B4CC5C341141E8CEA15486AF7C72E993B3EE1411636FBC2A2BA9C55D741831F6CE5C3E1 |
|||
9045f12c7f9924a19947b3916cf70801f2e2858efc16636920d871574e69a458fea3f4933d7e0d95748f728eb658718bcd5 |
|||
69B87931EAFD6BA336C24CF5C7A325381289586773B8F48986B4BB9AFC4BFE81B6628219361D809 |
|||
882154aee7b54a41dc25a59b59c30d5392af26013c5d1b023286085f0ca417918b8db38ef8e79dcb0603a180e6c9e0e8bb0 |
|||
CCFB21A991487CAC605DEC8032EF845D5DE98575B1DC262302EB651B8823893E81D396ACC50F6D6 |
|||
1e8a3ed71577c1bd314b2778af2fda55605c60e65525f3aa55ab945748986263e8144055ca396a2aab10b6b4cc5c341141e |
|||
FF383F442392E0B4482A484200469C8F04A9E1F9B5E21C66842F6E96C9A670C9C61ABD388F06A51 |
|||
8cea15486af7c72e993b3ee1411636fbc2a2ba9c55d741831f6ce5c3e169b87931eafd6ba336c24cf5c7a32538128958677 |
|||
A0D2D8542F68960FA728AB5133A36EEF0B6C137A3BE4BA3BF0507EFB2A98A1F1651D39AF017666C |
|||
3b8f48986b4bb9afc4bfe81b6628219361d809ccfb21a991487cac605dec8032ef845d5de98575b1dc262302eb651b88238 |
|||
A593E82430E888CEE8619456F9FB47D84A5C33B8B5EBEE06F75D885C12073401A449F56C16AA64E |
|||
93e81d396acc50f6d6ff383f442392e0b4482a484200469c8f04a9e1f9b5e21c66842f6e96c9a670c9c61abd388f06a51a0 |
|||
D3AA62363F77061BFEDF72429B023D37D0D724D00A1248DB0FEAD349F1C09B075372C980991B7B2 |
|||
d2d8542f68960fa728ab5133a36eef0b6c137a3be4ba3bf0507efb2a98a1f1651d39af017666ca593e82430e888cee86194 |
|||
5D479D8F6E8DEF7E3FE501AB6794C3B976CE0BD04C006BAC1A94FB6409F60C45E5C9EC2196A2463 |
|||
56f9fb47d84a5c33b8b5ebee06f75d885c12073401a449f56c16aa64ed3aa62363f77061bfedf72429b023d37d0d724d00a |
|||
68FB6FAF3E6C53B51339B2EB3B52EC6F6DFC511F9B30952CCC814544AF5EBD09BEE3D004DE334AF |
|||
1248db0fead349f1c09b075372c980991b7b25d479d8f6e8def7e3fe501ab6794c3b976ce0bd04c006bac1a94fb6409f60c |
|||
D660F2807192E4BB3C0CBA85745C8740FD20B5F39B9D3FBDB5579C0BD1A60320AD6A100C6402C72 |
|||
45e5c9ec2196a246368fb6faf3e6c53b51339b2eb3b52ec6f6dfc511f9b30952ccc814544af5ebd09bee3d004de334afd66 |
|||
79679F25FEFB1FA3CC8EA5E9F8DB3222F83C7516DFFD616B152F501EC8AD0552AB323DB5FAFD238 |
|||
0f2807192e4bb3c0cba85745c8740fd20b5f39b9d3fbdb5579c0bd1a60320ad6a100c6402c7279679f25fefb1fa3cc8ea5e |
|||
76053317B483E00DF829E5C57BBCA6F8CA01A87562EDF1769DBD542A8F6287EFFC3AC6732C68C4F |
|||
9f8db3222f83c7516dffd616b152f501ec8ad0552ab323db5fafd23876053317b483e00df829e5c57bbca6f8ca01a87562e |
|||
5573695B27B0BBCA58C8E1FFA35DB8F011A010FA3D98FD2183B84AFCB56C2DD1D35B9A53E479B6F |
|||
df1769dbd542a8f6287effc3ac6732c68c4f5573695b27b0bbca58c8e1ffa35db8f011a010fa3d98fd2183b84afcb56c2dd |
|||
84565D28E49BC4BFB9790E1DDF2DAA4CB7E3362FB1341CEE4C6E8EF20CADA36774C01D07E9EFE2B |
|||
1d35b9a53e479b6f84565d28e49bc4bfb9790e1ddf2daa4cb7e3362fb1341cee4c6e8ef20cada36774c01d07e9efe2bf11f |
|||
F11FB495DBDA4DAE909198EAAD8E716B93D5A0D08ED1D0AFC725E08E3C5B2F8E7594B78FF6E2FBF |
|||
b495dbda4dae909198eaad8e716b93d5a0d08ed1d0afc725e08e3c5b2f8e7594b78ff6e2fbf2122b648cb209fda49d89455 |
|||
2122B648CB209FDA49D89455E99887A81CF7DC407E83568CDC24FD608C80225F7ADA98BABF283A8 |
|||
e99887a81cf7dc407e83568cdc24fd608c80225f7ada98babf283a8e1b06bbdbb6e99f6b4bc3e795e7be1c57b21085778ab |
|||
E1B06BBDBB6E99F6B4BC3E795E7BE1C57B21085778AB866F897578CEC3600FB01B0789912575FEF |
|||
866f897578cec3600fb01b0789912575fefdc4595bf054658d676f6323cd6db1584bc6747713a2a431395d62de6646642e9 |
|||
DC4595BF054658D676F6323CD6DB1584BC6747713A2A431395D62DE6646642E9A995FB71811B93A |
|||
a995fb71811b93af99e6eb7b169c96740aa3a0f9ea3244ab192f10b595dc3e27cfec33f1341a2830a7a30cc356b0a13aa06 |
|||
F99E6EB7B169C96740AA3A0F9EA3244AB192F10B595DC3E27CFEC33F1341A2830A7A30CC356B0A1 |
|||
a5cffb2b87f9ae0dac27c0f649d4b5f0339 |
|||
3AA06A5CFFB2B87F9AE0DAC27C0F649D4B5F0339 |
|||
╔════════════════════════════╗ |
|||
║ diffs[prime(40k,40.8k)] ║ |
║ diffs[ prime(40k, 40.8k) ] ║ |
||
╚════════════════════════════╝ |
|||
1► 30 12 2 4 14 42 4 2 4 20 4 2 10 2 10 20 10 6 6 20 |
1► 30 12 2 4 14 42 4 2 4 20 4 2 10 2 10 20 10 6 6 20 |
||
21► 10 14 10 2 34 6 78 12 18 12 12 2 6 18 6 6 4 8 18 10 |
21► 10 14 10 2 34 6 78 12 18 12 12 2 6 18 6 6 4 8 18 10 |
||
Line 716: | Line 2,039: | ||
761► 28 2 16 2 16 12 12 2 16 12 2 24 40 6 8 6 4 30 8 10 |
761► 28 2 16 2 16 12 12 2 16 12 2 24 40 6 8 6 4 30 8 10 |
||
781► 14 18 6 16 18 6 2 18 4 6 6 26 4 26 28 26 24 4 32 6 |
781► 14 18 6 16 18 6 2 18 4 6 6 26 4 26 28 26 24 4 32 6 |
||
╔════════════════╗ |
╔════════════════╗ |
||
║ |
║ Collatz(38**8) ║ |
||
╚════════════════╝ |
╚════════════════╝ |
||
4347792138496 2173896069248 1086948034624 543474017312 271737008656 |
4347792138496 2173896069248 1086948034624 543474017312 271737008656 135868504328 67934252164 |
||
33967126082 16983563041 50950689124 25475344562 12737672281 38213016844 19106508422 |
|||
135868504328 67934252164 33967126082 16983563041 50950689124 |
|||
9553254211 28659762634 14329881317 42989643952 21494821976 10747410988 5373705494 |
|||
25475344562 12737672281 38213016844 19106508422 9553254211 |
|||
2686852747 8060558242 4030279121 12090837364 6045418682 3022709341 9068128024 |
|||
28659762634 14329881317 42989643952 21494821976 10747410988 |
|||
4534064012 2267032006 1133516003 3400548010 1700274005 5100822016 2550411008 |
|||
5373705494 2686852747 8060558242 4030279121 12090837364 |
|||
1275205504 637602752 318801376 159400688 79700344 39850172 19925086 |
|||
6045418682 3022709341 9068128024 4534064012 2267032006 |
|||
9962543 29887630 14943815 44831446 22415723 67247170 33623585 |
|||
1133516003 3400548010 1700274005 5100822016 2550411008 |
|||
100870756 50435378 25217689 75653068 37826534 18913267 56739802 |
|||
1275205504 637602752 318801376 159400688 79700344 |
|||
28369901 85109704 42554852 21277426 10638713 31916140 15958070 |
|||
7979035 23937106 11968553 35905660 17952830 8976415 26929246 |
|||
13464623 40393870 20196935 60590806 30295403 90886210 45443105 |
|||
136329316 68164658 34082329 102246988 51123494 25561747 76685242 |
|||
38342621 115027864 57513932 28756966 14378483 43135450 21567725 |
|||
64703176 32351588 16175794 8087897 24263692 12131846 6065923 |
|||
18197770 9098885 27296656 13648328 6824164 3412082 1706041 |
|||
5118124 2559062 1279531 3838594 1919297 5757892 2878946 |
|||
1439473 4318420 2159210 1079605 3238816 1619408 809704 |
|||
404852 202426 101213 303640 151820 75910 37955 |
|||
113866 56933 170800 85400 42700 21350 10675 |
|||
32026 16013 48040 24020 12010 6005 18016 |
|||
9008 4504 2252 1126 563 1690 845 |
|||
2536 1268 634 317 952 476 238 |
|||
119 358 179 538 269 808 404 |
|||
202 101 304 152 76 38 19 |
|||
58 29 88 44 22 11 34 |
|||
17 52 26 13 40 20 10 |
|||
5 16 8 4 2 1 |
|||
╔════════════════════════════════════════════════════╗ |
|||
48040 24020 12010 6005 18016 |
|||
║ sinD(-180, +180, 0.5);;; Plot DIGits 5 echoOptions ║ |
|||
╚════════════════════════════════════════════════════╝ |
|||
1690 845 2536 1268 634 |
|||
│1 ∙∙∙∙∙∙ |
|||
│ ∙∙∙ ∙∙∙ |
|||
│ ∙∙∙ ∙∙∙ |
|||
│ ∙∙ ∙∙ |
|||
│ ∙∙ ∙∙ |
|||
│ ∙∙ ∙∙ |
|||
│ ∙∙ ∙∙ |
|||
│ ∙ ∙ |
|||
│ ∙ ∙ |
|||
│ |
│ ∙∙ ∙∙ |
||
│ ∙∙ ∙∙ |
│ ∙∙ ∙∙ |
||
│ |
│ ∙ ∙ |
||
│ |
│ ∙∙ ∙∙ |
||
│ |
│ ∙ ∙∙ |
||
│ |
│ ∙ ∙ |
||
│ ∙∙ ∙∙ |
│ ∙∙ ∙∙ |
||
│ ∙ ∙ |
│ ∙ ∙ |
||
│ |
│ ∙∙ ∙∙ |
||
│ |
│ ∙ ∙ |
||
│ |
│ ∙∙ ∙ |
||
│ ∙ ∙ |
│ ∙ ∙ |
||
│ |
│ ∙ ∙ |
||
│ |
│ ∙∙ ∙∙ |
||
│ |
│ ∙ ∙ |
||
│ |
│ ∙∙ ∙∙ |
||
│ |
│ ∙ ∙ |
||
│ |
│ ∙∙ ∙∙ |
||
│ ∙ ∙ |
│ ∙ ∙ |
||
│0 ∙∙ ∙∙ |
|||
∙──────────────────────────────────────────────∙──────────────────────────────────────────────∙ |
|||
│ ∙ ∙ |
|||
∙∙ ∙∙ 721 |
|||
│∙ ∙ |
|||
∙──────────────────────────────────────∙──────────────────────────────────────∙ |
|||
│∙∙ ∙∙ |
|||
│ ∙ ∙ |
|||
│ |
│ ∙∙ ∙∙ |
||
│ ∙ ∙ |
│ ∙ ∙ |
||
│ ∙ ∙∙ |
│ ∙ ∙∙ |
||
│ ∙∙ ∙ |
│ ∙∙ ∙ |
||
│ ∙ |
│ ∙ ∙∙ |
||
│ ∙∙ |
│ ∙∙ ∙ |
||
│ ∙ ∙ |
│ ∙ ∙ |
||
│ ∙∙ ∙∙ |
│ ∙∙ ∙∙ |
||
│ |
│ ∙ ∙ |
||
│ |
│ ∙∙ ∙∙ |
||
│ |
│ ∙ ∙ |
||
│ |
│ ∙ ∙∙ |
||
│ |
│ ∙∙ ∙∙ |
||
│ |
│ ∙ ∙ |
||
│ |
│ ∙ ∙∙ |
||
│ ∙∙ ∙∙ |
│ ∙∙ ∙∙ |
||
│ ∙∙ ∙ |
│ ∙∙ ∙ |
||
│ |
│ ∙ ∙∙ |
||
│ |
│ ∙∙ ∙∙ |
||
│ |
│ ∙∙ ∙∙ |
||
│ |
│ ∙∙ ∙∙ |
||
│ ∙∙ ∙∙ |
|||
│ ∙∙∙ ∙∙ |
|||
│ ∙∙∙ ∙∙∙ |
|||
│-1 ∙∙∙∙∙∙ |
|||
time used for task 1 was 0 seconds. |
time used for task 1 was 0 seconds. |
||
time used for task 2 was |
time used for task 2 was 2 seconds. |
||
time used for task 3 was 0 seconds. |
time used for task 3 was 0 seconds. |
||
time used for task 4 was |
time used for task 4 was 0 seconds. |
||
</pre> |
</pre> |
||
=={{header|Ring}}== |
|||
<syntaxhighlight lang="ring"> |
|||
# Project : Rate counter |
|||
see "method 1: calculate reciprocal of elapsed time:" + nl |
|||
for trial = 1 to 3 |
|||
start = clock() |
|||
tasktomeasure() |
|||
finish = clock() |
|||
see "rate = " + 100 / (finish-start) + " per second" + nl |
|||
next |
|||
see "method 2: count completed tasks in one second:" + nl |
|||
for trial = 1 to 3 |
|||
runs = 0 |
|||
finish = clock() + 100 |
|||
while clock() < finish |
|||
tasktomeasure() |
|||
if clock() < finish |
|||
runs = runs + 1 |
|||
ok |
|||
end |
|||
see "rate = " + runs + " per second" + nl |
|||
next |
|||
func tasktomeasure |
|||
for i = 1 to 100000 |
|||
next |
|||
</syntaxhighlight> |
|||
Output: |
|||
<pre> |
|||
method 1: calculate reciprocal of elapsed time: |
|||
rate = 6.67 per second |
|||
rate = 6.25 per second |
|||
rate = 6.67 per second |
|||
method 2: count completed tasks in one second: |
|||
rate = 5 per second |
|||
rate = 6 per second |
|||
rate = 5 per second |
|||
</pre> |
|||
=={{header|Ruby}}== |
|||
Testing lookup speed in array versus hash: |
|||
<syntaxhighlight lang="ruby">require 'benchmark' |
|||
Document = Struct.new(:id,:a,:b,:c) |
|||
documents_a = [] |
|||
documents_h = {} |
|||
1.upto(10_000) do |n| |
|||
d = Document.new(n) |
|||
documents_a << d |
|||
documents_h[d.id] = d |
|||
end |
|||
searchlist = Array.new(1000){ rand(10_000)+1 } |
|||
Benchmark.bm(10) do |x| |
|||
x.report('array'){searchlist.each{|el| documents_a.any?{|d| d.id == el}} } |
|||
x.report('hash'){searchlist.each{|el| documents_h.has_key?(el)} } |
|||
end</syntaxhighlight> |
|||
System: I7-6700HQ, 3.5 GHz, Linux Kernel 5.6.17, Ruby 2.7.1 |
|||
Run as: $ ruby ratecounter.rb |
|||
{{Output}} |
|||
<pre> |
|||
user system total real |
|||
array 0.308848 0.037154 0.346002 ( 0.158290) |
|||
hash 0.005239 0.001036 0.006275 ( 0.002252) |
|||
➜ rosettacode |
|||
</pre> |
|||
=={{header|Run BASIC}}== |
|||
<syntaxhighlight lang="runbasic">html "<table bgcolor=wheat border=1><tr><td align=center colspan=2>Rate Counter</td></tr> |
|||
<tr><td>Run Job Times</td><td>" |
|||
textbox #runTimes,"10",3 |
|||
html "</tr><tr><td align=center colspan=2>" |
|||
button #r,"Run", [runIt] |
|||
html " " |
|||
button #a, "Average", [ave] |
|||
html "</td></tr></table>" |
|||
wait |
|||
[runIt] |
|||
runTimes = min(10,val(#runTimes contents$())) |
|||
count = count + 1 |
|||
print "-------- Run Number ";count;" ----------------" |
|||
print "Run jobs";runTimes;" times, reporting each" |
|||
for i = 1 to runTimes |
|||
' ----------------------------------------------------------------- |
|||
' Normally we use a RUN() command to run another program |
|||
' but for test pruporse we have a routine that simply loops a bunch |
|||
' ----------------------------------------------------------------- |
|||
begTime = time$("ms") |
|||
theRun = bogusProg() |
|||
endTime = time$("ms") |
|||
lapsTime = endTime - begTime |
|||
print "Job #";i;" Elapsed time, ms ";lapsTime;" ";1000/lapsTime; " ticks per second" |
|||
next |
|||
aveTime = (endTime-startTime)/runTimes |
|||
totAveTime = totAveTime + aveTime |
|||
print "Average time, ms, is ";aveTime;" "; 1000/((endTime-startTime)/runTimes); " ticks per second" |
|||
wait |
|||
[ave] |
|||
print "---------------------------------" |
|||
print "Total average time:";aveTime/count |
|||
function bogusProg() |
|||
for i = 1 to 10000 |
|||
sini = sini + sin(i) |
|||
tani = tani + tan(i) |
|||
cpsi = cosi + cos(i) |
|||
next |
|||
end function </syntaxhighlight> |
|||
Output: |
|||
<table bgcolor=wheat border=1><tr><td align=center colspan=2>Rate Counter</td></tr> |
|||
<tr><td>Run Job Times</td><td bgcolor=white>10</td></tr> |
|||
<tr><td align=center colspan=2> |
|||
<button value="Run"/> |
|||
<button value="Average"/></td></tr></table> |
|||
.-------- Run Number 1 ----------------<br /> |
|||
Run jobs 2 times, reporting each<br /> |
|||
Job #1 Elapsed time, ms 50 20 ticks per second<br /> |
|||
Job #2 Elapsed time, ms 48 20.8333349 ticks per second<br /> |
|||
Average time, ms, is 1754768605184 5.69875717e-10 ticks per second<br /> |
|||
.-------- Run Number 2 ----------------<br /> |
|||
Run jobs 3 times, reporting each<br /> |
|||
Job #1 Elapsed time, ms 47 21.2765955 ticks per second<br /> |
|||
Job #2 Elapsed time, ms 47 21.2765955 ticks per second<br /> |
|||
Job #3 Elapsed time, ms 47 21.2765955 ticks per second<br /> |
|||
Average time, ms, is 1169845780480 8.54813575e-10 ticks per second<br /> |
|||
.---------------------------------<br /> |
|||
Total average time:584922890240<br /> |
|||
=={{header|Scala}}== |
=={{header|Scala}}== |
||
Line 816: | Line 2,280: | ||
once the time is up. |
once the time is up. |
||
< |
<syntaxhighlight lang="scala">def task(n: Int) = Thread.sleep(n * 1000) |
||
def rate(fs: List[() => Unit]) = { |
def rate(fs: List[() => Unit]) = { |
||
val jobs = fs map (f => scala.actors.Futures.future(f())) |
val jobs = fs map (f => scala.actors.Futures.future(f())) |
||
Line 827: | Line 2,291: | ||
} |
} |
||
rate(List.fill(30)(() => task(scala.util.Random.nextInt(10)+1))) |
rate(List.fill(30)(() => task(scala.util.Random.nextInt(10)+1))) |
||
</syntaxhighlight> |
|||
</lang> |
|||
The solution below runs a task repeatedly, for at most N seconds or Y times. The |
The solution below runs a task repeatedly, for at most N seconds or Y times. The |
||
Line 834: | Line 2,298: | ||
result, if the time runs out. |
result, if the time runs out. |
||
< |
<syntaxhighlight lang="scala">def rate(n: Int, y: Int)(task: => Unit) { |
||
val startTime = System.currentTimeMillis |
val startTime = System.currentTimeMillis |
||
var currTime = startTime |
var currTime = startTime |
||
Line 848: | Line 2,312: | ||
println("Rate %d times in %.3f seconds" format (y, (currTime - startTime).toDouble / 1000)) |
println("Rate %d times in %.3f seconds" format (y, (currTime - startTime).toDouble / 1000)) |
||
} |
} |
||
rate(5, 20)(task(2))</ |
rate(5, 20)(task(2))</syntaxhighlight> |
||
=={{header|Sidef}}== |
|||
{{trans|Perl}} |
|||
<syntaxhighlight lang="ruby">var benchmark = frequire('Benchmark'); |
|||
func job1 { |
|||
#...job1 code... |
|||
} |
|||
func job2 { |
|||
#...job2 code... |
|||
} |
|||
const COUNT = -1; # run for one CPU second |
|||
benchmark.timethese(COUNT, Hash.new('Job1' => job1, 'Job2' => job2));</syntaxhighlight> |
|||
=={{header|Smalltalk}}== |
|||
{{works with|Pharo}} |
|||
{{works with|Smalltalk/X}} |
|||
<syntaxhighlight lang="smalltalk">|times| |
|||
times := Bag new. |
|||
1 to: 10 do: [:n| times add: |
|||
(Time millisecondsToRun: [3000 factorial])]. |
|||
Transcript show: times average asInteger.</syntaxhighlight> |
|||
Output: |
|||
<pre>153</pre> |
|||
=={{header|Tcl}}== |
=={{header|Tcl}}== |
||
The standard Tcl mechanism to measure how long a piece of code takes to execute is the <code>time</code> command. The first word of the string returned (which is also always a well-formed list) is the number of microseconds taken (in absolute time, not CPU time). Tcl uses the highest performance calibrated time source available on the system to compute the time taken; on Windows, this is derived from the system performance counter and not the (poor quality) standard system time source. |
The standard Tcl mechanism to measure how long a piece of code takes to execute is the <code>time</code> command. The first word of the string returned (which is also always a well-formed list) is the number of microseconds taken (in absolute time, not CPU time). Tcl uses the highest performance calibrated time source available on the system to compute the time taken; on Windows, this is derived from the system performance counter and not the (poor quality) standard system time source. |
||
< |
<syntaxhighlight lang="tcl">set iters 10 |
||
# A silly example task |
# A silly example task |
||
Line 867: | Line 2,356: | ||
}] 0] |
}] 0] |
||
puts "task took $t microseconds on iteration $i" |
puts "task took $t microseconds on iteration $i" |
||
}</ |
}</syntaxhighlight> |
||
When tasks are are very quick, a more accurate estimate of the time taken can be gained by repeating the task many times between time measurements. In this next example, the task (a simple assignment) is repeated a million times between measures (this is very useful when performing performance analysis of the Tcl implementation itself). |
When tasks are are very quick, a more accurate estimate of the time taken can be gained by repeating the task many times between time measurements. In this next example, the task (a simple assignment) is repeated a million times between measures (this is very useful when performing performance analysis of the Tcl implementation itself). |
||
< |
<syntaxhighlight lang="tcl">puts [time { set aVar 123 } 1000000]</syntaxhighlight> |
||
=={{header|UNIX Shell}}== |
=={{header|UNIX Shell}}== |
||
Line 877: | Line 2,366: | ||
<br> |
<br> |
||
This script spins, executing '''task''' as many times as possible. |
This script spins, executing '''task''' as many times as possible. |
||
< |
<syntaxhighlight lang="bash">#!/bin/bash |
||
while : ; do |
while : ; do |
||
task && echo >> .fc |
task && echo >> .fc |
||
done</ |
done</syntaxhighlight> |
||
Part 2: |
Part 2: |
||
<br> |
<br> |
||
This script runs '''foo.sh''' in the background, and checks the rate count file every five seconds. After four such checks, twenty seconds will have elapsed. |
This script runs '''foo.sh''' in the background, and checks the rate count file every five seconds. After four such checks, twenty seconds will have elapsed. |
||
< |
<syntaxhighlight lang="bash">./foo.sh & |
||
sleep 5 |
sleep 5 |
||
mv .fc .fc2 2>/dev/null |
mv .fc .fc2 2>/dev/null |
||
Line 900: | Line 2,389: | ||
killall foo.sh |
killall foo.sh |
||
wc -l .fc 2>/dev/null |
wc -l .fc 2>/dev/null |
||
rm .fc</ |
rm .fc</syntaxhighlight> |
||
=={{header|V (Vlang)}}== |
|||
{{trans|Go}} |
|||
<syntaxhighlight lang="v (vlang)">import rand |
|||
import time |
|||
// representation of time.Time is nanosecond, actual resolution system specific |
|||
struct RateStateS { |
|||
mut: |
|||
last_flush time.Time |
|||
period time.Duration |
|||
tick_count int |
|||
} |
|||
fn (mut p_rate RateStateS) tic_rate() { |
|||
p_rate.tick_count++ |
|||
now := time.now() |
|||
if now-p_rate.last_flush >= p_rate.period { |
|||
// TPS Report |
|||
mut tps := 0.0 |
|||
if p_rate.tick_count > 0 { |
|||
tps = f64(p_rate.tick_count) / (now-p_rate.last_flush).seconds() |
|||
} |
|||
println("$tps tics per second.") |
|||
// Reset |
|||
p_rate.tick_count = 0 |
|||
p_rate.last_flush = now |
|||
} |
|||
} |
|||
fn something_we_do() { |
|||
time.sleep(time.Duration(i64(9e7) + rand.i64n(i64(2e7)) or {i64(0)})) // sleep about .1 second. |
|||
} |
|||
fn main() { |
|||
start := time.now() |
|||
mut rate_watch := RateStateS{ |
|||
last_flush: start, |
|||
period: 5 * time.second, |
|||
} |
|||
// Loop for twenty seconds |
|||
mut latest := start |
|||
for latest-start < 20*time.second { |
|||
something_we_do() |
|||
rate_watch.tic_rate() |
|||
latest = time.now() |
|||
} |
|||
}</syntaxhighlight> |
|||
Output: |
|||
<pre> |
|||
10.029074483576407 tics per second. |
|||
9.946060524563189 tics per second. |
|||
9.97480364599023 tics per second. |
|||
</pre> |
|||
=={{header|Wren}}== |
|||
{{trans|Kotlin}} |
|||
For bench-marking purposes, Wren uses the ''System.clock'' method which returns the number of seconds (to 6 decimal places) since the script was started. |
|||
The precision of ''System.clock'' is not documented but since it calls C's ''clock()'' function in <timer.h> in the background it will certainly be no more than 1 microsecond and, in practice, resolution may be no better than 10 milliseconds on many systems. |
|||
Note that, in an attempt to obtain more meaningful times, I've called the function 1 million times compared to just one in the Kotlin example which uses a more accurate timer. |
|||
<syntaxhighlight lang="wren">var cube = Fn.new { |n| n * n * n } |
|||
var benchmark = Fn.new { |n, func, arg, calls| |
|||
var times = List.filled(n, 0) |
|||
for (i in 0...n) { |
|||
var m = System.clock |
|||
for (j in 0...calls) func.call(arg) |
|||
times[i] = ((System.clock - m) * 1000).round // milliseconds |
|||
} |
|||
return times |
|||
} |
|||
System.print("Timings (milliseconds) : ") |
|||
for (time in benchmark.call(10, cube, 5, 1e6)) System.print(time)</syntaxhighlight> |
|||
{{out}} |
|||
Sample run: |
|||
<pre> |
|||
Timings (milliseconds) : |
|||
55 |
|||
48 |
|||
45 |
|||
45 |
|||
45 |
|||
45 |
|||
45 |
|||
45 |
|||
45 |
|||
46 |
|||
</pre> |
|||
=={{header|XPL0}}== |
|||
<syntaxhighlight lang="xpl0">include c:\cxpl\codes; \intrinsic 'code' declarations |
|||
int N, I, T0, Time; |
|||
[for N:= 1, 3 do |
|||
[T0:= GetTime; |
|||
for I:= 1 to 100 do |
|||
[while port($3DA) & $08 do []; \wait for vertical retrace to go away |
|||
repeat until port($3DA) & $08; \wait for vertical retrace signal |
|||
]; |
|||
Time:= GetTime - T0; |
|||
IntOut(0, Time); Text(0, " microseconds for 100 samples = "); |
|||
RlOut(0, 100.0e6/float(Time)); Text(0, "Hz"); CrLf(0); |
|||
]; |
|||
]</syntaxhighlight> |
|||
Example output of vertical blanking (screen refresh) rates: |
|||
<pre> |
|||
These measurements were taken while running under DOS 5.0 with the |
|||
output redirected to a file. When the output is instead displayed on the |
|||
screen, the second two readings consistently match for the first five |
|||
digits. The first reading varies because the program (purposely) does not |
|||
sync up on the retrace signal before starting the measurements. |
|||
1682024 microseconds for 100 samples = 59.45218Hz |
|||
1683980 microseconds for 100 samples = 59.38313Hz |
|||
1689918 microseconds for 100 samples = 59.17447Hz |
|||
These measurements were taken on a Windows XP machine running in windowed mode: |
|||
1384184 microseconds for 100 samples = 72.24473Hz |
|||
1355413 microseconds for 100 samples = 73.77825Hz |
|||
1326029 microseconds for 100 samples = 75.41313Hz |
|||
These measurements were taken on the same Windows machine in full-screen mode: |
|||
1418413 microseconds for 100 samples = 70.50133Hz |
|||
1424391 microseconds for 100 samples = 70.20544Hz |
|||
1395069 microseconds for 100 samples = 71.68104Hz |
|||
</pre> |
|||
=={{header|Yabasic}}== |
|||
<syntaxhighlight lang="yabasic">iterations = 100000 |
|||
for j = 2 to 4 |
|||
a = peek("millisrunning") |
|||
for i = 1 to iterations |
|||
void = i + j^2 |
|||
next |
|||
dif = peek("millisrunning") - a |
|||
print "take ", dif, " ms"; |
|||
print " or ", iterations / dif * 1000 using "########", " sums per second" |
|||
next</syntaxhighlight> |
|||
=={{header|zkl}}== |
|||
One second resolution and we let the computation run to completion. We could run the computation in a thread and signal it if time is up but that doesn't seem reasonable. |
|||
<syntaxhighlight lang="zkl">fcn rateCounter(f,timeNRuns,secsToRun=Void){ |
|||
now:=Time.Clock.time; |
|||
if(secsToRun){ |
|||
then:=now + secsToRun; |
|||
N:=0; do{ f(); N+=1; }while(Time.Clock.time<then); |
|||
t:=Time.Clock.time - now; |
|||
println("%d runs in %s seconds = %.3f sec/run" |
|||
.fmt(N,Time.Date.toHMSString(0,0,t),t.toFloat()/N)); |
|||
} |
|||
else{ |
|||
do(timeNRuns){ f() } |
|||
t:=Time.Clock.time - now; |
|||
println("%s seconds to run %d times = %.3f sec/run" |
|||
.fmt(Time.Date.toHMSString(0,0,t),timeNRuns, |
|||
t.toFloat()/timeNRuns)); |
|||
t |
|||
} |
|||
}</syntaxhighlight> |
|||
<syntaxhighlight lang="zkl">ns:=List.createLong(0d100_000,(0).random,True); // one hundred thousand ints |
|||
rateCounter('wrap(){ ns.copy().sort() },20); |
|||
rateCounter('wrap(){ ns.copy().sort() },Void,10);</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
00:00:19 seconds to run 20 times = 0.950 sec/run |
|||
11 runs in 00:00:10 seconds = 0.909 sec/run |
|||
</pre> |
Latest revision as of 20:34, 28 April 2024
![Task](http://static.miraheze.org/rosettacodewiki/thumb/b/ba/Rcode-button-task-crushed.png/64px-Rcode-button-task-crushed.png)
You are encouraged to solve this task according to the task description, using any language you may know.
Counting the frequency at which something occurs is a common activity in measuring performance and managing resources. In this task, we assume that there is some job which we want to perform repeatedly, and we want to know how quickly these jobs are being performed.
Of interest is the code that performs the actual measurements. Any other code (such as job implementation or dispatching) that is required to demonstrate the rate tracking is helpful, but not the focus.
Multiple approaches are allowed (even preferable), so long as they can accomplish these goals:
- Run N seconds worth of jobs and/or Y jobs.
- Report at least three distinct times.
Be aware of the precision and accuracy limitations of your timing mechanisms, and document them if you can.
See also: System time, Time a function
Action!
INCLUDE "D2:REAL.ACT" ;from the Action! Tool Kit
DEFINE PTR="CARD"
CARD FUNC GetFrame()
BYTE RTCLOK1=$13,RTCLOK2=$14
CARD res
BYTE lsb=res,msb=res+1
lsb=RTCLOK2
msb=RTCLOK1
RETURN (res)
CARD FUNC FramesToMs(CARD frames)
BYTE PALNTSC=$D014
CARD res
IF PALNTSC=15 THEN
res=frames*60
ELSE
res=frames*50
FI
RETURN (res)
CARD FUNC ItersPerSecond(CARD timeMs,iters)
REAL rTime,rIters,r1000,tmp
CARD res
IntToReal(timeMs,tmp)
IntToReal(iters,rIters)
IntToReal(1000,r1000)
RealDiv(tmp,r1000,rTime)
RealDiv(rIters,rTime,tmp)
res=RealToInt(tmp)
RETURN (res)
;jump addr is stored in X and A registers
PROC Action=*(PTR jumpAddr)
DEFINE STX="$8E"
DEFINE STA="$8D"
DEFINE JSR="$20"
DEFINE RTS="$60"
[STX Action+8
STA Action+7
JSR $00 $00
RTS]
PROC Benchmark(PTR ARRAY actions,times BYTE count CARD iters)
BYTE i
CARD j,beg,end,diff,diffMs
PTR act
FOR i=0 TO count-1
DO
act=actions(i)
beg=GetFrame()
FOR j=0 TO iters-1
DO
Action(act)
OD
end=GetFrame()
diff=end-beg
times(i)=FramesToMs(diff)
OD
RETURN
PROC Action1()
RETURN
PROC Action2()
INT a=[12345],b=[23456],c
c=a+b
RETURN
PROC Action3()
INT i=[12345]
CHAR ARRAY s(6)
StrI(i,s)
RETURN
PROC Main()
DEFINE COUNT="3"
DEFINE ITERS="10000"
PTR ARRAY actions(COUNT)
CARD ARRAY times(COUNT),prec,rate
BYTE i
Put(125) PutE() ;clear the screen
prec=FramesToMs(1)
PrintF("Iteration count: %U%E",ITERS)
PrintF("Clock precision: %U ms%E%E",prec)
actions(0)=Action1
actions(1)=Action2
actions(2)=Action3
Benchmark(actions,times,COUNT,ITERS)
FOR i=0 TO COUNT-1
DO
rate=ItersPerSecond(times(i),iters)
PrintF("Action%B: %U ms, %U times per sec%E",i+1,times(i),rate)
OD
RETURN
- Output:
Screenshot from Atari 8-bit computer
Iteration count: 10000 Clock precision: 50 ms Action1: 1400 ms, 7143 times per sec Action2: 2000 ms, 5000 times per sec Action3: 47800 ms, 209 times per sec
Ada
Launch 6 jobs in parallel and record the elapsed time for each job. A variant
to get CPU times would use the package Ada.Execution_Time (Ada05).
The precision of measure is given by the value of System.Tick; on Windows value is 10 ms.
with System; use System;
with Ada.Text_IO; use Ada.Text_IO;
with Ada.Calendar; use Ada.Calendar;
with Ada.Unchecked_Deallocation; use Ada;
with Interfaces;
procedure Rate_Counter is
pragma Priority (Max_Priority);
package Duration_IO is new Fixed_IO (Duration);
Job_Nbr : constant := 6; -- adjust to your need
subtype Job_Index is Natural range 1 .. Job_Nbr;
task type Job (ID : Job_Index) is
pragma Priority (Default_Priority);
entry Start;
end Job;
type Job_Ptr is access Job;
procedure Free is new Unchecked_Deallocation (Job, Job_Ptr);
Jobs : array (Job_Index) of Job_Ptr;
Done : Natural := 0;
Completed : array (Job_Index) of Boolean := (others => False);
type Timings is array (Job_Index) of Calendar.Time;
Start_T, Stop_T : Timings;
task body Job is
Anchor : Interfaces.Integer_32;
pragma Volatile (Anchor); -- necessary to avoid compiler optimization.
begin
accept Start;
for I in Interfaces.Integer_32'Range loop -- the job to do
Anchor := I;
end loop;
end Job;
begin
for J in Job_Index'Range loop
Jobs (J) := new Job (ID => J); -- create the jobs first, sync later
end loop;
for J in Job_Index'Range loop -- launch the jobs in parallel
Start_T (J) := Calendar.Clock; -- get the start time
Jobs (J).Start; -- priority settings necessary to regain control.
end loop;
-- Polling for the results / also possible to use a protected type.
while not (Done = Job_Nbr) loop
for J in Job_Index'Range loop
if not Completed (J) and then Jobs (J)'Terminated then
Stop_T (J) := Calendar.Clock; -- get the end time
Put ("Job #" & Job_Index'Image (J) & " is finished. It took ");
Duration_IO.Put (Stop_T (J) - Start_T (J), Fore => 3, Aft => 2);
Put_Line (" seconds.");
Completed (J) := True;
Done := Done + 1;
end if;
end loop;
delay System.Tick; -- according to the precision of the system clock
end loop;
Duration_IO.Put (System.Tick, Fore => 1, Aft => 6);
Put_Line (" seconds is the precision of System clock.");
for J in Job_Index'Range loop
Free (Jobs (J)); -- no GC in Ada, clean-up is explicit
end loop;
end Rate_Counter;
Output on a Linux 64 bits system:
Job # 1 is finished. It took 57.93 seconds. Job # 5 is finished. It took 58.27 seconds. Job # 6 is finished. It took 58.27 seconds. Job # 4 is finished. It took 60.42 seconds. Job # 3 is finished. It took 60.98 seconds. Job # 2 is finished. It took 61.12 seconds. 0.000001 seconds is the precision of System clock.
Arturo
cube: function [z]->
z * z * z
loop 1..10 'x [
benchmark ->
loop 1..400 'o -> cube 5
]
- Output:
[benchmark] time: 0.231ms [benchmark] time: 0.231ms [benchmark] time: 0.213ms [benchmark] time: 0.184ms [benchmark] time: 0.141ms [benchmark] time: 0.175ms [benchmark] time: 0.169ms [benchmark] time: 0.254ms [benchmark] time: 0.174ms [benchmark] time: 0.174ms
AutoHotkey
Built in variable
The built in variable A_TickCount contains the number of milliseconds since the computer was rebooted. Storing this variable and later comparing it to the current value will measure the time elapsed. A_TickCount has a precision of approximately 10ms.
SetBatchLines, -1
Tick := A_TickCount ; store tickcount
Loop, 1000000 {
Random, x, 1, 1000000
Random, y, 1, 1000000
gcd(x, y)
}
t := A_TickCount - Tick ; store ticks elapsed
MsgBox, % t / 1000 " Seconds elapsed.`n" Round(1 / (t / 1000000000), 0) " Loop iterations per second."
gcd(a, b) { ; Euclidean GCD
while b
t := b, b := Mod(a, b), a := t
return, a
}
Output:
4.250000 Seconds elapsed. 235294 Loop iterations per second.
Query Performance Counter
The QPX function by SKAN wraps the QueryPerformanceCounter DLL, and is precise to one thousandth of a millisecond.
SetBatchLines, -1
QPX(1) ; start timer
Loop, 1000000 {
Random, x, 1, 1000000
Random, y, 1, 1000000
gcd(x, y)
}
t := QPX(0) ; end timer
MsgBox, % t " Seconds elapsed.`n" Round(1 / (t / 1000000), 0) " Loop iterations per second."
QPX( N=0 ) { ; Wrapper for QueryPerformanceCounter()by SKAN | CD: 06/Dec/2009
Static F,A,Q,P,X ; www.autohotkey.com/forum/viewtopic.php?t=52083 | LM: 10/Dec/2009
If ( N && !P )
Return DllCall("QueryPerformanceFrequency",Int64P,F) + (X:=A:=0) + DllCall("QueryPerformanceCounter",Int64P,P)
DllCall("QueryPerformanceCounter",Int64P,Q), A:=A+Q-P, P:=Q, X:=X+1
Return ( N && X=N ) ? (X:=X-1)<<64 : ( N=0 && (R:=A/X/F) ) ? ( R + (A:=P:=X:=0) ) : 1
}
gcd(a, b) { ; Euclidean GCD
while b
t := b, b := Mod(a, b), a := t
return, a
}
Output:
4.428430 Seconds elapsed. 225814 Loop iterations per second.
BaCon
The TIMER builtin returns the elapsed time since start of program run, in milliseconds.
' Rate counter
FOR i = 1 TO 3
GOSUB timeit
NEXT
i = 2000
GOSUB timeit
END
LABEL timeit
iter = 0
starter = TIMER
WHILE TRUE DO
INCR iter
IF TIMER >= starter + i THEN BREAK
WEND
PRINT iter, " iterations in ", i, " millisecond", IIF$(i > 1, "s", "")
RETURN
- Output:
prompt$ ./rate-counter 6169 iterations in 1 millisecond 16025 iterations in 2 milliseconds 23977 iterations in 3 milliseconds 28167202 iterations in 2000 milliseconds
BASIC256
global i
subroutine timeit()
iter = 0
starter = msec
while True
iter += 1
if msec >= starter + i then exit while
end while
print iter; " iteraciones en "; i; " milisegundo";
if i > 1 then print "s" else print
end subroutine
for i = 1 to 3
call timeit()
next i
i = 200
call timeit()
end
- Output:
660 iteraciones en 1 milisegundo 932 iteraciones en 2 milisegundos 1929 iteraciones en 3 milisegundos 173762 iteraciones en 200 milisegundos
BBC BASIC
PRINT "Method 1: Calculate reciprocal of elapsed time:"
FOR trial% = 1 TO 3
start% = TIME
PROCtasktomeasure
finish% = TIME
PRINT "Rate = "; 100 / (finish%-start%) " per second"
NEXT trial%
PRINT '"Method 2: Count completed tasks in one second:"
FOR trial% = 1 TO 3
runs% = 0
finish% = TIME + 100
REPEAT
PROCtasktomeasure
IF TIME < finish% runs% += 1
UNTIL TIME >= finish%
PRINT "Rate = "; runs% " per second"
NEXT trial%
END
REM This is an example, replace with the task you want to measure
DEF PROCtasktomeasure
LOCAL i%
FOR i% = 1 TO 1000000
NEXT
ENDPROC
Sample output:
Method 1: Calculate reciprocal of elapsed time: Rate = 9.09090909 per second Rate = 9.09090909 per second Rate = 9.09090909 per second Method 2: Count completed tasks in one second: Rate = 9 per second Rate = 9 per second Rate = 9 per second
C
This code stores all of the data of the rate counter and its configuration in an instance of a struct named rate_state_s, and a function named tic_rate is called on that struct instance every time we complete a job. If a configured time has elapsed, tic_rate calculates and reports the tic rate, and resets the counter.
#include <stdio.h>
#include <time.h>
// We only get one-second precision on most systems, as
// time_t only holds seconds.
struct rate_state_s
{
time_t lastFlush;
time_t period;
size_t tickCount;
};
void tic_rate(struct rate_state_s* pRate)
{
pRate->tickCount += 1;
time_t now = time(NULL);
if((now - pRate->lastFlush) >= pRate->period)
{
//TPS Report
size_t tps = 0.0;
if(pRate->tickCount > 0)
tps = pRate->tickCount / (now - pRate->lastFlush);
printf("%u tics per second.\n", tps);
//Reset
pRate->tickCount = 0;
pRate->lastFlush = now;
}
}
// A stub function that simply represents whatever it is
// that we want to multiple times.
void something_we_do()
{
// We use volatile here, as many compilers will optimize away
// the for() loop otherwise, even without optimizations
// explicitly enabled.
//
// volatile tells the compiler not to make any assumptions
// about the variable, implying that the programmer knows more
// about that variable than the compiler, in this case.
volatile size_t anchor = 0;
size_t x = 0;
for(x = 0; x < 0xffff; ++x)
{
anchor = x;
}
}
int main()
{
time_t start = time(NULL);
struct rate_state_s rateWatch;
rateWatch.lastFlush = start;
rateWatch.tickCount = 0;
rateWatch.period = 5; // Report every five seconds.
time_t latest = start;
// Loop for twenty seconds
for(latest = start; (latest - start) < 20; latest = time(NULL))
{
// Do something.
something_we_do();
// Note that we did something.
tic_rate(&rateWatch);
}
return 0;
}
C++
This code defines the counter as a class, CRateState. The counter's period is configured as an argument to its constructor, and the rest of the counter state is kept as class members. A member function Tick() manages updating the counter state, and reports the tic rate if the configured period has elapsed.
#include <iostream>
#include <ctime>
// We only get one-second precision on most systems, as
// time_t only holds seconds.
class CRateState
{
protected:
time_t m_lastFlush;
time_t m_period;
size_t m_tickCount;
public:
CRateState(time_t period);
void Tick();
};
CRateState::CRateState(time_t period) : m_lastFlush(std::time(NULL)),
m_period(period),
m_tickCount(0)
{ }
void CRateState::Tick()
{
m_tickCount++;
time_t now = std::time(NULL);
if((now - m_lastFlush) >= m_period)
{
//TPS Report
size_t tps = 0.0;
if(m_tickCount > 0)
tps = m_tickCount / (now - m_lastFlush);
std::cout << tps << " tics per second" << std::endl;
//Reset
m_tickCount = 0;
m_lastFlush = now;
}
}
// A stub function that simply represents whatever it is
// that we want to multiple times.
void something_we_do()
{
// We use volatile here, as many compilers will optimize away
// the for() loop otherwise, even without optimizations
// explicitly enabled.
//
// volatile tells the compiler not to make any assumptions
// about the variable, implying that the programmer knows more
// about that variable than the compiler, in this case.
volatile size_t anchor = 0;
for(size_t x = 0; x < 0xffff; ++x)
{
anchor = x;
}
}
int main()
{
time_t start = std::time(NULL);
CRateState rateWatch(5);
// Loop for twenty seconds
for(time_t latest = start; (latest - start) < 20; latest = std::time(NULL))
{
// Do something.
something_we_do();
// Note that we did something.
rateWatch.Tick();
}
return 0;
}
Chipmunk Basic
100 cls
110 for i = 1 to 3
120 gosub 170
130 next i
140 i = 200
150 gosub 170
160 end
170 'function timeit
180 iter = 0
190 starter = timer
200 while true
210 iter = iter+1
220 if timer >= starter+i then exit while
230 wend
240 print iter;" iteraciones en ";i;" milisegundo";
250 if i > 1 then print "s" else print ""
260 return
Common Lisp
Common Lisp already has a time
macro.
(time (do some stuff))
will give a timing report about "stuff" on the trace output. We can define something similar with repeats:
(defmacro time-this (cnt &rest body)
(let ((real-t (gensym)) (run-t (gensym)))
`(let (,real-t ,run-t)
(setf ,real-t (get-internal-real-time)
,run-t (get-internal-run-time))
(loop repeat ,cnt do ,@body)
(list (/ (- (get-internal-real-time) ,real-t)
(coerce internal-time-units-per-second 'float))
(/ (- (get-internal-run-time) ,run-t)
(coerce internal-time-units-per-second 'float))))))
Call the time-this
macro to excute a loop 99 times:
(print (time-this 99 (loop for i below 10000 sum i)))
which gives a pair of numbers, the real time and the run time, both in seconds:
(0.023 0.022)
Crystal
Testing lookup speed in array versus hash:
require "benchmark"
struct Document
property :id
def initialize(@id : Int32) end
end
documents_a = [] of Int32 | Document
documents_h = {} of Int32 => Int32 | Document
1.upto(10_000) do |n|
d = Document.new(n)
documents_a << d
documents_h[d.id] = d
end
searchlist = Array.new(1000){ rand(10_000)+1 }
Benchmark.bm do |x|
x.report("array"){searchlist.each{ |el| documents_a.any?{ |d| d == el }} }
x.report("hash") {searchlist.each{ |el| documents_h.has_key?(el) } }
end
puts
Benchmark.ips do |x|
x.report("array"){searchlist.each{ |el| documents_a.any?{ |d| d == el }} }
x.report("hash") {searchlist.each{ |el| documents_h.has_key?(el) } }
end
System: I7-6700HQ, 3.5 GHz, Linux Kernel 5.6.17, Crystal 0.35 Run as: $ crystal run ratecounter.cr --release
- Output:
user system total real array 0.006493 0.000736 0.007229 ( 0.007223) hash 0.000015 0.000008 0.000023 ( 0.000023) array 166.53 ( 6.00ms) (± 1.87%) 0.0B/op 545.27× slower hash 90.81k ( 11.01µs) (± 4.16%) 0.0B/op fastest
D
import std.stdio;
import std.conv;
import std.datetime.stopwatch;
int a;
void f0() {}
void f1() { auto b = a; }
void f2() { auto b = to!string(a); }
void main()
{
auto r = benchmark!(f0, f1, f2)(10_000);
writeln("Time fx took to run 10,000 times:\n");
writeln("f0: ", r[0]);
writeln("f1: ", r[1]);
writeln("f2: ", r[2]);
}
- Output:
Time fx took to run 10,000 times: f0: 37 μs and 7 hnsecs f1: 56 μs and 2 hnsecs f2: 1 ms, 966 μs, and 6 hnsecs
Delphi
program Rate_counter;
{$APPTYPE CONSOLE}
uses
System.SysUtils,
System.Diagnostics;
var
a: Integer;
function TickToString(Tick: Int64): string;
var
ns, us, ms, s, t: Cardinal;
begin
Result := '';
ns := (Tick mod 10) * 100;
if ns > 0 then
Result := format(' %dns', [ns]);
t := Tick div 10;
us := t mod 1000;
if us > 0 then
Result := format(' %dus', [us]) + Result;
t := t div 1000;
ms := t mod 1000;
if ms > 0 then
Result := format(' %dms', [ms]) + Result;
t := t div 1000;
s := t mod 1000;
if s > 0 then
Result := format(' %ds', [s]) + Result;
end;
function Benchmark(Fns: TArray<TProc>; times: Cardinal): TArray<string>;
var
Stopwatch: TStopwatch;
fn: TProc;
i, j: Cardinal;
begin
SetLength(result, length(Fns));
Stopwatch := TStopwatch.Create;
for i := 0 to High(Fns) do
begin
fn := Fns[i];
if not Assigned(fn) then
Continue;
Stopwatch.Reset;
Stopwatch.Start;
for j := 1 to times do
fn();
Stopwatch.Stop;
Result[i] := TickToString(Stopwatch.ElapsedTicks);
end;
end;
procedure F0();
begin
end;
procedure F1();
begin
var b := a;
end;
procedure F2();
begin
var b := a.ToString;
end;
begin
writeln('Time fx took to run 10,000 times:'#10);
var r := Benchmark([F0, F1, F2], 10000);
for var i := 0 to High(r) do
writeln('f', i, ': ', r[i]);
Readln;
end.
- Output:
Time fx took to run 10,000 times: f0: 32us 400ns f1: 34us 600ns f2: 607us 100ns
E
def makeLamportSlot := <import:org.erights.e.elib.slot.makeLamportSlot>
The rate counter:
/** Returns a function to call to report the event being counted, and an
EverReporter slot containing the current rate, as a float64 in units of
events per millisecond. */
def makeRateCounter(timer, reportPeriod) {
var count := 0
var start := timer.now()
def &rate := makeLamportSlot(nullOk[float64], null)
def signal() {
def time := timer.now()
count += 1
if (time >= start + reportPeriod) {
rate := count / (time - start)
start := time
count := 0
}
}
return [signal, &rate]
}
The test code:
/** Dummy task: Retrieve http://localhost/ and return the content. */
def theJob() {
return when (def text := <http://localhost/> <- getText()) -> {
text
}
}
/** Repeatedly run 'action' and wait for it until five seconds have elapsed. */
def repeatForFiveSeconds(action) {
def stopTime := timer.now() + 5000
def loop() {
if (timer.now() < stopTime) {
when (action <- ()) -> {
loop()
}
}
}
loop()
}
def whenever := <import:org.erights.e.elib.slot.whenever>
def [signal, &rate] := makeRateCounter(timer, 1000)
# Prepare to report the rate info.
whenever([&rate], fn {
println(`Rate: ${rate*1000} requests/sec`)
}, fn {true})
# Do some stuff to be counted.
repeatForFiveSeconds(fn {
signal()
theJob()
})
EasyLang
color 700
on animate
clear
rad += 0.2
move 50 50
circle rad
if rad > 50
rad = 0
.
t = systime
if t0 > 0
print 1000 * (t - t0) & " ms"
.
t0 = t
end
- Output:
17.00 ms 17.00 ms 16.00 ms . .
Erlang
Measuring elapsed time is built into the timer module. Doing something during a time period requires code. For normal use the Fun should take a large amount of microseconds, our unit of measurement.
-module( rate_counter ).
-export( [fun_during_seconds/2, task/0] ).
fun_during_seconds( Fun, Seconds ) ->
My_pid = erlang:self(),
Ref = erlang:make_ref(),
Pid = erlang:spawn( fun() -> fun_during_seconds_loop( My_pid, Fun ) end ),
timer:send_after( Seconds * 1000, My_pid, {stop, Ref} ),
N = fun_during_seconds_receive_loop( Ref, Pid, 0 ),
erlang:exit( Pid, kill ),
N.
task() ->
Results = [timer:tc( fun() -> io:fwrite("Hello, world!~n") end ) || _X <- lists:seq(1, 3)],
Times = [X || {X, _Returned} <- Results],
io:fwrite( "Times ~p, average ~p microseconds.~n", [Times, lists:sum(Times) / erlang:length(Times)]),
N = fun_during_seconds( fun() -> math:sqrt(123) end, 2 ),
io:fwrite( "Square root of 123, during 2 seconds, was done ~p times.~n", [N] ).
fun_during_seconds_loop( Pid, Fun ) ->
Fun(),
Pid ! {one_time, erlang:self()},
fun_during_seconds_loop( Pid, Fun ).
fun_during_seconds_receive_loop( Ref, Pid, N ) ->
receive
{stop, Ref} -> N;
{one_time, Pid} -> fun_during_seconds_receive_loop( Ref, Pid, N + 1 )
end.
- Output:
19> rate_counter:task(). Hello, world! Hello, world! Hello, world! Times [54,26,52], average 44.0 microseconds. Square root of 123, during 2 seconds, was done 6398906 times.
ERRE
PROGRAM RATE_COUNTER
!
! for rosettacode.org
!
!
! This is an example, replace with the task you want to measure
!
PROCEDURE TASK_TO_MEASURE
LOCAL I
FOR I=1 TO 1000000 DO
END FOR
END PROCEDURE
BEGIN
PRINT("Method 1: Calculate reciprocal of elapsed time:")
FOR TRIAL%=1 TO 3 DO
START=TIMER
TASK_TO_MEASURE
FINISH=TIMER
PRINT("Rate =";100/(FINISH-START);"per second")
END FOR
PRINT("Method 2: Count completed tasks in one minute:")
FOR TRIAL%=1 TO 3 DO
RUNS%=0
FINISH=TIMER+60
REPEAT
TASK_TO_MEASURE
IF TIMER<FINISH THEN RUNS%+=1 END IF
UNTIL TIMER>=FINISH
PRINT("Rate =";RUNS%;"per minute")
END FOR
END PROGRAM
Time elapsed is measured with TIMER function (taken from computer clock).
- Output:
Method 1: Calculate reciprocal of elapsed time: Rate = 25.24655 per second Rate = 25.32147 per second Rate = 25.6513 per second Method 2: Count completed tasks in one minute: Rate = 15 per second Rate = 15 per second Rate = 15 per second
Fortran
Standard Fortran does not offer facilities for starting another task, nor for monitoring such a task's consumption of cpu time against clock time. However, a program can monitor its own usage by invoking a suitable routine at appropriate points in its computation, say on each new iteration of its outermost DO-loop, and thus generate progress reports that could also include an estimated time of finishing. This requires access to system timers, usually achieved via invocations of special routines that are often specific to an installation. But F90 introduced the intrinsic CALL CPU_TIME(T)
that returns a "processor-dependent approximation of the processor time in seconds" in T
a floating-point variable.
Similarly, an installation may offer local routines to report the date and time, and F90 has introduced an intrinsic that can be invoked as CALL DATE_AND_TIME(VALUES = MARK)
where MARK is an eight-element integer array, rather exhaustingly returning year, month, day, minutes from GMT (or UT, etc), hour, minute, second, milliseconds.
So, in
DO I = FIRST,LAST
IF (PROGRESSNOTE((I - FIRST)/(LAST - FIRST + 1.0))) WRITE (6,*) "Reached ",I,", towards ",LAST
...much computation...
END DO
Function PROGRESSNOTE is invoked at the start of each iteration, with its parameter stating how much progress has been made on a scale of zero to one, with a "zero progress" restarting its timers. The function notes whether sufficient clock time has elapsed since its previous report (more than six seconds, for example) and if so, returns true after starting an output line with a standard report giving an estimated time to run and an estimated time (and date, if not the current day) of finishing. This line is not terminated; the invoking routine appends its own progress message, tailored to the nature of the task it is working through. For instance,
Standard progress report|Tailored message. ETF + 6·2hrs!@Monday 17/ 7/2017 5:23:25·013am. 0% Dumping Monday 3/ 2/1749. ETF + 6·2hrs!@Monday 17/ 7/2017 5:23:37·167am. 0% Dumping Sunday 9/ 3/1749. ETF + 6·2hrs!@Monday 17/ 7/2017 5:26:06·383am. 0% Dumping Friday 11/ 4/1749. ETF + 6·1hrs!@Monday 17/ 7/2017 5:21:23·397am. 0% Dumping Friday 16/ 5/1749.
Thus, the human waiting at the computer screen can monitor the rate of progress and know to go for a walk, or not.
Incidentally, on windows systems at least, frequent invocations of the date and time routine can cause execution to run much slower, or worse. A loop waiting for the system's DATE_AND_TIME result to attain a specified value will instead cause a crash.
For another approach, imagine a long-running program, WORKER, that writes various remarks to standard output as it goes, and consider another, TIMESTAMP, that copies from standard input to standard output, prefixing each line with a date and time stamp, perhaps invoked via something like WORKER | TIMESTAMP >Log.txt
- the vertical bar an amusing choice to symbolise a horizontal "pipe". When everything finishes, the log file can be analysed to determine the rate of progress. But alas, in the windows world, the stages of a "pipeline" are performed serially, not simultaneously - the vertical bar symbolising this separation. All output from WORKER will be saved in a temporary disc file then when WORKER finishes that file will be fed as input to TIMESTAMP, thereby producing data only on the rate of file input/output.
FreeBASIC
Dim Shared As Integer i
Sub timeit
Dim As Integer iter = 0
Dim As Double starter = Timer
While True
iter += 1
If Timer >= starter + i Then Exit While
Wend
Print iter; " iteraciones en"; i; " milisegundo"; Iif(i > 1, "s", "")
End Sub
For i = 1 To 3
timeit
Next i
i = 200 : timeit
Sleep
- Output:
44804265 iteraciones en 1 milisegundo 91122566 iteraciones en 2 milisegundos 137725199 iteraciones en 3 milisegundos 8426682089 iteraciones en 200 milisegundos
Go
package main
import (
"fmt"
"math/rand"
"time"
)
// representation of time.Time is nanosecond, actual resolution system specific
type rateStateS struct {
lastFlush time.Time
period time.Duration
tickCount int
}
func ticRate(pRate *rateStateS) {
pRate.tickCount++
now := time.Now()
if now.Sub(pRate.lastFlush) >= pRate.period {
// TPS Report
tps := 0.
if pRate.tickCount > 0 {
tps = float64(pRate.tickCount) / now.Sub(pRate.lastFlush).Seconds()
}
fmt.Println(tps, "tics per second.")
// Reset
pRate.tickCount = 0
pRate.lastFlush = now
}
}
func somethingWeDo() {
time.Sleep(time.Duration(9e7 + rand.Int63n(2e7))) // sleep about .1 second.
}
func main() {
start := time.Now()
rateWatch := rateStateS{
lastFlush: start,
period: 5 * time.Second,
}
// Loop for twenty seconds
latest := start
for latest.Sub(start) < 20*time.Second {
somethingWeDo()
ticRate(&rateWatch)
latest = time.Now()
}
}
Output:
9.941784884430728 tics per second. 10.01399996465647 tics per second. 9.848572291869138 tics per second.
Haskell
This solution returns the time deltas in picosecond resolution.
import Control.Monad
import Control.Concurrent
import Data.Time
getTime :: IO DiffTime
getTime = fmap utctDayTime getCurrentTime
addSample :: MVar [a] -> a -> IO ()
addSample q v = modifyMVar_ q (return . (v:))
timeit :: Int -> IO a -> IO [DiffTime]
timeit n task = do
samples <- newMVar []
forM_ [0..n] $ \n -> do
t1 <- getTime
task
t2 <- getTime
addSample samples (t2 - t1)
readMVar samples
main = timeit 10 (threadDelay 1000000)
HicEst
The script opens a modeless dialog with 3 buttons: "Hits++" to increase Hits, "Count 5 sec" to reset Hits and initialize a delayed call to F5 after 5 sec, "Rate" to display the current rate on the status bar.
CHARACTER prompt='Count "Hits++" for 5 sec, get current rate'
DLG(Button="1:&Hits++", CALL="cb", B="2:&Count 5sec", B="3:&Rate", RC=retcod, TItle=prompt, WIN=hdl)
SUBROUTINE cb ! callback after dialog buttons
IF(retcod == 1) THEN ! "Hits++" button
Hits = Hits + 1
ELSEIF(retcod == 2) THEN ! "Count 5 sec" button
Hits = 0
ALARM(5, 5) ! call F5 in 5 seconds
t_start = TIME()
ELSE ! "Rate" button
sec = TIME() - t_start
WRITE(StatusBar) 'Average rate since last "5 sec" button = ', hits/sec, " Hz"
ENDIF
END
SUBROUTINE F5 ! called 5 sec after button "5 sec"
WRITE(StatusBar) Hits, "hits last 5 sec"
END
J
Solution
x (6!:2) y
The foreign conjunction 6!:2
will execute the code y
(right argument), x
times (left argument) and report the average time in seconds required for one execution.
Example:
list=: 1e6 ?@$ 100 NB. 1 million random integers from 0 to 99
freqtable=: ~. ,. #/.~ NB. verb to calculate and build frequency table
20 (6!:2) 'freqtable list' NB. calculate and build frequency table for list, 20 times
0.00994106
Note, if instead we want distinct times instead of averaged times we can use a repeated counter for the number of times to execute the code
1 1 1 (6!:2) 'freqtable list'
0.0509995 0.0116702 0.0116266
Java
import java.util.function.Consumer;
public class RateCounter {
public static void main(String[] args) {
for (double d : benchmark(10, x -> System.out.print(""), 10))
System.out.println(d);
}
static double[] benchmark(int n, Consumer<Integer> f, int arg) {
double[] timings = new double[n];
for (int i = 0; i < n; i++) {
long time = System.nanoTime();
f.accept(arg);
timings[i] = System.nanoTime() - time;
}
return timings;
}
}
70469.0 2047.0 1169.0 877.0 877.0 877.0 877.0 877.0 877.0 877.0
Stream based solution
import java.util.function.IntConsumer;
import java.util.stream.DoubleStream;
import static java.lang.System.nanoTime;
import static java.util.stream.DoubleStream.generate;
import static java.lang.System.out;
public interface RateCounter {
public static void main(final String... arguments) {
benchmark(
10,
x -> out.print(""),
10
)
.forEach(out::println)
;
}
public static DoubleStream benchmark(
final int n,
final IntConsumer consumer,
final int argument
) {
return generate(() -> {
final long time = nanoTime();
consumer.accept(argument);
return nanoTime() - time;
})
.limit(n)
;
}
}
81431.0 3987.0 3205.0 3081.0 3020.0 3101.0 3040.0 3102.0 3072.0 3060.0
JavaScript
The benchmark function below executes a given function n times, calling it with the specified arguments. After execution of all functions, it returns an array with the execution time of each execution, in milliseconds.
function millis() { // Gets current time in milliseconds.
return (new Date()).getTime();
}
/* Executes function 'func' n times, returns array of execution times. */
function benchmark(n, func, args) {
var times = [];
for (var i=0; i<n; i++) {
var m = millis();
func.apply(func, args);
times.push(millis() - m);
}
return times;
}
jq
Works with jq and gojq, that is, the C and Go implementations of jq.
In this entry, the times to compute `x*x*x` are compared with the times to compute `pow(x;3)`.
Note that jq only has direct access to the system clock ("now").
def cube: . * . * .;
def pow3: pow(.; 3);
def benchmark($n; func; $arg; $calls):
reduce range(0; $n) as $i ([];
now as $_
| (range(0; $calls) | ($arg | func)) as $x
# milliseconds:
| . + [(now - $_) * 1000 | floor] ) ;
"Timings (total elapsed time in milliseconds):",
"cube pow3",
([benchmark(10; cube; 5; 1e5), benchmark(10; pow3; 5; 1e5)]
| transpose[]
| "\(.[0]) \(.[1])" )
Invocation: jq -nr -f rate-counter.jq
{
- Output:
Timings (total elapsed time in milliseconds): cube pow3 205 178 164 182 182 156 173 173 167 154 181 175 180 176 176 160 186 206 173 174
Jsish
#!/usr/bin/env jsish
"use strict";
/* Rate counter, timer access, in Jsish */
/* System time in milliseconds */
var runs = 0, newMs;
function countJobsIsTheJob() { runs += 1; }
var milliSeconds = strptime();
while ((newMs = strptime()) < (milliSeconds + 1000)) { countJobsIsTheJob(); }
puts(runs, 'runs in', newMs - milliSeconds, 'ms');
/* Builtin times test(callback, runs), result in microseconds */
function sleeper() { sleep(10); }
var timer;
for (var i = 1; i < 4; i++) {
timer = times(sleeper, 100);
puts(timer, 'μs to sleep 10 ms, 100 times');
}
- Output:
prompt$ jsish rateCounter.jsi 81494 runs in 1000 ms 1019410 μs to sleep 10 ms, 100 times 1018384 μs to sleep 10 ms, 100 times 1018984 μs to sleep 10 ms, 100 times
Julia
The elapsed() macro in Julia generally is accurate in the nanosecond range.
dosomething() = sleep(abs(randn()))
function runNsecondsworthofjobs(N)
times = Vector{Float64}()
totaltime = 0
runcount = 0
while totaltime < N
t = @elapsed(dosomething())
push!(times, t)
totaltime += t
runcount += 1
end
println("Ran job $runcount times, for total time of $totaltime seconds.")
println("Average time per run was $(sum(times)/length(times)) seconds.")
println("Individual times of the jobs in seconds were:")
for t in times
println(" $t")
end
end
runNsecondsworthofjobs(5)
- Output:
Ran job 5 times, for total time of 5.215301074 seconds.Average time per run was 1.0430602148 seconds. Individual times of the jobs in seconds were: 1.901202753 0.706044625 0.485377196 0.489283165 1.633393335
Kotlin
// version 1.1.3
typealias Func<T> = (T) -> T
fun cube(n: Int) = n * n * n
fun <T> benchmark(n: Int, func: Func<T>, arg: T): LongArray {
val times = LongArray(n)
for (i in 0 until n) {
val m = System.nanoTime()
func(arg)
times[i] = System.nanoTime() - m
}
return times
}
fun main(args: Array<String>) {
println("\nTimings (nanoseconds) : ")
for (time in benchmark(10, ::cube, 5)) println(time)
}
Sample output:
154430 2100 1275 1138 1063 1113 1087 1088 1063 1025
Liberty BASIC
precision depends on OS. It is 16 (sometines cames as 15) ms for XP and 10 ms for Win2000.
Print "Rate counter"
print "Precision: system clock, ms ";
t0=time$("ms")
while time$("ms")=t0 'busy loop till click ticks
wend
print time$("ms")-t0
print
Print "Run jobs N times, report every time"
Print "After that, report average time"
N=10
t00=time$("ms")
for i = 1 to 10
scan
t0=time$("ms")
'any code we want to measure goes here
res = testFunc()
'end of measured code
t1=time$("ms")
ElapsedTime = t1-t0
print "Job #";i;" Elapsed time, ms ";ElapsedTime, 1000/ElapsedTime; " ticks per second"
next
print "---------------------------------"
print "Average time, ms, is ";(t1-t00)/N, 1000/((t1-t00)/N); " ticks per second"
print
print "Run jobs for not less then N seconds (if time up, it'll finish last job)"
print "After that, report average time"
NSec=5
i = 0
t00=time$("ms")
while time$("ms")<t00+NSec*1000
scan
i = i+1
t0=time$("ms")
'any code we want to measure goes here
res = testFunc()
'end of measured code
t1=time$("ms")
ElapsedTime = t1-t0
print "Job #";i;" Elapsed time, ms ";ElapsedTime, 1000/ElapsedTime; " ticks per second"
wend
print "---------------------------------"
print "Average time, ms, is ";(t1-t00)/i, 1000/((t1-t00)/i); " ticks per second"
end
function testFunc()
s=0
for i = 1 to 30000
s=s+sin(i)/30000
next
testFunc = s
end function
Mathematica/Wolfram Language
The first parameter for both of these functions can be any program code.
jobRateCounted[fn_,Y_Integer]:=First[AbsoluteTiming[Do[fn,{Y}]]/Y;
SetAttributes[jobRateCounted,HoldFirst]
jobRatePeriod[fn_,time_]:=Block[{n=0},TimeConstrained[While[True,fn;n++]];n/time];
SetAttributes[jobRatePeriod,HoldFirst]
Nim
import sugar, std/monotimes, times
type Func[T] = (T) -> T
func cube(n: int): int = n * n * n
proc benchmark[T](n: int; f: Func[T]; arg: T): seq[Duration] =
result.setLen(n)
for i in 0..<n:
let m = getMonoTime()
discard f(arg)
result[i] = getMonoTime() - m
echo "Timings (nanoseconds):"
for time in benchmark(10, cube, 5):
echo time.inNanoseconds
- Output:
Timings (nanoseconds): 556 170 88 93 91 93 109 96 91 92
OxygenBasic
Rate Counter Deluxe, giving start and finish times + duration. The duration is measured in seconds using the system performance counter, resolved to the nearest microsecond.
'========
'TIME API
'========
'http://msdn.microsoft.com/en-us/library/windows/desktop/ms724950(v=vs.85).aspx
extern lib "kernel32.dll"
type SYSTEMTIME
WORD wYear
WORD wMonth
WORD wDayOfWeek
WORD wDay
WORD wHour
WORD wMinute
WORD wSecond
WORD wMilliseconds
end type
void GetSystemTime(SYSTEMTIME*t)
void GetLocalTime(SYSTEMTIME*t)
void QueryPerformanceCounter(quad*c)
void QueryPerformanceFrequency(quad*freq)
void Sleep(sys millisecods)
end extern
String WeekDay[7]={"Sunday","Monday","Tuesday","Wednesday",
"Thursday","Friday","Saturday"}
String MonthName[12]={"January","February","March","April","May","June",
"July","August","September","October","November","December"}
'==============
Class Jobrecord
'==============
has SYSTEMTIME stt
has SYSTEMTIME fin
quad countA
quad CountB
quad freq
sys serial
method pad(string s) as string
method=s
if len(method)<2 then method="0"+method
end method
method ShowDateTime(sys a,f) as string
SYSTEMTIME *t
if a then
@t=@fin
else
@t=@stt
end if
'
String month=pad(str t.wMonth)
String day=pad(str t.wDay)
if f=0 then
return "" t.wYear "-" month "-" day " "+
pad(t.wHour) ":" pad(t.wMinute) ":" pad(t.wSecond) ":" t.wMilliSeconds
elseif f=1
return WeekDay[t.wDayOfWeek+1 and 7 ] " " +
MonthName[t.wMonth and 31] " " day " " t.wYear
end if
end method
method Start()
QueryPerformanceCounter countA
QueryPerformanceFrequency freq
serial++
GetLocalTime stt
end method
method Finish()
GetLocalTime fin
QueryPerformanceCounter countB
end method
method ShowDuration() as string
return str((countB-countA)/freq,6) 'seconds with microsecond resolution
end method
method report() as string
string tab=chr(9), cr=chr(13)+chr(10)
method="Job:" tab serial cr +
"Duration:" tab ShowDuration() cr +
"Start: " tab ShowDateTime(0,0) cr +
"Finish:" tab ShowDateTime(1,0) cr +
ShowDateTime(1,1) cr
end method
end class
'#recordof JobRecord
'====
'TEST
'====
JobRecord JR
JR.start
sleep 100 'JOB!
JR.finish
print JR.Report
'putfile "s.txt",JR.Report
'
'Job: 1
'Duration: 0.099026
'Start: 2012-07-01 00:52:36:874
'Finish: 2012-07-01 00:52:36:974
'Sunday July 01 2012
PARI/GP
a=0;
b=0;
for(n=1,20000000,
a=a+gettime();
if(a>60000,print(b);a=0;b=0);
'''code to test'''
b=b+1;
a=a+gettime();
if(a>60000,print(b);a=0;b=0)
)
Perl
The Benchmark module can rate code per time, or per loops executed:
use Benchmark;
timethese COUNT,{ 'Job1' => &job1, 'Job2' => &job2 };
sub job1
{
...job1 code...
}
sub job2
{
...job2 code...
}
A negative COUNT will run each job for at least COUNT seconds.
A positive COUNT will run each job COUNT times.
Phix
On windows, time() advances in ~0.015s increments, whereas on linux it is ~0.0000016s.
procedure task_to_measure() sleep(0.1) end procedure printf(1,"method 1: calculate reciprocal of elapsed time:\n") for trial=1 to 3 do atom t=time() task_to_measure() t = time()-t string r = iff(t?sprintf("%g",1/t):"inf") printf(1,"rate = %s per second\n",{r}) end for printf(1,"method 2: count completed tasks in one second:\n") for trial=1 to 3 do integer runs=0 atom finish=time()+1 while true do task_to_measure() if time()>=finish then exit end if runs += 1 end while printf(1,"rate = %d per second\n",runs) end for
- Output:
Of course it fails to achieve the perfect 10/s, due to the overhead of call/ret/time/printf etc.
method 1: calculate reciprocal of elapsed time: rate = 9.17431 per second rate = 9.09091 per second rate = 9.17431 per second method 2: count completed tasks in one second: rate = 9 per second rate = 9 per second rate = 9 per second
Phixmonti
100000 var iterations
2 4 2 tolist
for
msec var a
iterations
for
over 2 power + drop
endfor
msec a - var dif
"take " print dif print " secs" print
" or " print iterations dif / print " sums per second" print nl
endfor
PicoLisp
usec returns a relative time in microseconds. This can be used, for example, to measure the time between two key strokes
(prin "Hit a key ... ")
(key)
(prinl)
(let Usec (usec)
(prin "Hit another key ... ")
(key)
(prinl)
(prinl "This took " (format (- (usec) Usec) 6) " seconds") )
Output:
Hit a key ... Hit another key ... This took 3.132058 seconds
The bench benchmark function could also be used. Here we measure the time until a key is pressed
(bench (key))
1.761 sec -> "a"
PowerShell
[datetime]$start = Get-Date
[int]$count = 3
[timespan[]]$times = for ($i = 0; $i -lt $count; $i++)
{
Measure-Command {0..999999 | Out-Null}
}
[datetime]$end = Get-Date
$rate = [PSCustomObject]@{
StartTime = $start
EndTime = $end
Duration = ($end - $start).TotalSeconds
TimesRun = $count
AverageRunTime = ($times.TotalSeconds | Measure-Object -Average).Average
}
$rate | Format-List
- Output:
StartTime : 10/27/2016 3:33:16 PM EndTime : 10/27/2016 3:33:30 PM Duration : 13.9062588 TimesRun : 3 AverageRunTime : 4.63301593333333
PureBasic
Counting frequence of an event
Procedure.d TimesPSec(Reset=#False)
Static starttime, cnt
Protected Result.d, dt
If Reset
starttime=ElapsedMilliseconds(): cnt=0
Else
cnt+1
dt=(ElapsedMilliseconds()-starttime)
If dt
Result=cnt/(ElapsedMilliseconds()-starttime)
EndIf
EndIf
ProcedureReturn Result*1000
EndProcedure
If OpenWindow(0,#PB_Ignore,#PB_Ignore,220,110,"",#PB_Window_SystemMenu)
Define Event, r.d, GadgetNumber
ButtonGadget(0,10, 5,200,35,"Click me!")
ButtonGadget(1,10,70,100,35,"Reset")
TextGadget (2,10,45,200,25,"")
TimesPSec(1)
Repeat
Event=WaitWindowEvent()
If Event=#PB_Event_Gadget
GadgetNumber =EventGadget()
If GadgetNumber=0
r=TimesPSec()
SetGadgetText(2,"You are clicking at "+StrD(r,5)+" Hz.")
ElseIf GadgetNumber=1
TimesPSec(1)
SetGadgetText(2,"Counter zeroed.")
EndIf
EndIf
Until Event=#PB_Event_CloseWindow
EndIf
Counting events for a time period
Procedure DummyThread(arg)
Define.d dummy=#PI*Pow(arg,2)/4
EndProcedure
start=ElapsedMilliseconds()
Repeat
T=CreateThread(@DummyThread(),Random(100))
WaitThread(T)
cnt+1
Until start+10000<=ElapsedMilliseconds(); Count for 10 sec
msg$="We got "+Str(cnt)+" st."+Chr(10)+StrF(cnt/10,2)+" threads per sec."
MessageRequester("Counting threads in 10 sec",msg$)
Python
import subprocess
import time
class Tlogger(object):
def __init__(self):
self.counts = 0
self.tottime = 0.0
self.laststart = 0.0
self.lastreport = time.time()
def logstart(self):
self.laststart = time.time()
def logend(self):
self.counts +=1
self.tottime += (time.time()-self.laststart)
if (time.time()-self.lastreport)>5.0: # report once every 5 seconds
self.report()
def report(self):
if ( self.counts > 4*self.tottime):
print "Subtask execution rate: %f times/second"% (self.counts/self.tottime);
else:
print "Average execution time: %f seconds"%(self.tottime/self.counts);
self.lastreport = time.time()
def taskTimer( n, subproc_args ):
logger = Tlogger()
for x in range(n):
logger.logstart()
p = subprocess.Popen(subproc_args)
p.wait()
logger.logend()
logger.report()
import timeit
import sys
def main( ):
# for accurate timing of code segments
s = """j = [4*n for n in range(50)]"""
timer = timeit.Timer(s)
rzlts = timer.repeat(5, 5000)
for t in rzlts:
print "Time for 5000 executions of statement = ",t
# subprocess execution timing
print "#times:",sys.argv[1]
print "Command:",sys.argv[2:]
print ""
for k in range(3):
taskTimer( int(sys.argv[1]), sys.argv[2:])
main()
Usage Example: First argument is the number of times to iterate. Additional arguments are command to execute.
C:>rateCounter.py 20 md5.exe
Racket
#lang racket
;; Racket has a useful `time*' macro that does just what's requested:
;; run some expression N times, and produce timing results
(require unstable/time)
;; Sample use:
(define (fib n) (if (<= n 1) n (+ (fib (- n 1)) (fib (- n 2)))))
(time* 10 (fib 38))
;; But of course, can be used to measure external processes too:
(time* 10 (system "sleep 1"))
Sample output:
; run #1... -> 39088169 ; run #2... -> 39088169 ; run #3... -> 39088169 ; run #4... -> 39088169 ; run #5... -> 39088169 ; run #6... -> 39088169 ; run #7... -> 39088169 ; run #8... -> 39088169 ; run #9... -> 39088169 ; run #10... -> 39088169 ; 10 runs, 2 best/worst removed, 6 left for average: ; cpu time: 778ms = 778ms + 0ms gc; real time: 780ms 39088169 ; run #1... -> #t ; run #2... -> #t ; run #3... -> #t ; run #4... -> #t ; run #5... -> #t ; run #6... -> #t ; run #7... -> #t ; run #8... -> #t ; run #9... -> #t ; run #10... -> #t ; 10 runs, 2 best/worst removed, 6 left for average: ; cpu time: 3ms = 3ms + 0ms gc; real time: 1007ms #t
Raku
(formerly Perl 6)
sub runrate($N where $N > 0, &todo) {
my $n = $N;
my $start = now;
todo() while --$n;
my $end = now;
say "Start time: ", DateTime.new($start).Str;
say "End time: ", DateTime.new($end).Str;
my $elapsed = $end - $start;
say "Elapsed time: $elapsed seconds";
say "Rate: { ($N / $elapsed).fmt('%.2f') } per second\n";
}
sub factorial($n) { (state @)[$n] //= $n < 2 ?? 1 !! $n * factorial($n-1) }
runrate 100_000, { state $n = 1; factorial($n++) }
runrate 100_000, { state $n = 1; factorial($n++) }
- Output:
Start time: 2023-04-19T08:23:50.276418Z End time: 2023-04-19T08:23:54.716864Z Elapsed time: 4.440445313 seconds Rate: 22520.26 per second Start time: 2023-04-19T08:23:54.726913Z End time: 2023-04-19T08:23:54.798238Z Elapsed time: 0.071324057 seconds Rate: 1402051.48 per second
The Instant type in Perl 6 is defined to be based on TAI seconds, and represented with rational numbers that are more than sufficiently accurate to represent your clock's accuracy. The actual accuracy will depend on your clock's accuracy (even if you don't have an atomic clock in your kitchen, your smartphone can track various orbiting atomic clocks, right?) modulo the vagaries of returning the atomic time (or unreasonable facsimile) via system calls and library APIs.
REXX
Programming note: The $CALC (REXX) program which is invoked below is a general purpose calculator which supports a multitude
of functions (over 1,500), and can show the results in many different formats (some of which are shown here).
/*REXX program reports on the amount of elapsed time 4 different tasks use (wall clock).*/
time.= /*nullify times for all the tasks below*/
/*──────────────────────────────────────────────────────────────────────────────────────*/
call time 'Reset' /*reset the REXX (elapsed) clock timer.*/
/*show pi in hex to 2,000 dec. digits.*/
task.1= 'base(pi,16) ;;; lowercase digits 2k echoOptions'
call '$CALC' task.1 /*perform task number one (via $CALC).*/
time.1=time('E') /*get and save the time used by task 1.*/
/*──────────────────────────────────────────────────────────────────────────────────────*/
call time 'Reset' /*reset the REXX (elapsed) clock timer.*/
/*get primes 40000 ──► 40800 and */
/*show their differences. */
task.2= 'diffs[ prime(40k, 40.8k) ] ;;; GRoup 20'
call '$CALC' task.2 /*perform task number two (via $CALC).*/
time.2=time('E') /*get and save the time used by task 2.*/
/*──────────────────────────────────────────────────────────────────────────────────────*/
call time 'Reset' /*reset the REXX (elapsed) clock timer.*/
/*show the Collatz sequence for a */
/*stupidly gihugeic number. */
task.3= 'Collatz(38**8) ;;; Horizontal'
call '$CALC' task.3 /*perform task number three (via $CALC)*/
time.3=time('E') /*get and save the time used by task 3.*/
/*──────────────────────────────────────────────────────────────────────────────────────*/
call time 'Reset' /*reset the REXX (elapsed) clock timer.*/
/*plot SINE in ½ degree increments.*/
/*using five decimal digits (¬ 60). */
task.4= 'sinD(-180, +180, 0.5) ;;; Plot DIGits 5 echoOptions'
call '$CALC' task.4 /*perform task number four (via $CALC).*/
time.4=time('E') /*get and save the time used by task 4.*/
/*──────────────────────────────────────────────────────────────────────────────────────*/
say
do j=1 while time.j\==''
say 'time used for task' j "was" right(format(time.j,,0),4) 'seconds.'
end /*j*/
/*stick a fork in it, we're all done. */
output (of the tasks as well as the above REXX timer program):
(The terminal screen size used was 60 deep x 100 wide.)
╔════════════════════════════════════════════════╗ ║ base(pi,16);;; lowercase digits 2k echoOptions ║ ╚════════════════════════════════════════════════╝ 3.243f6a8885a308d313198a2e03707344a4093822299f31d0082efa98ec4e6c89452821e638d01377be5466cf34e90c6cc 0ac29b7c97c50dd3f84d5b5b54709179216d5d98979fb1bd1310ba698dfb5ac2ffd72dbd01adfb7b8e1afed6a267e96ba7c 9045f12c7f9924a19947b3916cf70801f2e2858efc16636920d871574e69a458fea3f4933d7e0d95748f728eb658718bcd5 882154aee7b54a41dc25a59b59c30d5392af26013c5d1b023286085f0ca417918b8db38ef8e79dcb0603a180e6c9e0e8bb0 1e8a3ed71577c1bd314b2778af2fda55605c60e65525f3aa55ab945748986263e8144055ca396a2aab10b6b4cc5c341141e 8cea15486af7c72e993b3ee1411636fbc2a2ba9c55d741831f6ce5c3e169b87931eafd6ba336c24cf5c7a32538128958677 3b8f48986b4bb9afc4bfe81b6628219361d809ccfb21a991487cac605dec8032ef845d5de98575b1dc262302eb651b88238 93e81d396acc50f6d6ff383f442392e0b4482a484200469c8f04a9e1f9b5e21c66842f6e96c9a670c9c61abd388f06a51a0 d2d8542f68960fa728ab5133a36eef0b6c137a3be4ba3bf0507efb2a98a1f1651d39af017666ca593e82430e888cee86194 56f9fb47d84a5c33b8b5ebee06f75d885c12073401a449f56c16aa64ed3aa62363f77061bfedf72429b023d37d0d724d00a 1248db0fead349f1c09b075372c980991b7b25d479d8f6e8def7e3fe501ab6794c3b976ce0bd04c006bac1a94fb6409f60c 45e5c9ec2196a246368fb6faf3e6c53b51339b2eb3b52ec6f6dfc511f9b30952ccc814544af5ebd09bee3d004de334afd66 0f2807192e4bb3c0cba85745c8740fd20b5f39b9d3fbdb5579c0bd1a60320ad6a100c6402c7279679f25fefb1fa3cc8ea5e 9f8db3222f83c7516dffd616b152f501ec8ad0552ab323db5fafd23876053317b483e00df829e5c57bbca6f8ca01a87562e df1769dbd542a8f6287effc3ac6732c68c4f5573695b27b0bbca58c8e1ffa35db8f011a010fa3d98fd2183b84afcb56c2dd 1d35b9a53e479b6f84565d28e49bc4bfb9790e1ddf2daa4cb7e3362fb1341cee4c6e8ef20cada36774c01d07e9efe2bf11f b495dbda4dae909198eaad8e716b93d5a0d08ed1d0afc725e08e3c5b2f8e7594b78ff6e2fbf2122b648cb209fda49d89455 e99887a81cf7dc407e83568cdc24fd608c80225f7ada98babf283a8e1b06bbdbb6e99f6b4bc3e795e7be1c57b21085778ab 866f897578cec3600fb01b0789912575fefdc4595bf054658d676f6323cd6db1584bc6747713a2a431395d62de6646642e9 a995fb71811b93af99e6eb7b169c96740aa3a0f9ea3244ab192f10b595dc3e27cfec33f1341a2830a7a30cc356b0a13aa06 a5cffb2b87f9ae0dac27c0f649d4b5f0339 ╔════════════════════════════╗ ║ diffs[ prime(40k, 40.8k) ] ║ ╚════════════════════════════╝ 1► 30 12 2 4 14 42 4 2 4 20 4 2 10 2 10 20 10 6 6 20 21► 10 14 10 2 34 6 78 12 18 12 12 2 6 18 6 6 4 8 18 10 41► 8 22 2 10 2 36 4 6 8 4 6 6 8 12 10 6 14 4 60 14 61► 46 6 18 6 12 12 12 14 16 24 12 14 28 30 8 10 8 4 18 8 81► 12 10 12 2 6 12 22 8 16 6 14 6 4 12 14 10 8 6 6 4 101► 14 6 4 18 8 4 20 18 48 4 2 4 36 20 10 6 8 22 8 16 121► 14 22 20 12 12 18 18 22 6 12 30 14 6 12 16 6 8 12 4 2 141► 22 30 2 16 18 14 6 6 24 6 4 2 12 6 12 4 26 30 24 34 161► 20 4 8 4 6 12 20 22 6 2 16 6 56 10 14 10 14 4 2 10 181► 20 18 28 14 24 4 8 12 16 6 6 2 6 6 10 14 4 42 18 6 201► 2 4 6 8 12 30 24 4 24 6 6 8 18 4 20 4 2 18 4 6 221► 2 12 12 10 6 8 6 16 14 16 8 10 24 2 10 24 2 18 24 6 241► 10 14 46 14 30 10 26 30 12 24 4 12 30 2 10 8 4 6 8 4 261► 30 8 28 6 14 10 20 10 12 8 10 2 24 10 24 14 10 8 4 20 281► 18 10 6 6 14 34 8 10 14 6 22 26 12 10 8 6 18 6 4 6 301► 6 14 22 2 16 2 10 14 10 6 14 24 22 8 16 18 20 28 8 10 321► 24 6 12 12 20 6 6 6 22 2 18 10 12 8 6 22 14 16 24 18 341► 2 24 12 22 8 4 24 14 6 22 8 10 2 28 2 4 38 12 34 20 361► 10 2 4 8 18 4 48 12 24 6 18 12 6 8 10 42 24 14 60 24 381► 36 12 22 8 12 12 6 4 18 20 12 10 8 6 24 6 4 30 6 2 401► 54 48 36 4 12 8 12 6 22 6 6 14 10 32 18 12 10 24 24 20 421► 6 10 6 38 10 14 18 12 16 12 2 22 24 42 8 4 2 60 6 10 441► 14 18 18 18 16 30 14 4 2 10 8 10 20 12 16 14 6 24 16 2 461► 12 10 18 2 24 34 12 14 6 10 6 2 10 8 28 2 10 2 6 10 481► 26 10 6 32 10 12 6 2 16 12 20 10 14 6 12 16 20 4 2 10 501► 14 4 6 2 4 14 16 8 36 10 2 12 16 20 4 12 6 30 38 16 521► 6 14 4 2 22 6 14 16 6 8 28 2 6 16 6 14 6 12 22 44 541► 6 4 24 2 6 28 14 22 20 4 6 36 14 18 6 4 6 26 4 2 561► 18 10 6 6 2 6 4 8 18 54 28 12 2 4 30 12 2 6 24 10 581► 12 6 8 10 6 8 16 12 14 6 4 18 8 10 2 12 30 16 2 6 601► 36 10 30 6 18 6 6 2 10 30 6 12 50 24 6 4 8 10 26 6 621► 4 2 18 4 2 6 10 12 2 24 16 6 2 6 4 8 4 6 8 6 641► 28 18 2 6 10 2 22 18 14 30 10 26 28 6 30 8 6 10 6 6 661► 2 10 36 2 12 10 6 6 6 14 6 10 20 12 6 24 6 6 28 18 681► 14 4 12 12 26 12 22 12 8 10 8 24 10 8 40 8 4 14 6 24 701► 4 18 12 6 20 22 2 16 6 20 16 30 8 6 18 6 22 18 2 18 721► 4 8 10 8 22 8 6 36 10 12 2 4 14 42 18 22 6 14 4 2 741► 10 2 42 10 18 30 2 6 4 14 6 10 14 4 18 2 16 14 10 2 761► 28 2 16 2 16 12 12 2 16 12 2 24 40 6 8 6 4 30 8 10 781► 14 18 6 16 18 6 2 18 4 6 6 26 4 26 28 26 24 4 32 6 ╔════════════════╗ ║ Collatz(38**8) ║ ╚════════════════╝ 4347792138496 2173896069248 1086948034624 543474017312 271737008656 135868504328 67934252164 33967126082 16983563041 50950689124 25475344562 12737672281 38213016844 19106508422 9553254211 28659762634 14329881317 42989643952 21494821976 10747410988 5373705494 2686852747 8060558242 4030279121 12090837364 6045418682 3022709341 9068128024 4534064012 2267032006 1133516003 3400548010 1700274005 5100822016 2550411008 1275205504 637602752 318801376 159400688 79700344 39850172 19925086 9962543 29887630 14943815 44831446 22415723 67247170 33623585 100870756 50435378 25217689 75653068 37826534 18913267 56739802 28369901 85109704 42554852 21277426 10638713 31916140 15958070 7979035 23937106 11968553 35905660 17952830 8976415 26929246 13464623 40393870 20196935 60590806 30295403 90886210 45443105 136329316 68164658 34082329 102246988 51123494 25561747 76685242 38342621 115027864 57513932 28756966 14378483 43135450 21567725 64703176 32351588 16175794 8087897 24263692 12131846 6065923 18197770 9098885 27296656 13648328 6824164 3412082 1706041 5118124 2559062 1279531 3838594 1919297 5757892 2878946 1439473 4318420 2159210 1079605 3238816 1619408 809704 404852 202426 101213 303640 151820 75910 37955 113866 56933 170800 85400 42700 21350 10675 32026 16013 48040 24020 12010 6005 18016 9008 4504 2252 1126 563 1690 845 2536 1268 634 317 952 476 238 119 358 179 538 269 808 404 202 101 304 152 76 38 19 58 29 88 44 22 11 34 17 52 26 13 40 20 10 5 16 8 4 2 1 ╔════════════════════════════════════════════════════╗ ║ sinD(-180, +180, 0.5);;; Plot DIGits 5 echoOptions ║ ╚════════════════════════════════════════════════════╝ │1 ∙∙∙∙∙∙ │ ∙∙∙ ∙∙∙ │ ∙∙∙ ∙∙∙ │ ∙∙ ∙∙ │ ∙∙ ∙∙ │ ∙∙ ∙∙ │ ∙∙ ∙∙ │ ∙ ∙ │ ∙ ∙ │ ∙∙ ∙∙ │ ∙∙ ∙∙ │ ∙ ∙ │ ∙∙ ∙∙ │ ∙ ∙∙ │ ∙ ∙ │ ∙∙ ∙∙ │ ∙ ∙ │ ∙∙ ∙∙ │ ∙ ∙ │ ∙∙ ∙ │ ∙ ∙ │ ∙ ∙ │ ∙∙ ∙∙ │ ∙ ∙ │ ∙∙ ∙∙ │ ∙ ∙ │ ∙∙ ∙∙ │ ∙ ∙ │0 ∙∙ ∙∙ ∙──────────────────────────────────────────────∙──────────────────────────────────────────────∙ ∙∙ ∙∙ 721 │∙ ∙ │∙∙ ∙∙ │ ∙ ∙ │ ∙∙ ∙∙ │ ∙ ∙ │ ∙ ∙∙ │ ∙∙ ∙ │ ∙ ∙∙ │ ∙∙ ∙ │ ∙ ∙ │ ∙∙ ∙∙ │ ∙ ∙ │ ∙∙ ∙∙ │ ∙ ∙ │ ∙ ∙∙ │ ∙∙ ∙∙ │ ∙ ∙ │ ∙ ∙∙ │ ∙∙ ∙∙ │ ∙∙ ∙ │ ∙ ∙∙ │ ∙∙ ∙∙ │ ∙∙ ∙∙ │ ∙∙ ∙∙ │ ∙∙ ∙∙ │ ∙∙∙ ∙∙ │ ∙∙∙ ∙∙∙ │-1 ∙∙∙∙∙∙ time used for task 1 was 0 seconds. time used for task 2 was 2 seconds. time used for task 3 was 0 seconds. time used for task 4 was 0 seconds.
Ring
# Project : Rate counter
see "method 1: calculate reciprocal of elapsed time:" + nl
for trial = 1 to 3
start = clock()
tasktomeasure()
finish = clock()
see "rate = " + 100 / (finish-start) + " per second" + nl
next
see "method 2: count completed tasks in one second:" + nl
for trial = 1 to 3
runs = 0
finish = clock() + 100
while clock() < finish
tasktomeasure()
if clock() < finish
runs = runs + 1
ok
end
see "rate = " + runs + " per second" + nl
next
func tasktomeasure
for i = 1 to 100000
next
Output:
method 1: calculate reciprocal of elapsed time: rate = 6.67 per second rate = 6.25 per second rate = 6.67 per second method 2: count completed tasks in one second: rate = 5 per second rate = 6 per second rate = 5 per second
Ruby
Testing lookup speed in array versus hash:
require 'benchmark'
Document = Struct.new(:id,:a,:b,:c)
documents_a = []
documents_h = {}
1.upto(10_000) do |n|
d = Document.new(n)
documents_a << d
documents_h[d.id] = d
end
searchlist = Array.new(1000){ rand(10_000)+1 }
Benchmark.bm(10) do |x|
x.report('array'){searchlist.each{|el| documents_a.any?{|d| d.id == el}} }
x.report('hash'){searchlist.each{|el| documents_h.has_key?(el)} }
end
System: I7-6700HQ, 3.5 GHz, Linux Kernel 5.6.17, Ruby 2.7.1 Run as: $ ruby ratecounter.rb
- Output:
user system total real array 0.308848 0.037154 0.346002 ( 0.158290) hash 0.005239 0.001036 0.006275 ( 0.002252) ➜ rosettacode
Run BASIC
html "<table bgcolor=wheat border=1><tr><td align=center colspan=2>Rate Counter</td></tr>
<tr><td>Run Job Times</td><td>"
textbox #runTimes,"10",3
html "</tr><tr><td align=center colspan=2>"
button #r,"Run", [runIt]
html " "
button #a, "Average", [ave]
html "</td></tr></table>"
wait
[runIt]
runTimes = min(10,val(#runTimes contents$()))
count = count + 1
print "-------- Run Number ";count;" ----------------"
print "Run jobs";runTimes;" times, reporting each"
for i = 1 to runTimes
' -----------------------------------------------------------------
' Normally we use a RUN() command to run another program
' but for test pruporse we have a routine that simply loops a bunch
' -----------------------------------------------------------------
begTime = time$("ms")
theRun = bogusProg()
endTime = time$("ms")
lapsTime = endTime - begTime
print "Job #";i;" Elapsed time, ms ";lapsTime;" ";1000/lapsTime; " ticks per second"
next
aveTime = (endTime-startTime)/runTimes
totAveTime = totAveTime + aveTime
print "Average time, ms, is ";aveTime;" "; 1000/((endTime-startTime)/runTimes); " ticks per second"
wait
[ave]
print "---------------------------------"
print "Total average time:";aveTime/count
function bogusProg()
for i = 1 to 10000
sini = sini + sin(i)
tani = tani + tan(i)
cpsi = cosi + cos(i)
next
end function
Output:
Rate Counter | |
Run Job Times | 10 |
<button value="Run"/> <button value="Average"/> |
.-------- Run Number 1 ----------------
Run jobs 2 times, reporting each
Job #1 Elapsed time, ms 50 20 ticks per second
Job #2 Elapsed time, ms 48 20.8333349 ticks per second
Average time, ms, is 1754768605184 5.69875717e-10 ticks per second
.-------- Run Number 2 ----------------
Run jobs 3 times, reporting each
Job #1 Elapsed time, ms 47 21.2765955 ticks per second
Job #2 Elapsed time, ms 47 21.2765955 ticks per second
Job #3 Elapsed time, ms 47 21.2765955 ticks per second
Average time, ms, is 1169845780480 8.54813575e-10 ticks per second
.---------------------------------
Total average time:584922890240
Scala
The solution below measures the number of tasks run in 5, 10 and 15 seconds. The tasks, however, run multithreaded, not sequentially. It also does not stop the remaining tasks once the time is up.
def task(n: Int) = Thread.sleep(n * 1000)
def rate(fs: List[() => Unit]) = {
val jobs = fs map (f => scala.actors.Futures.future(f()))
val cnt1 = scala.actors.Futures.awaitAll(5000, jobs: _*).count(_ != None)
val cnt2 = scala.actors.Futures.awaitAll(5000, jobs: _*).count(_ != None)
val cnt3 = scala.actors.Futures.awaitAll(5000, jobs: _*).count(_ != None)
println("%d jobs in 5 seconds" format cnt1)
println("%d jobs in 10 seconds" format cnt2)
println("%d jobs in 15 seconds" format cnt3)
}
rate(List.fill(30)(() => task(scala.util.Random.nextInt(10)+1)))
The solution below runs a task repeatedly, for at most N seconds or Y times. The precision available is milliseconds, though the sampling was limited to seconds. It will wait until the current execution of the task is finished before announcing the result, if the time runs out.
def rate(n: Int, y: Int)(task: => Unit) {
val startTime = System.currentTimeMillis
var currTime = startTime
var loops = 0
do {
task
currTime = System.currentTimeMillis
loops += 1
} while (currTime - startTime < n * 1000 && loops < y)
if (currTime - startTime > n * 1000)
println("Rate %d times per %d seconds" format (loops - 1, n))
else
println("Rate %d times in %.3f seconds" format (y, (currTime - startTime).toDouble / 1000))
}
rate(5, 20)(task(2))
Sidef
var benchmark = frequire('Benchmark');
func job1 {
#...job1 code...
}
func job2 {
#...job2 code...
}
const COUNT = -1; # run for one CPU second
benchmark.timethese(COUNT, Hash.new('Job1' => job1, 'Job2' => job2));
Smalltalk
|times|
times := Bag new.
1 to: 10 do: [:n| times add:
(Time millisecondsToRun: [3000 factorial])].
Transcript show: times average asInteger.
Output:
153
Tcl
The standard Tcl mechanism to measure how long a piece of code takes to execute is the time
command. The first word of the string returned (which is also always a well-formed list) is the number of microseconds taken (in absolute time, not CPU time). Tcl uses the highest performance calibrated time source available on the system to compute the time taken; on Windows, this is derived from the system performance counter and not the (poor quality) standard system time source.
set iters 10
# A silly example task
proc theTask {} {
for {set a 0} {$a < 100000} {incr a} {
expr {$a**3+$a**2+$a+1}
}
}
# Measure the time taken $iters times
for {set i 1} {$i <= $iters} {incr i} {
set t [lindex [time {
theTask
}] 0]
puts "task took $t microseconds on iteration $i"
}
When tasks are are very quick, a more accurate estimate of the time taken can be gained by repeating the task many times between time measurements. In this next example, the task (a simple assignment) is repeated a million times between measures (this is very useful when performing performance analysis of the Tcl implementation itself).
puts [time { set aVar 123 } 1000000]
UNIX Shell
This code stores the number of times the program task can complete in 20 seconds. It is two parts.
Part 1: file "foo.sh"
This script spins, executing task as many times as possible.
#!/bin/bash
while : ; do
task && echo >> .fc
done
Part 2:
This script runs foo.sh in the background, and checks the rate count file every five seconds. After four such checks, twenty seconds will have elapsed.
./foo.sh &
sleep 5
mv .fc .fc2 2>/dev/null
wc -l .fc2 2>/dev/null
rm .fc2
sleep 5
mv .fc .fc2 2>/dev/null
wc -l .fc2 2>/dev/null
sleep 5
mv .fc .fc2 2>/dev/null
wc -l .fc2 2>/dev/null
sleep 5
killall foo.sh
wc -l .fc 2>/dev/null
rm .fc
V (Vlang)
import rand
import time
// representation of time.Time is nanosecond, actual resolution system specific
struct RateStateS {
mut:
last_flush time.Time
period time.Duration
tick_count int
}
fn (mut p_rate RateStateS) tic_rate() {
p_rate.tick_count++
now := time.now()
if now-p_rate.last_flush >= p_rate.period {
// TPS Report
mut tps := 0.0
if p_rate.tick_count > 0 {
tps = f64(p_rate.tick_count) / (now-p_rate.last_flush).seconds()
}
println("$tps tics per second.")
// Reset
p_rate.tick_count = 0
p_rate.last_flush = now
}
}
fn something_we_do() {
time.sleep(time.Duration(i64(9e7) + rand.i64n(i64(2e7)) or {i64(0)})) // sleep about .1 second.
}
fn main() {
start := time.now()
mut rate_watch := RateStateS{
last_flush: start,
period: 5 * time.second,
}
// Loop for twenty seconds
mut latest := start
for latest-start < 20*time.second {
something_we_do()
rate_watch.tic_rate()
latest = time.now()
}
}
Output:
10.029074483576407 tics per second. 9.946060524563189 tics per second. 9.97480364599023 tics per second.
Wren
For bench-marking purposes, Wren uses the System.clock method which returns the number of seconds (to 6 decimal places) since the script was started.
The precision of System.clock is not documented but since it calls C's clock() function in <timer.h> in the background it will certainly be no more than 1 microsecond and, in practice, resolution may be no better than 10 milliseconds on many systems.
Note that, in an attempt to obtain more meaningful times, I've called the function 1 million times compared to just one in the Kotlin example which uses a more accurate timer.
var cube = Fn.new { |n| n * n * n }
var benchmark = Fn.new { |n, func, arg, calls|
var times = List.filled(n, 0)
for (i in 0...n) {
var m = System.clock
for (j in 0...calls) func.call(arg)
times[i] = ((System.clock - m) * 1000).round // milliseconds
}
return times
}
System.print("Timings (milliseconds) : ")
for (time in benchmark.call(10, cube, 5, 1e6)) System.print(time)
- Output:
Sample run:
Timings (milliseconds) : 55 48 45 45 45 45 45 45 45 46
XPL0
include c:\cxpl\codes; \intrinsic 'code' declarations
int N, I, T0, Time;
[for N:= 1, 3 do
[T0:= GetTime;
for I:= 1 to 100 do
[while port($3DA) & $08 do []; \wait for vertical retrace to go away
repeat until port($3DA) & $08; \wait for vertical retrace signal
];
Time:= GetTime - T0;
IntOut(0, Time); Text(0, " microseconds for 100 samples = ");
RlOut(0, 100.0e6/float(Time)); Text(0, "Hz"); CrLf(0);
];
]
Example output of vertical blanking (screen refresh) rates:
These measurements were taken while running under DOS 5.0 with the output redirected to a file. When the output is instead displayed on the screen, the second two readings consistently match for the first five digits. The first reading varies because the program (purposely) does not sync up on the retrace signal before starting the measurements. 1682024 microseconds for 100 samples = 59.45218Hz 1683980 microseconds for 100 samples = 59.38313Hz 1689918 microseconds for 100 samples = 59.17447Hz These measurements were taken on a Windows XP machine running in windowed mode: 1384184 microseconds for 100 samples = 72.24473Hz 1355413 microseconds for 100 samples = 73.77825Hz 1326029 microseconds for 100 samples = 75.41313Hz These measurements were taken on the same Windows machine in full-screen mode: 1418413 microseconds for 100 samples = 70.50133Hz 1424391 microseconds for 100 samples = 70.20544Hz 1395069 microseconds for 100 samples = 71.68104Hz
Yabasic
iterations = 100000
for j = 2 to 4
a = peek("millisrunning")
for i = 1 to iterations
void = i + j^2
next
dif = peek("millisrunning") - a
print "take ", dif, " ms";
print " or ", iterations / dif * 1000 using "########", " sums per second"
next
zkl
One second resolution and we let the computation run to completion. We could run the computation in a thread and signal it if time is up but that doesn't seem reasonable.
fcn rateCounter(f,timeNRuns,secsToRun=Void){
now:=Time.Clock.time;
if(secsToRun){
then:=now + secsToRun;
N:=0; do{ f(); N+=1; }while(Time.Clock.time<then);
t:=Time.Clock.time - now;
println("%d runs in %s seconds = %.3f sec/run"
.fmt(N,Time.Date.toHMSString(0,0,t),t.toFloat()/N));
}
else{
do(timeNRuns){ f() }
t:=Time.Clock.time - now;
println("%s seconds to run %d times = %.3f sec/run"
.fmt(Time.Date.toHMSString(0,0,t),timeNRuns,
t.toFloat()/timeNRuns));
t
}
}
ns:=List.createLong(0d100_000,(0).random,True); // one hundred thousand ints
rateCounter('wrap(){ ns.copy().sort() },20);
rateCounter('wrap(){ ns.copy().sort() },Void,10);
- Output:
00:00:19 seconds to run 20 times = 0.950 sec/run 11 runs in 00:00:10 seconds = 0.909 sec/run
- Programming Tasks
- Solutions by Programming Task
- Action!
- Action! Tool Kit
- Ada
- Arturo
- AutoHotkey
- BaCon
- BASIC256
- BBC BASIC
- C
- C++
- Chipmunk Basic
- Common Lisp
- Crystal
- D
- Delphi
- System.SysUtils
- System.Diagnostics
- E
- EasyLang
- Erlang
- ERRE
- Fortran
- FreeBASIC
- Go
- Haskell
- HicEst
- J
- Java
- JavaScript
- Jq
- Jsish
- Julia
- Kotlin
- Liberty BASIC
- Mathematica
- Wolfram Language
- Nim
- OxygenBasic
- PARI/GP
- Perl
- Phix
- Phixmonti
- PicoLisp
- PowerShell
- PureBasic
- Python
- Racket
- Raku
- REXX
- Ring
- Ruby
- Run BASIC
- Scala
- Sidef
- Smalltalk
- Tcl
- UNIX Shell
- V (Vlang)
- Wren
- XPL0
- Yabasic
- Zkl