refactor for multiple timers

cormullion · cormullion · commit 532aa1bae4a9 · 2018-03-17T12:33:23.000Z
diff --git a/README.md b/README.md
@@ -3,68 +3,78 @@
 ![tick tock](images/ticktock.gif)
 
 
-| **PackageEvaluator**                                                                            | **Build Status**                                                                |
-|:-------------------------------------------------------------------------------:|:-----------------------------------------------------------------------------------------------:|
+| **PackageEvaluator** | **Build Status**  |
+|:---:|:---:|
 |[![][pkg-0.6-img]][pkg-0.6-url] [![][pkg-0.7-img]][pkg-0.7-url] | [![][travis-img]][travis-url] [![][appveyor-img]][appveyor-url] [![][codecov-img]][codecov-url] |
 
-
-
-This module provides `tick()`, `tock()`, and `tok()` functions. They're similar to the `tic()`, `toc()`, and `toq()` functions that you might find in MATLAB and similar software. There are also `lap()` and `peek()` functions that reveal the state of the current timer without stopping it.
+This module provides `tick()`, `tock()`, and `tok()` functions. They're similar to the `tic()`, `toc()`, and `toq()` functions that you might find in MATLAB and similar software. There are also `laptime()` and `peektime()` functions that reveal the state of the current timers without stopping them.
 
 **Don't use these for timing code execution!** Julia provides much better facilities for measuring performance, ranging from the `@time` and `@elapsed` macros to packages such as [BenchmarkTools.jl](https://github.com/JuliaCI/BenchmarkTools.jl). (And remember, don't time Julia code running in global scope!) The [TimerOutputs.jl](https://github.com/KristofferC/TimerOutputs.jl) package provides tools for timing different sections of a program.
 
 ## Functions
 
-- `tick()` start counting
-- `tock()` stop counting, show total elapsed time
-- `tok()`  stop counting, return seconds
-- `peek()` continue counting, return elapsed seconds
-- `lap()`  continue counting, show total elapsed time
+- `tick()     ` start timing
+- `tock()     ` stop timing, show total elapsed time
+- `tok()      ` stop timing, return elapsed seconds
+- `peektime() ` continue timing, return elapsed seconds
+- `laptimer()  ` continue timing, show total elapsed time
 
 ## Suggestions for use
 
 You can:
 
 - time how long a phone call takes without leaving the Julia REPL
 
-```
+```julia
 julia-0.6> using TickTock
 julia-0.6> tick()
-Started timer: 2017-12-13T22:30:59.632.
+ Started timer at 2017-12-13T22:30:59.632
 julia-0.6> tock()
 55.052638936 ms: 55 seconds, 52 milliseconds
 ```
 
 - see how long your cup of tea's been brewing:
 
-```
+```julia
 julia-0.6> tick()
-Started timer: 2017-12-13T22:34:03.78.
-julia-0.6> lap()
-72.625839832 ms: 1 minute, 12 seconds, 625 milliseconds
-julia-0.6> lap()
-266.053953749 ms: 4 minutes, 26 seconds, 53 milliseconds
-julia-0.6> lap()
-285.314459174 ms: 4 minutes, 45 seconds, 314 milliseconds
+ Started timer at 2017-12-13T22:34:03.78
+julia-0.6> laptimer()
+ 72.625839832 ms: 1 minute, 12 seconds, 625 milliseconds
+julia-0.6> laptimer()
+ 266.053953749 ms: 4 minutes, 26 seconds, 53 milliseconds
+julia-0.6> laptimer()
+ 285.314459174 ms: 4 minutes, 45 seconds, 314 milliseconds
 ```
 
 - see how many seconds you held your breath for:
 
-```
+```julia
 julia-0.6> tick()
-Started timer at 2017-12-12T09:17:45.504.
+ Started timer at 2017-12-12T09:17:45.504
 
 julia-0.6> tok()
 287.841546621
 ```
 
 - see how long your computer (and Julia session) has been running for:
 
-```
+```julia
 julia-0.6> tick()
-...
-julia-0.6> lap()
-1.302200135485876e6s: (2 weeks, 1 day, 1 hour, 43 minutes, 20 seconds, 135 milliseconds)
+...go on holiday, then come back
+julia-0.6> laptimer()
+  1.302200135485876e6s: 2 weeks, 1 day, 1 hour, 43 minutes, 20 seconds, 135 milliseconds
+```
+
+- time a number of things:
+
+```julia
+julia-0.7> tick()
+ started timer at: 2018-03-17T12:08:43.326
+julia-0.7> tick()
+ started timer at: 2018-03-17T12:14:03.077
+julia-0.7> laptimer()
+2                  7.315769543s: 7 seconds, 315 milliseconds
+1                327.074715234s: 5 minutes, 27 seconds, 74 milliseconds
 ```
 
 You should *not* use this package to:
@@ -78,7 +88,6 @@ You should *not* use this package to:
 Some of this code used to live in Julia Base in the `tic()`, `toc()`, and `toq()` functions
 (in base/util.jl). They were deprecated in GitHub issue [17046](https://github.com/JuliaLang/julia/issues/17046).
 
-
 [travis-img]: https://travis-ci.org/cormullion/TickTock.jl.svg?branch=master
 [travis-url]: https://travis-ci.org/cormullion/TickTock.jl
 
diff --git a/src/TickTock.jl b/src/TickTock.jl
@@ -12,10 +12,9 @@ time Julia code running in global scope!)
 This code used to live in Julia Base as the `tic()`, `toc()`, and `toq()` functions
 (in base/util.jl). They were deprecated in GitHub issue [17046](https://github.com/JuliaLang/julia/issues/17046).
 """
-
 module TickTock
 
-export tick, tock, tok, peek, lap
+export tick, tock, tok, peektimer, laptimer
 
 if VERSION > v"0.7.0-"
     using Dates # for now() :(
@@ -26,27 +25,48 @@ end
 
 Start counting. The other functions are:
 
-- `tock()` stop counting, show total elapsed time in canonical form
-- `tok()`  stop counting, return seconds
-- `peek()` continue counting, return elapsed seconds
-- `lap()`  continue counting, show total elapsed time in canonical form
+- `tock()`       ` stop counting, show total elapsed time in canonical form
+- `tok()`        ` stop counting, return seconds
+- `peektimer()   ` continue counting, return elapsed seconds
+- `laptimer()    ` continue counting, show total elapsed time in canonical form
 """
 function tick()
     t0 = time_ns()
     task_local_storage(:TIMERS, (t0, get(task_local_storage(), :TIMERS, ())))
-    println("Started timer: $(now()).")
+    println(" started timer at: $(now())")
+end
+
+function printcanonical(tnow)
+    canondc = Dates.canonicalize(
+        Dates.CompoundPeriod(Dates.Second(floor(tnow)),
+        Dates.Millisecond(floor( (tnow - floor(tnow)) * 1000))))
+    println("$(lpad(tnow, 20))s: $canondc")
+end
+
+function gettimers()
+    result = UInt64[]
+    timers = get(task_local_storage(), :TIMERS, ())
+    if timers === ()
+        error("Use `tick()` to start a timer.")
+    end
+    while timers[2] != ()
+        push!(result, timers[1]::UInt64)
+        timers = timers[2]
+    end
+    push!(result, timers[1]::UInt64)
+    return result
 end
 
 """
-    peek()
+    peektimer()
 
-Return the current elapsed seconds counted by the current timer, without stopping it.
+Return the current elapsed seconds counted by the most recent timer, without stopping it.
 """
-function peek()
+function peektimer()
     t1 = time_ns()
     timers = get(task_local_storage(), :TIMERS, ())
     if timers === ()
-        error("You must first use `tick()`.")
+        error("Use `tick()` to start a timer.")
     end
     t0 = timers[1]::UInt64
     return (t1 - t0)/1e9
@@ -55,44 +75,49 @@ end
 """
     tok()
 
-Return the seconds since the previous `tick()` then stop counting.
+Return the current elapsed seconds counted by the most recent timer, then stop counting.
 """
 function tok()
     timers = get(task_local_storage(), :TIMERS, ())
     if timers === ()
-        error("You must first use `tick()`.")
+        error("Use `tick()` to start a timer.")
     end
-    t = peek()
+    t = peektimer()
     task_local_storage(:TIMERS, timers[2])
     return t
 end
 
 """
     tock()
 
-Print the elapsed time, in canonical form, since the previous `tick()`,
-then stop counting.
+Print the elapsed time, in canonical form, of the most recent timer, then stop counting.
 """
 function tock()
     t = tok()
-    canondc = Dates.canonicalize(
-        Dates.CompoundPeriod(Dates.Second(floor(t)),
-        Dates.Millisecond(floor( (t - floor(t)) * 1000))))
-    println("$(t)s: ($canondc)")
+    printcanonical(t)
+end
+
+function showtimes(;canonical=true)
+    t1 = time_ns()
+    timers = gettimers()
+    if timers === ()
+        error("Use `tick()` to start a timer.")
+    end
+    timernumber = length(timers)
+    for t0 in timers
+        tnow = (t1 - t0)/1e9
+        print(rpad(timernumber, 10))
+        canonical ? printcanonical(tnow) : println(tnow)
+        timernumber -= 1
+    end
 end
 
 """
-    lap()
+laptimer()
 
 Print the current elapsed time, in canonical form, since the previous `tick()`,
 and continue counting.
 """
-function lap()
-    t = peek()
-    canondc = Dates.canonicalize(
-        Dates.CompoundPeriod(Dates.Second(floor(t)),
-        Dates.Millisecond(floor( (t - floor(t)) * 1000))))
-    println("$(t)s: ($canondc)")
-end
+laptimer() = showtimes(canonical=true)
 
 end # module
diff --git a/test/runtests.jl b/test/runtests.jl
@@ -1,36 +1,73 @@
-using TickTock
-
 if VERSION > v"0.7.0-"
+    using Pkg
     using Test
 else
     using Base.Test
 end
 
+using TickTock
+
 tick()
 
 sleep(1)
 
-@test typeof(peek()) == Float64
+@test typeof(peektimer()) == Float64
 
 if VERSION > v"0.7.0-"
-    @test sprint(showcompact, lap()) == "nothing"
+    @test sprint(show, laptimer(), context=:compact => true) == "nothing"
 else
-    @test typeof(lap()) == Void
+    @test typeof(laptimer()) == Void
 end
 
-
 @test tok() > 1.0
 
 tick()
 
 if VERSION > v"0.7.0-"
-    @test sprint(showcompact, tock()) == "nothing"
+    @test sprint(show, tock(), context=:compact => true) == "nothing"
 else
     @test typeof(tock()) == Void
 end
 
-# with no current timer, these should error
+println("Make 10 timers")
+
+for i in 1:10
+    tick()
+    sleep(1)
+end
+
+@test length(TickTock.gettimers()) == 10
+
+println("Check that there are 10 timers")
+
+println("wait a second")
+
+sleep(1)
+
+println("Print all the timers")
+
+laptimer()
+
+
+for i in 1:10
+    peektimer()
+end
+
+println("Check that the most recent timer is more than 1 second")
+
+println(peektimer())
+
+@test peektimer() > 1.0
+
+println("Finish 10 timers and show canonical")
+
+for i in 1:10
+    tock()
+end
+
+# now, with no current timers, these should all error
 
-@test_throws ErrorException peek()
-@test_throws ErrorException lap()
+@test_throws ErrorException TickTock.gettimers()
+@test_throws ErrorException peektimer()
+@test_throws ErrorException laptimer()
 @test_throws ErrorException tok()
