From 21c6148861b6ad3f82245302cdadeaa043a20692 Mon Sep 17 00:00:00 2001 From: Jarrett Revels Date: Fri, 30 Sep 2016 16:36:22 -0400 Subject: [PATCH 1/3] enable picosecond timing resolution and backwards compatible serialization --- REQUIRE | 3 ++- doc/manual.md | 2 +- src/BenchmarkTools.jl | 9 ++++++++ src/execution.jl | 8 +++---- src/parameters.jl | 11 ++++----- src/serialization.jl | 53 +++++++++++++++++++++++++++++++++++++++++++ src/trials.jl | 8 +++---- test/TrialsTests.jl | 12 +++++----- 8 files changed, 83 insertions(+), 23 deletions(-) create mode 100644 src/serialization.jl diff --git a/REQUIRE b/REQUIRE index 2d1525cc..cce90081 100644 --- a/REQUIRE +++ b/REQUIRE @@ -1,2 +1,3 @@ julia 0.4 -Compat 0.7.20 +Compat 0.8.0 +JLD 0.6.4 diff --git a/doc/manual.md b/doc/manual.md index cd71a120..9308c6db 100644 --- a/doc/manual.md +++ b/doc/manual.md @@ -841,7 +841,7 @@ Caching parameters in this manner leads to a far shorter turnaround time, and mo # Miscellaneous tips and info -- Times reported by BenchmarkTools are limited to nanosecond resolution, though derived estimates might report fractions of nanoseconds. +- BenchmarkTools restricts the minimum measurable benchmark execution time to one picosecond. - If you use `rand` or something similar to generate the values that are used in your benchmarks, you should seed the RNG (or provide a seeded RNG) so that the values are consistent between trials/samples/evaluations. - BenchmarkTools attempts to be robust against machine noise occurring between *samples*, but BenchmarkTools can't do very much about machine noise occurring between *trials*. To cut down on the latter kind of noise, it is advised that you dedicate CPUs and memory to the benchmarking Julia process by using a shielding tool such as [cset](http://manpages.ubuntu.com/manpages/precise/man1/cset.1.html). - On some machines, for some versions of BLAS and Julia, the number of BLAS worker threads can exceed the number of available cores. This can occasionally result in scheduling issues and inconsistent performance for BLAS-heavy benchmarks. To fix this issue, you can use `BLAS.set_num_threads(i::Int)` in the Julia REPL to ensure that the number of BLAS threads is equal to or less than the number of available cores. diff --git a/src/BenchmarkTools.jl b/src/BenchmarkTools.jl index c4fef316..7fe9b701 100644 --- a/src/BenchmarkTools.jl +++ b/src/BenchmarkTools.jl @@ -1,12 +1,15 @@ module BenchmarkTools using Compat +import JLD # `show` compatibility for pre-JuliaLang/julia#16354 builds if VERSION < v"0.5.0-dev+4305" Base.get(io::IO, setting::Symbol, default::Bool) = default end +const BENCHMARKTOOLS_VERSION = v"0.0.6" + ############## # Parameters # ############## @@ -65,4 +68,10 @@ export tune!, loadplotting() = include(joinpath(dirname(@__FILE__), "plotting.jl")) +################# +# Serialization # +################# + +include("serialization.jl") + end # module BenchmarkTools diff --git a/src/execution.jl b/src/execution.jl index 13c83d1c..dd0f5d4e 100644 --- a/src/execution.jl +++ b/src/execution.jl @@ -46,7 +46,7 @@ end function _lineartrial(b::Benchmark, p::Parameters = b.params; maxevals = RESOLUTION, kwargs...) params = Parameters(p; kwargs...) - estimates = zeros(Int, maxevals) + estimates = zeros(maxevals) completed = 0 params.gctrial && gcscrub() start_time = time() @@ -117,7 +117,7 @@ end function tune!(b::Benchmark, p::Parameters = b.params; verbose::Bool = false, pad = "", kwargs...) warmup(b, false) - estimate = minimum(lineartrial(b, p; kwargs...)) + estimate = ceil(Int, minimum(lineartrial(b, p; kwargs...))) b.params.evals = guessevals(estimate) return b end @@ -256,8 +256,8 @@ function generate_benchmark_definition(eval_module, out_vars, setup_vars, __sample_time = time_ns() - __start_time __gcdiff = Base.GC_Diff(Base.gc_num(), __gc_start) $(teardown) - __time = max(Int(cld(__sample_time, __evals)) - __params.overhead, 1) - __gctime = max(Int(cld(__gcdiff.total_time, __evals)) - __params.overhead, 0) + __time = max((__sample_time / __evals) - __params.overhead, 0.001) + __gctime = max((__gcdiff.total_time / __evals) - __params.overhead, 0.0) __memory = Int(fld(__gcdiff.allocd, __evals)) __allocs = Int(fld(__gcdiff.malloc + __gcdiff.realloc + __gcdiff.poolalloc + __gcdiff.bigalloc, diff --git a/src/parameters.jl b/src/parameters.jl index 6ba04834..b304a6eb 100644 --- a/src/parameters.jl +++ b/src/parameters.jl @@ -9,7 +9,7 @@ type Parameters seconds::Float64 samples::Int evals::Int - overhead::Int + overhead::Float64 gctrial::Bool gcsample::Bool time_tolerance::Float64 @@ -80,16 +80,13 @@ end nullfunc() end sample_time = time_ns() - start_time - return Int(cld(sample_time, evals)) + return (sample_time / evals) end function estimate_overhead() - x = typemax(Int) + x = typemax(Float64) for _ in 1:10000 - y = overhead_sample(RESOLUTION) - if y < x - x = y - end + x = min(x, overhead_sample(RESOLUTION)) end return x end diff --git a/src/serialization.jl b/src/serialization.jl new file mode 100644 index 00000000..98e874bb --- /dev/null +++ b/src/serialization.jl @@ -0,0 +1,53 @@ +const VERSION_KEY = "__versions__" + +const VERSIONS = Dict("Julia" => string(VERSION), "BenchmarkTools" => string(BENCHMARKTOOLS_VERSION)) + +type ParametersPreV006 + seconds::Float64 + samples::Int + evals::Int + overhead::Int + gctrial::Bool + gcsample::Bool + time_tolerance::Float64 + memory_tolerance::Float64 +end + +type TrialPreV006 + params::Parameters + times::Vector{Int} + gctimes::Vector{Int} + memory::Int + allocs::Int +end + +function JLD.readas(p::ParametersPreV006) + return Parameters(p.seconds, p.samples, p.evals, Float64(p.overhead), p.gctrial, + p.gcsample, p.time_tolerance, p.memory_tolerance) +end + +function JLD.readas(t::TrialPreV006) + new_times = convert(Vector{Float64}, t.times) + new_gctimes = convert(Vector{Float64}, t.gctimes) + return Trial(t.params, new_times, new_gctimes, t.memory, t.allocs) +end + +function save(filename, args...) + JLD.save(filename, VERSION_KEY, VERSIONS, args...) + return nothing +end + +function load(filename, args...) + # no version-based rules are needed for now, we just need + # to check that version information exists in the file. + if JLD.jldopen(file -> JLD.exists(file, VERSION_KEY), filename, "r") + result = JLD.load(filename, args...) + else + JLD.translate("BenchmarkTools.Parameters", "BenchmarkTools.ParametersPreV006") + JLD.translate("BenchmarkTools.Trial", "BenchmarkTools.TrialPreV006") + result = JLD.load(filename, args...) + JLD.translate("BenchmarkTools.Parameters", "BenchmarkTools.Parameters") + JLD.translate("BenchmarkTools.Trial", "BenchmarkTools.Trial") + end + return result +end diff --git a/src/trials.jl b/src/trials.jl index 64ad5d7c..f83f2d70 100644 --- a/src/trials.jl +++ b/src/trials.jl @@ -4,13 +4,13 @@ type Trial params::Parameters - times::Vector{Int} - gctimes::Vector{Int} + times::Vector{Float64} + gctimes::Vector{Float64} memory::Int allocs::Int end -Trial(params::Parameters) = Trial(params, Int[], Int[], typemax(Int), typemax(Int)) +Trial(params::Parameters) = Trial(params, Float64[], Float64[], typemax(Int), typemax(Int)) @compat function Base.:(==)(a::Trial, b::Trial) return a.params == b.params && @@ -246,7 +246,7 @@ function prettytime(t) else value, units = t / 1e9, "s" end - return string(@sprintf("%.2f", value), " ", units) + return string(@sprintf("%.3f", value), " ", units) end function prettymemory(b) diff --git a/test/TrialsTests.jl b/test/TrialsTests.jl index 387f0b94..3c235dae 100644 --- a/test/TrialsTests.jl +++ b/test/TrialsTests.jl @@ -154,12 +154,12 @@ tj_r_2 = judge(tr; time_tolerance = 2.0, memory_tolerance = 2.0) @test BenchmarkTools.prettydiff(1.0) == "+0.00%" @test BenchmarkTools.prettydiff(2.0) == "+100.00%" -@test BenchmarkTools.prettytime(999) == "999.00 ns" -@test BenchmarkTools.prettytime(1000) == "1.00 μs" -@test BenchmarkTools.prettytime(999_999) == "1000.00 μs" -@test BenchmarkTools.prettytime(1_000_000) == "1.00 ms" -@test BenchmarkTools.prettytime(999_999_999) == "1000.00 ms" -@test BenchmarkTools.prettytime(1_000_000_000) == "1.00 s" +@test BenchmarkTools.prettytime(999) == "999.000 ns" +@test BenchmarkTools.prettytime(1000) == "1.000 μs" +@test BenchmarkTools.prettytime(999_999) == "999.999 μs" +@test BenchmarkTools.prettytime(1_000_000) == "1.000 ms" +@test BenchmarkTools.prettytime(999_999_999) == "1000.000 ms" +@test BenchmarkTools.prettytime(1_000_000_000) == "1.000 s" @test BenchmarkTools.prettymemory(1023) == "1023.00 bytes" @test BenchmarkTools.prettymemory(1024) == "1.00 kb" From 91ac865dca9d757ab30d4555dcc577c4f631e224 Mon Sep 17 00:00:00 2001 From: Jarrett Revels Date: Fri, 30 Sep 2016 17:20:18 -0400 Subject: [PATCH 2/3] add tests --- benchmark/benchmarks.jl | 10 +++++----- benchmark/params.jld | Bin 26808 -> 25943 bytes src/serialization.jl | 2 +- test/SerializationTests.jl | 14 ++++++++++++++ test/data_pre_v006.jld | Bin 0 -> 1155653 bytes test/runtests.jl | 4 ++++ 6 files changed, 24 insertions(+), 6 deletions(-) create mode 100644 test/SerializationTests.jl create mode 100644 test/data_pre_v006.jld diff --git a/benchmark/benchmarks.jl b/benchmark/benchmarks.jl index db4e303d..7964058a 100644 --- a/benchmark/benchmarks.jl +++ b/benchmark/benchmarks.jl @@ -5,15 +5,15 @@ using JLD const suite = BenchmarkGroup() # Add some child groups to our benchmark suite. -suite["utf8"] = BenchmarkGroup(["string", "unicode"]) +suite["string"] = BenchmarkGroup(["unicode"]) suite["trigonometry"] = BenchmarkGroup(["math", "triangles"]) # This string will be the same every time because we're seeding the RNG -teststr = UTF8String(join(rand(MersenneTwister(1), 'a':'d', 10^4))) +teststr = join(rand(MersenneTwister(1), 'a':'d', 10^4)) # Add some benchmarks to the "utf8" group -suite["utf8"]["replace"] = @benchmarkable replace($teststr, "a", "b") -suite["utf8"]["join"] = @benchmarkable join($teststr, $teststr) +suite["string"]["replace"] = @benchmarkable replace($teststr, "a", "b") +suite["string"]["join"] = @benchmarkable join($teststr, $teststr) # Add some benchmarks to the "trigonometry" group for f in (sin, cos, tan) @@ -25,5 +25,5 @@ end # Load the suite's cached parameters as part of including the file. This is much # faster and more reliable than re-tuning `suite` every time the file is included paramspath = joinpath(Pkg.dir("BenchmarkTools"), "benchmark", "params.jld") -#tune!(suite); JLD.save(paramspath, "suite", params(suite)); +# tune!(suite); JLD.save(paramspath, "suite", params(suite)); loadparams!(suite, JLD.load(paramspath, "suite"), :evals, :samples); diff --git a/benchmark/params.jld b/benchmark/params.jld index 5e0c9fa8827759597555f92310b0024670ea211b..3ff5b554bc175cddc8def9d6ab5e5903a9cae2bf 100644 GIT binary patch literal 25943 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 P{i5FxTYn?$SA6~t(Yr3b diff --git a/src/serialization.jl b/src/serialization.jl index 98e874bb..85c53d99 100644 --- a/src/serialization.jl +++ b/src/serialization.jl @@ -37,7 +37,7 @@ function save(filename, args...) return nothing end -function load(filename, args...) +@inline function load(filename, args...) # no version-based rules are needed for now, we just need # to check that version information exists in the file. if JLD.jldopen(file -> JLD.exists(file, VERSION_KEY), filename, "r") diff --git a/test/SerializationTests.jl b/test/SerializationTests.jl new file mode 100644 index 00000000..db70a931 --- /dev/null +++ b/test/SerializationTests.jl @@ -0,0 +1,14 @@ +module SerializationTests + +using Base.Test +using BenchmarkTools + +old_data = BenchmarkTools.load(joinpath(dirname(@__FILE__), "data_pre_v006.jld"), "results") +BenchmarkTools.save(joinpath(dirname(@__FILE__), "tmp.jld"), "results", old_data) +new_data = BenchmarkTools.load(joinpath(dirname(@__FILE__), "tmp.jld"), "results") + +@test old_data == new_data + +rm(joinpath(dirname(@__FILE__), "tmp.jld")) + +end # module diff --git a/test/data_pre_v006.jld b/test/data_pre_v006.jld new file mode 100644 index 0000000000000000000000000000000000000000..cf126f9b3f02ff640a622fad405d3f903997391d GIT binary patch literal 1155653 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 Date: Tue, 4 Oct 2016 17:20:31 -0600 Subject: [PATCH 3/3] leave serialization compat fix in source tree, but comment out inclusion in module --- src/BenchmarkTools.jl | 8 +++++++- test/runtests.jl | 8 +++++--- 2 files changed, 12 insertions(+), 4 deletions(-) diff --git a/src/BenchmarkTools.jl b/src/BenchmarkTools.jl index 7fe9b701..48c48cfe 100644 --- a/src/BenchmarkTools.jl +++ b/src/BenchmarkTools.jl @@ -72,6 +72,12 @@ loadplotting() = include(joinpath(dirname(@__FILE__), "plotting.jl")) # Serialization # ################# -include("serialization.jl") +# Adds a compatibility fix for deserializing JLD files written with older versions of +# BenchmarkTools. Unfortunately, this use of JLD.translate encounters a weird scoping bug +# (see JuliaCI/BenchmarkTools.jl#23.). Even though it's currently unused, I've decided to +# leave this code in the source tree for the time being, with the hope that a fix for +# the scoping bug is pushed sometime soon. + +# include("serialization.jl") end # module BenchmarkTools diff --git a/test/runtests.jl b/test/runtests.jl index a8e74988..2c6b2836 100644 --- a/test/runtests.jl +++ b/test/runtests.jl @@ -14,6 +14,8 @@ print("Testing execution..."); tic() include("ExecutionTests.jl") println("done (took ", toq(), " seconds)") -print("Testing serialization..."); tic() -include("SerializationTests.jl") -println("done (took ", toq(), " seconds)") +# This test fails due to a weird JLD scoping error. See JuliaCI/BenchmarkTools.jl#23. +# +# print("Testing serialization..."); tic() +# include("SerializationTests.jl") +# println("done (took ", toq(), " seconds)")