Updated 2012-12-04 21:07:05 by pooryorick

time script ?iterations?

Executes script and reports how long it takes per iteration (if iterations is absent, only one iteration is used). From 8.5, the report has sub-microsecond resolution (with accuracy depending on the OS's available timers).

Does anyone have some examples of using Tcl's time command?
 time {myCommand $arg1 $arg2} 1000

will run the specified command, with substitutions performed, 1000 times, and finally return a list like this:
 123456 microseconds per iteration

The higher you give the factor, the more precise the measurement will be, but of course take proportional time - so best start with small values, and increase until it feels too slow.

See How to measure Performance for additional info - but no obvious examples.

Also another use of the word time is as a network protocol for the transmission of time data - see RFC868 [1] NTP is a more sophisticated protocol, but the time protocol does a simple job simply.

In yet another different use of the word time, LV asks "Has anyone written a time chooser similar to the date chooser widgets written elsewhere on the Wiki?" Larry refers to A little date chooser and An i15d date chooser.

You might like to check out: timeentry and timefield.

You can measure the runtime of a lengthy script with the following pattern:
 set t0 [clock clicks -millisec]
 puts stderr "[expr ([clock clicks -millisec]-$t0)/1000.] sec" ;# RS

Even when you're not interested in the timing, you can use time as a simple control structure for loops:
 time {puts Hello} 5

instead of
 for {set i 0} {$i<5} {incr i} {puts Hello}

(MS voip in the Tcl chatroom 2005-03-03, brought here by RS)

LV Sometimes users ask how to get a tcl program's time in terms of real/user/system, similar to how they would use the ksh built in time command. The command documented on this page doesn't provide information of that granularity. Does anyone know of alternative methods?

AMG, adapted from an email by MS:

"[time] has more looping overhead than a script version! See below for proof."
proc f {} {}

proc a {} {
    set n 100000
    puts [time f $n]

    set c $n
    incr c
    set start [clock microseconds]
    while {[incr c -1]} {
    set end [clock microseconds]

    puts "[expr {($end - $start)/double($n)}] microseconds per iteration"


On my machine (WinXP, Tcl 8.6b1.2), this produces the following times:
3.78325 microseconds per iteration
1.62831 microseconds per iteration

[f] is run 100,000 times, both by [time] and by [while]/[incr]]. Strangely enough, it takes [time] more than twice as long as [while] to do this. That makes no sense. Maybe [time] is recompiling the script "f" each time. But, how long can it take to compile a script that's only one character long???

A stabilized timing helper edit

DKF: It's not always easy to pick a good number of iterations to run the timing script for. This script picks a balance by trying to use the number of iterations that would take about 2 seconds (subject to it being a minimum of 500 iterations)

Explanation: The script first tries to factor out the compilation time, then does an initial timing run to estimate the number of iterations for the main run.
proc measure args {
    set it [expr {int(ceil(10000./[lindex [time $args] 0]))}]
    set it [expr {int(ceil(2000000./[lindex [time $args $it] 0]))}]
    while {$it < 500} {set it 500}
    lindex [time $args $it] 0

Use it like this:
measure theProc arg1 arg2...

Adapting to take a single script argument instead is trivial.