Rate counter: Difference between revisions

 

'''See also:''' [[System time]], [[Time a function]]

 

=={{header|Ada}}==

to get CPU times would use the package Ada.Execution_Time (Ada05).<br>

The precision of measure is given by the value of System.Tick; on Windows value is 10 ms.

with Ada.Text_IO; use Ada.Text_IO;

with Ada.Calendar; use Ada.Calendar;

end loop;

 

 

Output on a Linux 64 bits system:

0.000001 seconds is the precision of System clock.

</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.

Tick := A_TickCount ; store tickcount

Loop, 1000000 {

t := b, b := Mod(a, b), a := t

return, a

'''Output:'''

<pre>4.250000 Seconds elapsed.

===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.

QPX(1) ; start timer

Loop, 1000000 {

t := b, b := Mod(a, b), a := t

return, a

'''Output:'''

<pre>4.428430 Seconds elapsed.

The TIMER builtin returns the elapsed time since start of program run, in milliseconds.

 

FOR i = 1 TO 3

GOSUB timeit

WEND

PRINT iter, " iterations in ", i, " millisecond", IIF$(i > 1, "s", "")

 

{{out}}

23977 iterations in 3 milliseconds

28167202 iterations in 2000 milliseconds</pre>

 

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

FOR trial% = 1 TO 3

start% = TIME

FOR i% = 1 TO 1000000

NEXT

'''Sample output:'''

<pre>

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 <time.h>

 

 

return 0;

 

=={{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.

 

#include <ctime>

 

 

return 0;

 

=={{header|Common Lisp}}==

Common Lisp already has a <code>time</code> macro.

(let ((real-t (gensym)) (run-t (gensym)))

`(let (,real-t ,run-t)

(coerce internal-time-units-per-second 'float))

(/ (- (get-internal-run-time) ,run-t)

 

Call the <code>time-this</code> macro to excute a loop 99 times:

 

=={{header|Crystal}}==

{{trans|Ruby}}

Testing lookup speed in array versus hash:

 

struct Document

x.report("array"){searchlist.each{ |el| documents_a.any?{ |d| d == el }} }

x.report("hash") {searchlist.each{ |el| documents_h.has_key?(el) } }

 

System: I7-6700HQ, 3.5 GHz, Linux Kernel 5.6.17, Crystal 0.35

=={{header|D}}==

 

import std.stdio;

import std.conv;

}

 

 

{{out}}

 

</pre>

 

=={{header|E}}==

 

The rate counter:

return [signal, &rate]

 

The test code:

 

def theJob() {

return when (def text := <http://localhost/> <- getText()) -> {

signal()

theJob()

 

=={{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.

-module( rate_counter ).

 

end.

 

{{out}}

<pre>

 

=={{header|ERRE}}==

PROGRAM RATE_COUNTER

 

END FOR

END PROGRAM

Time elapsed is measured with TIMER function (taken from computer clock).

{{out}}

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.

 

IF (PROGRESSNOTE((I - FIRST)/(LAST - FIRST + 1.0))) WRITE (6,*) "Reached ",I,", towards ",LAST

...much computation...

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>

 

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|Go}}==

{{trans|C}}

 

import (

latest = time.Now()

}

Output:

<pre>

=={{header|Haskell}}==

This solution returns the time deltas in picosecond resolution.

import Control.Monad

import Control.Concurrent

 

main = timeit 10 (threadDelay 1000000)

 

=={{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.

 

DLG(Button="1:&Hits++", CALL="cb", B="2:&Count 5sec", B="3:&Rate", RC=retcod, TItle=prompt, WIN=hdl)

SUBROUTINE F5 ! called 5 sec after button "5 sec"

WRITE(StatusBar) Hits, "hits last 5 sec"

 

=={{header|J}}==

'''Solution'''<br>

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:'''

freqtable=: ~. ,. #/.~ NB. verb to calculate and build frequency table

20 (6!:2) 'freqtable list' NB. calculate and build frequency table for list, 20 times

 

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

 

 

=={{header|Java}}==

{{trans|JavaScript}}

{{works with|Java|8}}

 

public class RateCounter {

return timings;

}

 

<pre>70469.0

{{trans|JavaScript}}

{{works with|Java|8}}

import java.util.stream.DoubleStream;

 

;

}

 

<pre>81431.0

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.

 

return (new Date()).getTime();

}

}

return times;

 

=={{header|Jsish}}==

"use strict";

/* Rate counter, timer access, in Jsish */

timer = times(sleeper, 100);

puts(timer, 'μs to sleep 10 ms, 100 times');

 

{{out}}

=={{header|Julia}}==

The elapsed() macro in Julia generally is accurate in the nanosecond range.

 

function runNsecondsworthofjobs(N)

 

runNsecondsworthofjobs(5)

Average time per run was 1.0430602148 seconds.

Individual times of the jobs in seconds were:

=={{header|Kotlin}}==

{{trans|JavaScript}}

 

typealias Func<T> = (T) -> T

println("\nTimings (nanoseconds) : ")

for (time in benchmark(10, ::cube, 5)) println(time)

 

Sample output:

=={{header|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 ";

testFunc = s

end function

 

The first parameter for both of these functions can be any program code.

SetAttributes[jobRateCounted,HoldFirst]

jobRatePeriod[fn_,time_]:=Block[{n=0},TimeConstrained[While[True,fn;n++]];n/time];

 

=={{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.

'========

'TIME API

'Finish: 2012-07-01 00:52:36:974

'Sunday July 01 2012

 

=={{header|PARI/GP}}==

b=0;

for(n=1,20000000,

a=a+gettime();

if(a>60000,print(b);a=0;b=0)

 

=={{header|Perl}}==

The [http://perldoc.perl.org/Benchmark.html Benchmark] module can rate code per time, or per loops executed:

 

timethese COUNT,{ 'Job1' => &job1, 'Job2' => &job2 };

{

...job2 code...

A negative COUNT will run each job for at least COUNT seconds.<br>

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.

{{out}}

Of course it fails to achieve the perfect 10/s, due to the overhead of call/ret/time/printf etc.

 

=={{header|Phixmonti}}==

2 4 2 tolist

for

"take " print dif print " secs" print

" or " print iterations dif / print " sums per second" print nl

 

=={{header|PicoLisp}}==

microseconds. This can be used, for example, to measure the time between two key

strokes

(key)

(prinl)

(key)

(prinl)

Output:

<pre>Hit a key ...

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

<pre>1.761 sec

-> "a"</pre>

 

=={{header|PowerShell}}==

[datetime]$start = Get-Date

 

 

$rate | Format-List

{{Out}}

<pre>

=={{header|PureBasic}}==

===Counting frequence of an event===

Static starttime, cnt

Protected Result.d, dt

EndIf

Until Event=#PB_Event_CloseWindow

 

===Counting events for a time period===

Define.d dummy=#PI*Pow(arg,2)/4

EndProcedure

 

msg$="We got "+Str(cnt)+" st."+Chr(10)+StrF(cnt/10,2)+" threads per sec."

 

=={{header|Python}}==

import time

 

taskTimer( int(sys.argv[1]), sys.argv[2:])

 

Usage Example:

First argument is the number of times to iterate. Additional arguments are command to execute.

 

=={{header|Racket}}==

#lang racket

 

;; But of course, can be used to measure external processes too:

(time* 10 (system "sleep 1"))

 

Sample output:

=={{header|Raku}}==

(formerly Perl 6)

my $n = $N;

 

sub factorial($n) { (state @)[$n] //= $n < 2 ?? 1 !! $n * factorial($n-1) }

 

 

{{out}}

 

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.

 

Programming note: &nbsp; The &nbsp; '''$CALC''' &nbsp; (REXX) program which is invoked below is a general purpose calculator which supports a multitude

<br>of functions (over 1,500), &nbsp; and can show the results in many different formats &nbsp; (some of which are shown here).

time.= /*nullify times for all the tasks below*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

say 'time used for task' j "was" right(format(time.j,,0),4) 'seconds.'

end /*j*/

'''output''' &nbsp; (of the tasks as well as the above REXX timer program):

 

 

=={{header|Ring}}==

# Project : Rate counter

 

for i = 1 to 100000

next

Output:

<pre>

=={{header|Ruby}}==

Testing lookup speed in array versus hash:

Document = Struct.new(:id,:a,:b,:c)

documents_a = []

x.report('array'){searchlist.each{|el| documents_a.any?{|d| d.id == el}} }

x.report('hash'){searchlist.each{|el| documents_h.has_key?(el)} }

 

System: I7-6700HQ, 3.5 GHz, Linux Kernel 5.6.17, Ruby 2.7.1

 

=={{header|Run BASIC}}==

<tr><td>Run Job Times</td><td>"

textbox #runTimes,"10",3

cpsi = cosi + cos(i)

next

Output:

 

once the time is up.

 

def rate(fs: List[() => Unit]) = {

val jobs = fs map (f => scala.actors.Futures.future(f()))

}

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

result, if the time runs out.

 

val startTime = System.currentTimeMillis

var currTime = startTime

println("Rate %d times in %.3f seconds" format (y, (currTime - startTime).toDouble / 1000))

}

 

=={{header|Sidef}}==

{{trans|Perl}}

 

func job1 {

 

const COUNT = -1; # run for one CPU second

 

=={{header|Smalltalk}}==

{{works with|Pharo}}

{{works with|Smalltalk/X}}

times := Bag new.

1 to: 10 do: [:n| times add:

(Time millisecondsToRun: [3000 factorial])].

Output:

<pre>153</pre>

=={{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.

 

# A silly example task

}] 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).

 

=={{header|UNIX Shell}}==

<br>

This script spins, executing '''task''' as many times as possible.

 

while : ; do

task && echo >> .fc

 

Part 2:

<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.

sleep 5

mv .fc .fc2 2>/dev/null

killall foo.sh

wc -l .fc 2>/dev/null

 

=={{header|Wren}}==

 

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 benchmark = Fn.new { |n, func, arg, calls|

 

System.print("Timings (milliseconds) : ")

 

{{out}}

 

=={{header|XPL0}}==

int N, I, T0, Time;

[for N:= 1, 3 do

RlOut(0, 100.0e6/float(Time)); Text(0, "Hz"); CrLf(0);

];

 

Example output of vertical blanking (screen refresh) rates:

 

=={{header|Yabasic}}==

 

for j = 2 to 4

print "take ", dif, " ms";

print " or ", iterations / dif * 1000 using "########", " sums per second"

 

=={{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.

now:=Time.Clock.time;

if(secsToRun){

t

}

rateCounter('wrap(){ ns.copy().sort() },20);

{{out}}

<pre>