Updates for 0.7/1.0 (#114)

Also remove `showall`, which was removed from Base, as well as the dependency on Compat

Author: ararslan

.travis.yml

@@ -4,13 +4,20 @@ os:
   - linux
   - osx
 julia:
-  - 0.6
   - 0.7
+  - 1.0
   - nightly
 notifications:
   email: false
-script:
-    - if [[ -a .git/shallow ]]; then git fetch --unshallow; fi
-    - julia -e 'Pkg.clone(pwd()); Pkg.build("BenchmarkTools"); Pkg.test("BenchmarkTools"; coverage=true)'
+#script:
+#    - if [[ -a .git/shallow ]]; then git fetch --unshallow; fi
+#    - julia -e 'Pkg.clone(pwd()); Pkg.build("BenchmarkTools"); Pkg.test("BenchmarkTools"; coverage=true)'
 after_success:
-    - julia -e 'cd(Pkg.dir("BenchmarkTools")); Pkg.add("Coverage"); using Coverage; Coveralls.submit(Coveralls.process_folder())'
+    - |
+        julia -e '
+          import BenchmarkTools, Pkg
+          Pkg.add("Coverage")
+          using Coverage
+          cd(normpath(dirname(pathof(BenchmarkTools)), ".."))
+          Coveralls.submit(Coveralls.process_folder())
+        '

README.md

@@ -34,7 +34,7 @@ If you're benchmarking on Linux, I wrote up a series of [tips and tricks](https:
 The simplest usage is via the [`@btime` macro](https://github.com/JuliaCI/BenchmarkTools.jl/blob/master/doc/manual.md#benchmarking-basics), which is analogous to Julia's built-in [`@time` macro](https://docs.julialang.org/en/stable/stdlib/base/#Base.@time) but is often more accurate (by collecting results over multiple runs):
 
 ```julia
-julia> using BenchmarkTools, Compat   # you need to use both modules
+julia> using BenchmarkTools
 
 julia> @btime sin(1)
   15.081 ns (0 allocations: 0 bytes)

REQUIRE

@@ -1,3 +1,2 @@
-julia 0.6
-Compat 0.62.0
+julia 0.7
 JSON

appveyor.yml

@@ -1,9 +1,18 @@
 environment:
   matrix:
-  - JULIA_URL: "https://julialang-s3.julialang.org/bin/winnt/x86/0.6/julia-0.6-latest-win32.exe"
-  - JULIA_URL: "https://julialang-s3.julialang.org/bin/winnt/x64/0.6/julia-0.6-latest-win64.exe"
-  - JULIA_URL: "https://julialangnightlies-s3.julialang.org/bin/winnt/x86/julia-latest-win32.exe"
-  - JULIA_URL: "https://julialangnightlies-s3.julialang.org/bin/winnt/x64/julia-latest-win64.exe"
+  - julia_version: 0.7
+  - julia_version: 1.0
+  - julia_version: latest
+
+platform:
+  - x86 # 32-bit
+  - x64 # 64-bit
+
+# # Uncomment the following lines to allow failures on nightly julia
+# # (tests will run but not make your overall status red)
+# matrix:
+#   allow_failures:
+#   - julia_version: latest
 
 branches:
   only:
@@ -17,19 +26,18 @@ notifications:
     on_build_status_changed: false
 
 install:
-  - ps: "[System.Net.ServicePointManager]::SecurityProtocol = [System.Net.SecurityProtocolType]::Tls12"
-# Download most recent Julia Windows binary
-  - ps: (new-object net.webclient).DownloadFile(
-        $env:JULIA_URL,
-        "C:\projects\julia-binary.exe")
-# Run installer silently, output to C:\projects\julia
-  - C:\projects\julia-binary.exe /S /D=C:\projects\julia
+  - ps: iex ((new-object net.webclient).DownloadString("https://raw.githubusercontent.com/JuliaCI/Appveyor.jl/version-1/bin/install.ps1"))
 
 build_script:
-# Need to convert from shallow to complete for Pkg.clone to work
-  - IF EXIST .git\shallow (git fetch --unshallow)
-  - C:\projects\julia\bin\julia -e "versioninfo();
-      Pkg.clone(pwd(), \"BenchmarkTools\"); Pkg.build(\"BenchmarkTools\")"
+  - echo "%JL_BUILD_SCRIPT%"
+  - C:\julia\bin\julia -e "%JL_BUILD_SCRIPT%"
 
 test_script:
-  - C:\projects\julia\bin\julia --check-bounds=yes -e "Pkg.test(\"BenchmarkTools\")"
+  - echo "%JL_TEST_SCRIPT%"
+  - C:\julia\bin\julia -e "%JL_TEST_SCRIPT%"
+
+# # Uncomment to support code coverage upload. Should only be enabled for packages
+# # which would have coverage gaps without running on Windows
+# on_success:
+#   - echo "%JL_CODECOV_SCRIPT%"
+#   - C:\julia\bin\julia -e "%JL_CODECOV_SCRIPT%"

doc/manual.md

@@ -526,7 +526,7 @@ end
 Let's look at our newly defined suite in the REPL:
 
 ```julia
-julia> showall(suite)
+julia> suite
 2-element BenchmarkTools.BenchmarkGroup:
   tags: []
   "utf8" => 2-element BenchmarkTools.BenchmarkGroup:
@@ -640,7 +640,7 @@ julia> g = BenchmarkGroup([], # no tags in the parent
                           "a" => BenchmarkGroup(["1", "2", "3"],  # contains tags and child groups
                                                 "d" => BenchmarkGroup(["8"], 1 => 1),
                                                 "e" => BenchmarkGroup(["9"], 2 => 2)));
-julia> showall(g)
+julia> g
 BenchmarkTools.BenchmarkGroup:
   tags: []
   "c" => BenchmarkTools.BenchmarkGroup:
@@ -678,7 +678,7 @@ To demonstrate the last two points:
 
 ```julia
 # also could've used `@tagged "1"`, `@tagged "a"`, `@tagged "e" || "d"`
-julia> showall(g[@tagged "8" || "9"])
+julia> g[@tagged "8" || "9"]
 BenchmarkTools.BenchmarkGroup:
   tags: []
   "a" => BenchmarkTools.BenchmarkGroup:
@@ -690,7 +690,7 @@ BenchmarkTools.BenchmarkGroup:
 		  tags: ["8"]
 		  1 => 1
 
-julia> showall(g[@tagged "d"])
+julia> g[@tagged "d"]
 BenchmarkTools.BenchmarkGroup:
     tags: []
     "a" => BenchmarkTools.BenchmarkGroup:
@@ -699,7 +699,7 @@ BenchmarkTools.BenchmarkGroup:
 		  tags: ["8"]
 		  1 => 1
 
-julia> showall(g[@tagged "9"])
+julia> g[@tagged "9"]
 BenchmarkTools.BenchmarkGroup:
   tags: []
   "a" => BenchmarkTools.BenchmarkGroup:
@@ -714,7 +714,7 @@ BenchmarkTools.BenchmarkGroup:
 It's sometimes useful to create `BenchmarkGroup` where the keys are drawn from one `BenchmarkGroup`, but the values are drawn from another. You can accomplish this by indexing into the latter `BenchmarkGroup` with the former:
 
 ```julia
-julia> showall(g) # leaf values are integers
+julia> g # leaf values are integers
 BenchmarkTools.BenchmarkGroup:
   tags: []
   "c" => BenchmarkTools.BenchmarkGroup:
@@ -738,7 +738,7 @@ BenchmarkTools.BenchmarkGroup:
 	  "2" => 2
 	  "3" => 3
 
-julia> showall(x) # note that leaf values are characters
+julia> x # note that leaf values are characters
 BenchmarkTools.BenchmarkGroup:
   tags: []
   "c" => BenchmarkTools.BenchmarkGroup:
@@ -754,7 +754,7 @@ BenchmarkTools.BenchmarkGroup:
 	  "2" => '2'
 	  "3" => '3'
 
-julia> showall(g[x]) # index into `g` with the keys of `x`
+julia> g[x] # index into `g` with the keys of `x`
 BenchmarkTools.BenchmarkGroup:
   tags: []
   "c" => BenchmarkTools.BenchmarkGroup:
@@ -788,7 +788,7 @@ To solve this problem, BenchmarkTools allows you to uniquely index group nodes u
 ```julia
 julia> g = BenchmarkGroup([], 1 => BenchmarkGroup([], "a" => BenchmarkGroup([], :b => 1234)));
 
-julia> showall(g)
+julia> g
 BenchmarkTools.BenchmarkGroup:
   tags: []
   1 => BenchmarkTools.BenchmarkGroup:
@@ -797,17 +797,17 @@ BenchmarkTools.BenchmarkGroup:
 		  tags: []
 		  :b => 1234
 
-julia> showall(g[[1]]) # == g[1]
+julia> g[[1]] # == g[1]
 BenchmarkTools.BenchmarkGroup:
   tags: []
   "a" => BenchmarkTools.BenchmarkGroup:
 	  tags: []
 	  :b => 1234
-julia> showall(g[[1, "a"]]) # == g[1]["a"]
+julia> g[[1, "a"]] # == g[1]["a"]
 BenchmarkTools.BenchmarkGroup:
   tags: []
   :b => 1234
-julia> showall(g[[1, "a", :b]]) # == g[1]["a"][:b]
+julia> g[[1, "a", :b]] # == g[1]["a"][:b]
 1234
 ```
 
@@ -817,7 +817,7 @@ Keep in mind that this indexing scheme also works with `setindex!`:
 julia> g[[1, "a", :b]] = "hello"
 "hello"
 
-julia> showall(g)
+julia> g
 BenchmarkTools.BenchmarkGroup:
   tags: []
   1 => BenchmarkTools.BenchmarkGroup:
@@ -833,7 +833,7 @@ Assigning into a `BenchmarkGroup` with a `Vector` creates sub-groups as necessar
 julia>  g[[2, "a", :b]] = "hello again"
 "hello again"
 
-julia>  showall(g)
+julia> g
 2-element BenchmarkTools.BenchmarkGroup:
   tags: []
   2 => 1-element BenchmarkTools.BenchmarkGroup:

src/BenchmarkTools.jl

@@ -1,18 +1,10 @@
-__precompile__()
-
 module BenchmarkTools
 
-using Compat
 using JSON
 using Base.Iterators
 
-if VERSION >= v"0.7.0-beta.85"
-    import Statistics: mean, median
-else
-    import Base: mean, median
-end
-
-using Compat.Printf
+using Statistics
+using Printf
 
 
 const BENCHMARKTOOLS_VERSION = v"0.2.2"

src/execution.jl

@@ -1,11 +1,7 @@
 # Trigger several successive GC sweeps. This is more comprehensive than running just a
 # single sweep, since freeable objects may need more than one sweep to be appropriately
 # marked and freed.
-if VERSION >= v"0.7.0-DEV.3469"
-    gcscrub() = (GC.gc(); GC.gc(); GC.gc(); GC.gc())
-else
-    gcscrub() = (gc(); gc(); gc(); gc())
-end
+gcscrub() = (GC.gc(); GC.gc(); GC.gc(); GC.gc())
 
 #############
 # Benchmark #
@@ -33,25 +29,8 @@ end
 # compatiblity hacks #
 ######################
 
-if VERSION >= v"0.7.0-DEV.1139"
-    run_result(b::Benchmark, p::Parameters = b.params; kwargs...) = Base.invokelatest(_run, b, p; kwargs...)
-    lineartrial(b::Benchmark, p::Parameters = b.params; kwargs...) = Base.invokelatest(_lineartrial, b, p; kwargs...)
-elseif VERSION < v"0.7.0-DEV.484"
-    # `invokelatest` on v0.6 doesn't take keyword arguments, so we fall back
-    # to the `current_module` approach if we're on a Julia version where that's
-    # still possible.
-    function run_result(b::Benchmark, p::Parameters = b.params; kwargs...)
-        return Core.eval(@__MODULE__, :(BenchmarkTools._run($(b), $(p); $(kwargs...))))
-    end
-    function lineartrial(b::Benchmark, p::Parameters = b.params; kwargs...)
-        return Core.eval(@__MODULE__, :(BenchmarkTools._lineartrial($(b), $(p); $(kwargs...))))
-    end
-else
-    # There's a commit gap between `current_module` deprecation and `invokelatest` keyword
-    # argument support.  I could try to hack something together just for that gap, but it's
-    # probably not worth it.
-    error("Congratulations, you've found the obscure range of Julia v0.7-dev commits where BenchmarkTools is really, really broken. Sorry about that :(")
-end
+run_result(b::Benchmark, p::Parameters = b.params; kwargs...) = Base.invokelatest(_run, b, p; kwargs...)
+lineartrial(b::Benchmark, p::Parameters = b.params; kwargs...) = Base.invokelatest(_lineartrial, b, p; kwargs...)
 
 #############
 # execution #
@@ -274,11 +253,9 @@ macro benchmarkable(args...)
     core_vars = isa(core, Expr) ? collectvars(core) : []
     out_vars = filter(var -> var in setup_vars, core_vars)
 
-    eval_module = VERSION >= v"0.7.0-DEV.484" ? __module__ : current_module()
-
     # generate the benchmark definition
     return esc(quote
-        $BenchmarkTools.generate_benchmark_definition($(eval_module),
+        $BenchmarkTools.generate_benchmark_definition($__module__,
                                                       $(Expr(:quote, out_vars)),
                                                       $(Expr(:quote, setup_vars)),
                                                       $(Expr(:quote, core)),

src/groups.jl

@@ -19,10 +19,6 @@ end
 # Dict-like methods #
 #-------------------#
 
-if VERSION < v"0.7.0-DEV.2731"
-    const empty = similar
-end
-
 Base.:(==)(a::BenchmarkGroup, b::BenchmarkGroup) = a.tags == b.tags && a.data == b.data
 Base.copy(group::BenchmarkGroup) = BenchmarkGroup(copy(group.tags), copy(group.data))
 Base.similar(group::BenchmarkGroup) = BenchmarkGroup(copy(group.tags), empty(group.data))
@@ -34,9 +30,7 @@ Base.delete!(group::BenchmarkGroup, k...) = delete!(group.data, k...)
 Base.haskey(group::BenchmarkGroup, k) = haskey(group.data, k)
 Base.keys(group::BenchmarkGroup) = keys(group.data)
 Base.values(group::BenchmarkGroup) = values(group.data)
-Base.start(group::BenchmarkGroup) = start(group.data)
-Base.next(group::BenchmarkGroup, state) = next(group.data, state)
-Base.done(group::BenchmarkGroup, state) = done(group.data, state)
+Base.iterate(group::BenchmarkGroup, i=1) = iterate(group.data, i)
 
 # mapping/filtering #
 #-------------------#
@@ -60,12 +54,7 @@ end
 mapvals!(f, group::BenchmarkGroup) = mapvals!(f, similar(group), group)
 mapvals(f, groups::BenchmarkGroup...) = mapvals!(f, similar(first(groups)), groups...)
 
-if VERSION >= v"0.7.0-DEV.1393"
-    filtervals!(f, group::BenchmarkGroup) = (filter!(kv -> f(kv[2]), group.data); return group)
-else
-    filtervals!(f, group::BenchmarkGroup) = (filter!((k, v) -> f(v), group.data); return group)
-end
-
+filtervals!(f, group::BenchmarkGroup) = (filter!(kv -> f(kv[2]), group.data); return group)
 filtervals(f, group::BenchmarkGroup) = filtervals!(f, copy(group))
 
 Base.filter!(f, group::BenchmarkGroup) = (filter!(f, group.data); return group)
@@ -76,8 +65,8 @@ Base.filter(f, group::BenchmarkGroup) = filter!(f, copy(group))
 
 Base.minimum(group::BenchmarkGroup) = mapvals(minimum, group)
 Base.maximum(group::BenchmarkGroup) = mapvals(maximum, group)
-mean(group::BenchmarkGroup) = mapvals(mean, group)
-median(group::BenchmarkGroup) = mapvals(median, group)
+Statistics.mean(group::BenchmarkGroup) = mapvals(mean, group)
+Statistics.median(group::BenchmarkGroup) = mapvals(median, group)
 Base.min(groups::BenchmarkGroup...) = mapvals(min, groups...)
 Base.max(groups::BenchmarkGroup...) = mapvals(max, groups...)
 
@@ -259,8 +248,6 @@ Base.setindex!(group::BenchmarkGroup, v, k::BenchmarkGroup) = error("A Benchmark
 
 tagrepr(tags) = string("[", join(map(repr, tags), ", "), "]")
 
-Base.showall(io::IO, group::BenchmarkGroup) = show(io, MIME"text/plain"(), group; verbose = true, limit = Inf)
-
 Base.show(io::IO, group::BenchmarkGroup) = print(io, "$(length(group))-element BenchmarkGroup($(tagrepr(group.tags)))")
 
 function Base.show(io::IO, mime::MIME"text/plain", group::BenchmarkGroup, pad = ""; verbose = false, limit = 10)

src/serialization.jl

@@ -1,5 +1,3 @@
-using Base.Meta: parse
-
 const VERSIONS = Dict("Julia" => string(VERSION),
                       "BenchmarkTools" => string(BENCHMARKTOOLS_VERSION))
 
@@ -24,7 +22,7 @@ function recover(x::Vector)
     length(x) == 2 || throw(ArgumentError("Expecting a vector of length 2"))
     typename = x[1]::String
     fields = x[2]::Dict
-    T = Core.eval(@__MODULE__, parse(typename))::Type
+    T = Core.eval(@__MODULE__, Meta.parse(typename))::Type
     fc = fieldcount(T)
     xs = Vector{Any}(undef, fc)
     for i = 1:fc
@@ -71,9 +69,9 @@ function save(io::IO, args...)
     goodargs = Any[]
     for arg in args
         if arg isa String
-            Compat.@warn("Naming variables in serialization is no longer supported.\n" *
-                         "The name will be ignored and the object will be serialized " *
-                         "in the order it appears in the input.")
+            @warn("Naming variables in serialization is no longer supported.\n" *
+                  "The name will be ignored and the object will be serialized " *
+                  "in the order it appears in the input.")
             continue
         elseif !any(T->arg isa T, SUPPORTED_TYPES)
             throw(ArgumentError("Only BenchmarkTools types can be serialized."))

src/trials.jl

@@ -39,7 +39,7 @@ end
 Base.length(t::Trial) = length(t.times)
 Base.getindex(t::Trial, i::Number) = push!(Trial(t.params), t.times[i], t.gctimes[i], t.memory, t.allocs)
 Base.getindex(t::Trial, i) = Trial(t.params, t.times[i], t.gctimes[i], t.memory, t.allocs)
-Compat.lastindex(t::Trial) = length(t)
+Base.lastindex(t::Trial) = length(t)
 
 function Base.sort!(t::Trial)
     inds = sortperm(t.times)
@@ -118,8 +118,8 @@ function Base.maximum(trial::Trial)
     return TrialEstimate(trial, trial.times[i], trial.gctimes[i])
 end
 
-median(trial::Trial) = TrialEstimate(trial, median(trial.times), median(trial.gctimes))
-mean(trial::Trial) = TrialEstimate(trial, mean(trial.times), mean(trial.gctimes))
+Statistics.median(trial::Trial) = TrialEstimate(trial, median(trial.times), median(trial.gctimes))
+Statistics.mean(trial::Trial) = TrialEstimate(trial, mean(trial.times), mean(trial.gctimes))
 
 Base.isless(a::TrialEstimate, b::TrialEstimate) = isless(time(a), time(b))