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.

225814 Loop iterations per second.</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|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}}

Rate = 15 per second

</pre>

 

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

 

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

 

{{out}}

 

 

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

#t

</pre>

 

=={{header|REXX}}==

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

 

time used for task 3 was 0 seconds.

time used for task 4 was 0 seconds.

</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)} }

{{Output}}

<pre>

user system total real

</pre>

 

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

</pre>

 

 

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