Previous: Threads Up: Contents Next: Association lists

Time

Arc provides several functions to determine the current time, measure time intervals, and measure the execution time of expressions. Many of the functions use a system-dependent time base, which is typically the number of seconds since January 1, 1970; see the MzScheme time documentation for details.

One rather complex procedure is cache, which creates a procedure that generates and caches a value. cache takes a function to generate the cache lifetime, as well as a function to generate the value to cache. The value function is executed the first time the created procedure is called, and will be executed again only if the created procedure is called when the cache lifetime has expired. Otherwise, the cached value is returned. Typically a cache is used when the value function is something expensive to evaluate. The motivation behind dynamically computing the cache lifetime is that the lifetime can be modified for an existing cache, for instance through a global variable.

arc> (= mycache (cache (fn () 10) (fn () (prn "evaluated") (tostring (system "date")))))
#<procedure>
arc> (mycache)
evaluated
"Mon Mar 10 21:08:33 PDT 2008\n"
arc> (mycache)
"Mon Mar 10 21:08:33 PDT 2008\n"
arc> (mycache)
evaluated
"Mon Mar 10 21:08:46 PDT 2008\n"

Time

date [time]

Displays the specified date (or current date by default). This works only on Unix-like systems.

>(date)
2008年02月20日

seconds

Returns current time in seconds, from a platform-specific starting date.

>(seconds)
1535272001

msec

Returns current time in milliseconds. The time is from an arbitrary starting date, and can wrap or be negative.

>(msec)
1535272001424

timedate [secs]

Converts time to string; default is current time. New in arc3.

>(timedate)
(41 26 8 26 8 2018)

>(timedate 0)
(0 0 0 1 1 1970)

current-gc-milliseconds

Returns the amount of time spent in garbage collection.

>(current-gc-milliseconds)
324

current-process-milliseconds

Returns the number of milliseconds of processor time used.

>(current-process-milliseconds)
6392

since t0

Displays the number of seconds since t0. The base time t0 should come from seconds.

>(let t0 (seconds) (sleep 1) (since t0))
1

minutes-since t0

Displays number of minutes since t0. New in arc3.

>(let t0 (seconds) (sleep 1) (minutes-since t0))
1/60

hours-since t0

Displays number of hours since t0.

>(let t0 (seconds) (sleep 1) (hours-since t0))
1/3600

days-since t0

Displays number of days since t0.

>(let t0 (seconds) (sleep 1) (days-since t0))
1/86400

datestring [secs]

Creates a date string from the current time or given seconds. New in arc3.

>(datestring)
"2018-08-26"

>(datestring 0)
"1970-01-01"

Timing

time expr

Executes expr and prints how long it took to execute.

>(time (sleep 0.1))
time: 101 msec.
nil

jtime expr

Executes expr, prints how long it took to execute, and returns the symbol ok.

>(jtime (sleep 0.1))
time: 100 msec.
ok

time10 expr

Executes expr 10 times and prints how long it took in total to execute.

>(time10 (sleep 0.1))
time: 1001 msec.
nil

Cache

cache timef valf

Returns a caching procedure. timef is a function that returns the cache lifetime in seconds. valf is a function that returns the value to be cached.

>(cache (fn () 5) (fn () "val"))
#<procedure: cache>

defcache name lasts [body ...]

Assigns a caching procedure to variable name. lasts is the cache lifetime in seconds. The body code returns the value to be cached. New in arc3.

>(defcache foo 300 "val")
#<procedure: cache>