From 57e9e3c404f6607f2a5d5b1ce5a7257fbae5104f Mon Sep 17 00:00:00 2001 From: kalmarek Date: Mon, 20 Aug 2018 02:54:50 +0200 Subject: [PATCH] use external logging --- logging.jl | 58 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ main.jl | 50 +++++++++++++++++++++++++++------------------- 2 files changed, 88 insertions(+), 20 deletions(-) create mode 100644 logging.jl diff --git a/logging.jl b/logging.jl new file mode 100644 index 0000000..f8c3276 --- /dev/null +++ b/logging.jl @@ -0,0 +1,58 @@ +using Memento + +function setup_logging(filename::String, handlername::Symbol) + isdir(dirname(filename)) || mkdir(dirname(filename)) + logger = Memento.config!("info", fmt="{date}| {msg}") + handler = DefaultHandler(filename, DefaultFormatter("{date}| {msg}")) + logger.handlers[String(handlername)] = handler + return logger +end + +macro logtime(logger, ex) + quote + local stats = Base.gc_num() + local elapsedtime = Base.time_ns() + local val = $(esc(ex)) + elapsedtime = Base.time_ns() - elapsedtime + local diff = Base.GC_Diff(Base.gc_num(), stats) + local ts = time_string(elapsedtime, + diff.allocd, + diff.total_time, + Base.gc_alloc_count(diff) + ) + $(esc(info))($(esc(logger)), ts) + val + end +end + +function time_string(elapsedtime, bytes, gctime, allocs) + str = @sprintf("%10.6f seconds", elapsedtime/1e9) + if bytes != 0 || allocs != 0 + bytes, mb = Base.prettyprint_getunits(bytes, length(Base._mem_units), Int64(1024)) + allocs, ma = Base.prettyprint_getunits(allocs, length(Base._cnt_units), Int64(1000)) + if ma == 1 + str*= @sprintf(" (%d%s allocation%s: ", allocs, Base._cnt_units[ma], allocs==1 ? "" : "s") + else + str*= @sprintf(" (%.2f%s allocations: ", allocs, Base._cnt_units[ma]) + end + if mb == 1 + str*= @sprintf("%d %s%s", bytes, Base._mem_units[mb], bytes==1 ? "" : "s") + else + str*= @sprintf("%.3f %s", bytes, Base._mem_units[mb]) + end + if gctime > 0 + str*= @sprintf(", %.2f%% gc time", 100*gctime/elapsedtime) + end + str*=")" + elseif gctime > 0 + str*= @sprintf(", %.2f%% gc time", 100*gctime/elapsedtime) + end + return str +end + +import Base: info, @time + +Base.info(x) = info(getlogger(), x) +macro time(x) + return :(@logtime(getlogger(Main), $(esc(x)))) +end diff --git a/main.jl b/main.jl index 40784f7..554ef7d 100644 --- a/main.jl +++ b/main.jl @@ -1,3 +1,5 @@ +include("logging.jl") + using AbstractAlgebra using Nemo using PropertyT @@ -14,16 +16,16 @@ using PropertyTGroups struct Symmetrize end struct Standard end -function summarize(logger, groupdir, iterations, tol, upper_bound, radius, G, S) - info(logger, "Group: $groupdir") - info(logger, "Iterations: $iterations") - info(logger, "Precision: $tol") - info(logger, "Upper bound: $upper_bound") - info(logger, "Radius: $radius") - info(logger, "Threads: $(Threads.nthreads())") - info(logger, "Workers: $(workers())") - info(logger, string(G)) - info(logger, "with generating set of size $(length(S))") +function summarize(groupdir, iterations, tol, upper_bound, radius, G, S) + info("Group: $groupdir") + info("Iterations: $iterations") + info("Precision: $tol") + info("Upper bound: $upper_bound") + info("Radius: $radius") + info("Threads: $(Threads.nthreads())") + info("Workers: $(workers())") + info(string(G)) + info("with generating set of size $(length(S))") end function params(Gr::SymmetrizedGroup) @@ -47,23 +49,31 @@ end scs_solver(tol, iterations) = SCSSolver(eps=tol, max_iters=iterations, linearsolver=SCS.Direct, alpha=1.95, acceleration_lookback=1) -main(G::SymmetrizedGroup) = main(Symmetrize, G) -function main(::Type{Symmetrize}, Gr::SymmetrizedGroup) - radius, tol, iterations, upper_bound, warm, N = params(Gr) - groupdir = "$(PropertyTGroups.name(Gr))_r$radius" +function main(Gr::PropertyTGroup) + r = Gr.args["radius"] + ub = Gr.args["upper-bound"] + groupdir = "$(PropertyTGroups.name(Gr))_r$r" isdir(groupdir) || mkdir(groupdir) - logger = PropertyT.setup_logging(joinpath(groupdir, "$(upper_bound)"), :fulllog) + logfile = PropertyT.filename(joinpath(groupdir, string(ub)), :fulllog) + logger=setup_logging(logfile, :fulllog) + + if Gr.args["nosymmetry"] + return main(Naive, Gr, dir=groupdir) + else + return main(Symmetrize, Gr, dir=groupdir) + end +end G = PropertyTGroups.group(Gr) S = PropertyTGroups.generatingset(Gr) - summarize(logger, groupdir, iterations, tol, upper_bound, radius, G, S) + summarize(dir, iterations, tol, upper_bound, radius, G, S) autS = PropertyTGroups.autS(Gr) - info(logger, "Symmetrising with $(autS)") + info("Symmetrising with $(autS)") solver = scs_solver(tol, iterations) @@ -76,8 +86,8 @@ function main(::Type{Symmetrize}, Gr::SymmetrizedGroup) # solver = SDPA.SDPASolver(epsilonStar=tol, epsilonDash=tol) - sett = Settings(groupdir, N, G, S, autS, - radius, solver, upper_bound, tol, warm, logger) + sett = Settings(dir, N, G, S, autS, + radius, solver, upper_bound, tol, warm) return PropertyT.check_property_T(sett) end @@ -92,7 +102,7 @@ function main(::Type{Standard}, Gr::SymmetrizedGroup) G = PropertyTGroups.group(Gr) S = PropertyTGroups.generatingset(Gr) - summarize(logger, groupdir, iterations, tol, upper_bound, radius, G, S) + summarize(dir, iterations, tol, upper_bound, radius, G, S) solver = scs_solver(tol, iterations)