Description

Does anyone have some examples of using Tcl's time command? time executes script one time, or optionally, iterations times, time {myCommand $arg1 $arg2} 1000

 time {myCommand $arg1 $arg2} 1000

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

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. More iterations increase the precision of the returned value, at the cost of

Also another use of the word time is as a network protocol for the transmission of time data - see RFC868 [L1 ] 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 can measure the runtime of a lengthy script with the following pattern: You might like to check out: timeentry and timefield.

set t0 [clock clicks -millisec]
 set t0 [clock clicks -millisec]
 ...
 ...
 puts stderr "[expr ([clock clicks -millisec]-$t0)/1000.] sec" ;# RS

[kbk], Tcl's own wizard of speed and time,  has done all the work to ensure
----
Even when you're not interested in the timing, you can use [time] as a simple control structure for loops:

proc measure args {
 time {puts Hello} 5

Use it like this:

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

 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.

"time has more looping overhead than a script version! See below for proof." "[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]} {
        f
    }
    set end [clock microseconds]

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

a

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??? [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

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

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.

See Also