From fb0d9b0eea6bcb1463724f595d73f2b55048f992 Mon Sep 17 00:00:00 2001 From: Kristoffer Date: Thu, 29 Feb 2024 12:13:31 +0100 Subject: [PATCH] move to using Base parallel precompile --- Project.toml | 1 - src/API.jl | 694 +----------------- .../ShouldPreserveSemver/Manifest.toml | 2 +- 3 files changed, 4 insertions(+), 693 deletions(-) diff --git a/Project.toml b/Project.toml index ce8e687830..a9fba99cf3 100644 --- a/Project.toml +++ b/Project.toml @@ -17,7 +17,6 @@ Markdown = "d6f4376e-aef5-505a-96c1-9c027394607a" Printf = "de0858da-6303-5e67-8744-51eddeeeb8d7" Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c" SHA = "ea8e919c-243c-51af-8825-aaa63cd721ce" -Serialization = "9e88b42a-f829-5b0c-bbe9-9e923198166b" TOML = "fa267f1f-6049-4f14-aa54-33bafae1ed76" Tar = "a4e569a6-e804-4fa4-b0f3-eef7a1d5b13e" UUIDs = "cf7118a7-6976-5b1a-9a39-7adc72f591a4" diff --git a/src/API.jl b/src/API.jl index 950d3b002c..c3281a5d43 100644 --- a/src/API.jl +++ b/src/API.jl @@ -8,7 +8,6 @@ import Random using Dates import LibGit2 import Logging -using Serialization import FileWatching import Base: StaleCacheKey @@ -1099,703 +1098,16 @@ function precompile(ctx::Context, pkgs::Vector{PackageSpec}; internal_call::Bool strict::Bool=false, warn_loaded = true, already_instantiated = false, timing::Bool = false, _from_loading::Bool=false, flags_cacheflags::Pair{Cmd, Base.CacheFlags}=(``=>Base.CacheFlags()), kwargs...) Context!(ctx; kwargs...) - flags, cacheflags = flags_cacheflags if !already_instantiated instantiate(ctx; allow_autoprecomp=false, kwargs...) @debug "precompile: instantiated" end - time_start = time_ns() - - # Windows sometimes hits a ReadOnlyMemoryError, so we halve the default number of tasks. Issue #2323 - # TODO: Investigate why this happens in windows and restore the full task limit - default_num_tasks = Sys.iswindows() ? div(Sys.CPU_THREADS::Int, 2) + 1 : Sys.CPU_THREADS::Int + 1 - default_num_tasks = min(default_num_tasks, 16) # limit for better stability on shared resource systems - - num_tasks = parse(Int, get(ENV, "JULIA_NUM_PRECOMPILE_TASKS", string(default_num_tasks))) - parallel_limiter = Base.Semaphore(num_tasks) - io = ctx.io - if io isa UnstableIO - # precompile does quite a bit of output and using the UnstableIO can cause - # some slowdowns, the important part here is to not specialize the whole - # precompile function on the io - io = io.io - end - fancyprint = can_fancyprint(io) && !timing - - hascolor = get(io, :color, false)::Bool - color_string(cstr::String, col::Union{Int64, Symbol}) = _color_string(cstr, col, hascolor) - - recall_precompile_state() # recall suspended and force-queued packages - !internal_call && precomp_unsuspend!() # when manually called, unsuspend all packages that were suspended due to precomp errors - - direct_deps = [ - Base.PkgId(uuid, name) - for (name, uuid) in ctx.env.project.deps if !Base.in_sysimage(Base.PkgId(uuid, name)) - ] - stale_cache = Dict{StaleCacheKey, Bool}() - exts = Dict{Base.PkgId, String}() # ext -> parent - # make a flat map of each dep and its direct deps - depsmap = Dict{Base.PkgId, Vector{Base.PkgId}}() - pkg_specs = PackageSpec[] - pkg_exts_map = Dict{Base.PkgId, Vector{Base.PkgId}}() - for dep in ctx.env.manifest - pkg = Base.PkgId(first(dep), last(dep).name) - Base.in_sysimage(pkg) && continue - deps = [Base.PkgId(last(x), first(x)) for x in last(dep).deps] - depsmap[pkg] = filter!(!Base.in_sysimage, deps) - # add any extensions - weakdeps = last(dep).weakdeps - pkg_exts = Dict{Base.PkgId, Vector{Base.PkgId}}() - prev_ext = nothing - for (ext_name, extdep_names) in last(dep).exts - ext_deps = Base.PkgId[] - push!(ext_deps, pkg) # depends on parent package - all_extdeps_available = true - extdep_names = extdep_names isa String ? String[extdep_names] : extdep_names - for extdep_name in extdep_names - extdep_uuid = weakdeps[extdep_name] - if extdep_uuid in keys(ctx.env.manifest.deps) || Base.in_sysimage(Base.PkgId(extdep_uuid, extdep_name)) - push!(ext_deps, Base.PkgId(extdep_uuid, extdep_name)) - else - all_extdeps_available = false - break - end - end - all_extdeps_available || continue - if prev_ext isa Base.PkgId - # also make the exts depend on eachother sequentially to avoid race - push!(ext_deps, prev_ext) - end - ext_uuid = Base.uuid5(pkg.uuid, ext_name) - ext = Base.PkgId(ext_uuid, ext_name) - prev_ext = ext - push!(pkg_specs, PackageSpec(uuid = ext_uuid, name = ext_name)) # create this here as the name cannot be looked up easily later via the uuid - filter!(!Base.in_sysimage, ext_deps) - depsmap[ext] = ext_deps - exts[ext] = pkg.name - pkg_exts[ext] = ext_deps - end - if !isempty(pkg_exts) - pkg_exts_map[pkg] = collect(keys(pkg_exts)) - end - end - @debug "precompile: deps collected" - # this loop must be run after the full depsmap has been populated - for (pkg, pkg_exts) in pkg_exts_map - # find any packages that depend on the extension(s)'s deps and replace those deps in their deps list with the extension(s), - # basically injecting the extension into the precompile order in the graph, to avoid race to precompile extensions - for (_pkg, deps) in depsmap # for each manifest dep - if !in(_pkg, keys(exts)) && pkg in deps # if not an extension and depends on pkg - append!(deps, pkg_exts) # add the package extensions to deps - filter!(!isequal(pkg), deps) # remove the pkg from deps - end - end - end - @debug "precompile: extensions collected" - - # if the active environment is a package, add that - ctx_env_pkg = ctx.env.pkg - if ctx_env_pkg !== nothing && isfile(joinpath(dirname(ctx.env.project_file), "src", "$(ctx_env_pkg.name).jl")) - project_pkgid = Base.PkgId(ctx_env_pkg.uuid, ctx_env_pkg.name) - depsmap[project_pkgid] = [ - Base.PkgId(last(x), first(x)) - for x in ctx.env.project.deps if !Base.in_sysimage(Base.PkgId(last(x), first(x))) - ] - push!(direct_deps, Base.PkgId(ctx_env_pkg.uuid, ctx_env_pkg.name)) - else - project_pkgid = nothing - end - - # return early if no deps - if isempty(depsmap) - if isempty(pkgs) - return - elseif _from_loading - # if called from loading precompilation it may be a package from another environment stack so - # don't error and allow serial precompilation to try - # TODO: actually handle packages from other envs in the stack - return - else - pkgerror("No direct dependencies outside of the sysimage found matching $(repr([p.name for p in pkgs]))") - end - end - - # initialize signalling - started = Dict{Base.PkgId,Bool}() - was_processed = Dict{Base.PkgId,Base.Event}() - was_recompiled = Dict{Base.PkgId,Bool}() - for pkgid in keys(depsmap) - started[pkgid] = false - was_processed[pkgid] = Base.Event() - was_recompiled[pkgid] = false - push!(pkg_specs, get_or_make_pkgspec(pkg_specs, ctx, pkgid.uuid)) - end - @debug "precompile: signalling initialized" - - # remove packages that are suspended because they errored before - # note that when `Pkg.precompile` is manually called, all suspended packages are unsuspended - precomp_prune_suspended!(pkg_specs) - - # find and guard against circular deps - circular_deps = Base.PkgId[] - # Three states - # !haskey -> never visited - # true -> cannot be compiled due to a cycle (or not yet determined) - # false -> not depending on a cycle - could_be_cycle = Dict{Base.PkgId, Bool}() - function scan_pkg!(pkg, dmap) - did_visit_dep = true - inpath = get!(could_be_cycle, pkg) do - did_visit_dep = false - return true - end - if did_visit_dep ? inpath : scan_deps!(pkg, dmap) - # Found a cycle. Delete this and all parents - return true - end - return false - end - function scan_deps!(pkg, dmap) - for dep in dmap[pkg] - scan_pkg!(dep, dmap) && return true - end - could_be_cycle[pkg] = false - return false - end - for pkg in keys(depsmap) - if scan_pkg!(pkg, depsmap) - push!(circular_deps, pkg) - notify(was_processed[pkg]) - end - end - if !isempty(circular_deps) - @warn """Circular dependency detected. Precompilation will be skipped for:\n $(join(string.(circular_deps), "\n "))""" - end - @debug "precompile: circular dep check done" - - # if a list of packages is given, restrict to dependencies of given packages - if !isempty(pkgs) - pkgs_names = [p.name for p in pkgs] - function collect_all_deps(depsmap, dep, alldeps=Set{Base.PkgId}()) - for _dep in depsmap[dep] - if !(_dep in alldeps) - push!(alldeps, _dep) - collect_all_deps(depsmap, _dep, alldeps) - end - end - return alldeps - end - keep = Set{Base.PkgId}() - for dep in depsmap - dep_pkgid = first(dep) - if dep_pkgid.name in pkgs_names - push!(keep, dep_pkgid) - collect_all_deps(depsmap, dep_pkgid, keep) - end - end - for ext in keys(exts) - if issubset(collect_all_deps(depsmap, ext), keep) # if all extension deps are kept - push!(keep, ext) - end - end - filter!(d->in(first(d), keep), depsmap) - if isempty(depsmap) - if _from_loading - # if called from loading precompilation it may be a package from another environment stack so - # don't error and allow serial precompilation to try - # TODO: actually handle packages from other envs in the stack - return - else - pkgerror("No direct dependencies outside of the sysimage found matching $(repr(pkgs_names))") - end - end - target = join(pkgs_names, ", ") - else - target = "project..." - end - @debug "precompile: packages filtered" - - pkg_queue = Base.PkgId[] - failed_deps = Dict{Base.PkgId, String}() - skipped_deps = Base.PkgId[] - precomperr_deps = Base.PkgId[] # packages that may succeed after a restart (i.e. loaded packages with no cache file) - - print_lock = ctx.io isa Base.LibuvStream ? ctx.io.lock::ReentrantLock : ReentrantLock() - first_started = Base.Event() - printloop_should_exit::Bool = !fancyprint # exit print loop immediately if not fancy printing - interrupted_or_done = Base.Event() - - ansi_moveup(n::Int) = string("\e[", n, "A") - ansi_movecol1 = "\e[1G" - ansi_cleartoend = "\e[0J" - ansi_cleartoendofline = "\e[0K" - ansi_enablecursor = "\e[?25h" - ansi_disablecursor = "\e[?25l" - n_done::Int = 0 - n_already_precomp::Int = 0 - n_loaded::Int = 0 - interrupted = false - - function handle_interrupt(err, in_printloop = false) - notify(interrupted_or_done) - in_printloop || wait(t_print) # wait to let the print loop cease first - if err isa InterruptException - lock(print_lock) do - println(io, " Interrupted: Exiting precompilation...") - end - interrupted = true - return true - else - return false - end - end - - std_outputs = Dict{Base.PkgId,String}() - taskwaiting = Set{Base.PkgId}() - pkgspidlocked = Dict{Base.PkgId,String}() - pkg_liveprinted = nothing - - function monitor_std(pkg, pipe; single_requested_pkg=false) - try - liveprinting = false - while !eof(pipe) - str = readline(pipe, keep=true) - if single_requested_pkg && (liveprinting || !isempty(str)) - lock(print_lock) do - if !liveprinting - printpkgstyle(io, :Info, "Given $(pkg.name) was explicitly requested, output will be shown live $ansi_cleartoendofline", - color = Base.info_color()) - liveprinting = true - pkg_liveprinted = pkg - end - print(io, ansi_cleartoendofline, str) - end - end - std_outputs[pkg] = string(get(std_outputs, pkg, ""), str) - if !in(pkg, taskwaiting) && occursin("waiting for IO to finish", str) - !fancyprint && lock(print_lock) do - println(io, pkg.name, color_string(" Waiting for background task / IO / timer.", Base.warn_color())) - end - push!(taskwaiting, pkg) - end - if !fancyprint && in(pkg, taskwaiting) - lock(print_lock) do - print(io, str) - end - end - end - catch err - err isa InterruptException || rethrow() - end + activate(dirname(ctx.env.project_file)) do + pkgs_name = String[pkg.name for pkg in pkgs] + return Base.PrecompilePkgs.precompilepkgs(pkgs_name; internal_call, strict, warn_loaded, timing, _from_loading, flags_cacheflags, io=ctx.io) end - - ## fancy print loop - t_print = @async begin - try - wait(first_started) - (isempty(pkg_queue) || interrupted_or_done.set) && return - fancyprint && lock(print_lock) do - printpkgstyle(io, :Precompiling, target) - print(io, ansi_disablecursor) - end - t = Timer(0; interval=1/10) - anim_chars = ["◐","◓","◑","◒"] - i = 1 - last_length = 0 - bar = MiniProgressBar(; indent=2, header = "Progress", color = Base.info_color(), percentage=false, always_reprint=true) - n_total = length(depsmap) - bar.max = n_total - n_already_precomp - final_loop = false - n_print_rows = 0 - while !printloop_should_exit - lock(print_lock) do - term_size = Base.displaysize(ctx.io)::Tuple{Int,Int} - num_deps_show = term_size[1] - 3 - pkg_queue_show = if !interrupted_or_done.set && length(pkg_queue) > num_deps_show - last(pkg_queue, num_deps_show) - else - pkg_queue - end - str_ = sprint() do iostr - if i > 1 - print(iostr, ansi_cleartoend) - end - bar.current = n_done - n_already_precomp - bar.max = n_total - n_already_precomp - # when sizing to the terminal width subtract a little to give some tolerance to resizing the - # window between print cycles - termwidth = displaysize(io)[2] - 4 - if !final_loop - str = sprint(io -> show_progress(io, bar; termwidth, carriagereturn=false); context=io) - print(iostr, Base._truncate_at_width_or_chars(true, str, termwidth), "\n") - end - for dep in pkg_queue_show - loaded = warn_loaded && haskey(Base.loaded_modules, dep) - _name = haskey(exts, dep) ? string(exts[dep], " → ", dep.name) : dep.name - name = dep in direct_deps ? _name : string(color_string(_name, :light_black)) - line = if dep in precomperr_deps - string(color_string(" ? ", Base.warn_color()), name) - elseif haskey(failed_deps, dep) - string(color_string(" ✗ ", Base.error_color()), name) - elseif was_recompiled[dep] - !loaded && interrupted_or_done.set && continue - loaded || @async begin # keep successful deps visible for short period - sleep(1); - filter!(!isequal(dep), pkg_queue) - end - string(color_string(" ✓ ", loaded ? Base.warn_color() : :green), name) - elseif started[dep] - # Offset each spinner animation using the first character in the package name as the seed. - # If not offset, on larger terminal fonts it looks odd that they all sync-up - anim_char = anim_chars[(i + Int(dep.name[1])) % length(anim_chars) + 1] - anim_char_colored = dep in direct_deps ? anim_char : color_string(anim_char, :light_black) - waiting = if haskey(pkgspidlocked, dep) - who_has_lock = pkgspidlocked[dep] - color_string(" Being precompiled by $(who_has_lock)", Base.info_color()) - elseif dep in taskwaiting - color_string(" Waiting for background task / IO / timer. Interrupt to inspect", Base.warn_color()) - else - "" - end - string(" ", anim_char_colored, " ", name, waiting) - else - string(" ", name) - end - println(iostr, Base._truncate_at_width_or_chars(true, line, termwidth)) - end - end - last_length = length(pkg_queue_show) - n_print_rows = count("\n", str_) - print(io, str_) - printloop_should_exit = interrupted_or_done.set && final_loop - final_loop = interrupted_or_done.set # ensures one more loop to tidy last task after finish - i += 1 - printloop_should_exit || print(io, ansi_moveup(n_print_rows), ansi_movecol1) - end - wait(t) - end - catch err - handle_interrupt(err, true) || rethrow() - finally - fancyprint && print(io, ansi_enablecursor) - end - end - tasks = Task[] - if !_from_loading - Base.LOADING_CACHE[] = Base.LoadingCache() - end - @debug "precompile: starting precompilation loop" - ## precompilation loop - for (pkg, deps) in depsmap - cachepaths = Base.find_all_in_cache_path(pkg) - sourcepath = Base.locate_package(pkg) - if sourcepath === nothing - failed_deps[pkg] = "Error: Missing source file for $(pkg)" - notify(was_processed[pkg]) - continue - end - # Heuristic for when precompilation is disabled - if occursin(r"\b__precompile__\(\s*false\s*\)", read(sourcepath, String)) - notify(was_processed[pkg]) - continue - end - - single_requested_pkg = if length(pkgs) == 1 - only(pkgs).name == pkg.name - elseif project_pkgid isa Base.PkgId - pkg == project_pkgid # if a package project is being precompiled, consider the package requested - else - false - end - - task = @async begin - try - loaded = haskey(Base.loaded_modules, pkg) - for dep in deps # wait for deps to finish - wait(was_processed[dep]) - end - - pkgspec = get_or_make_pkgspec(pkg_specs, ctx, pkg.uuid) - suspended = precomp_suspended(pkgspec) - queued = precomp_queued(pkgspec) - - circular = pkg in circular_deps - is_stale = true - if !circular && (queued || (!suspended && (is_stale = !Base.isprecompiled(pkg; ignore_loaded=true, flags=cacheflags, stale_cache, cachepaths, sourcepath)))) - Base.acquire(parallel_limiter) - is_direct_dep = pkg in direct_deps - - # std monitoring - std_pipe = Base.link_pipe!(Pipe(); reader_supports_async=true, writer_supports_async=true) - t_monitor = @async monitor_std(pkg, std_pipe; single_requested_pkg) - - _name = haskey(exts, pkg) ? string(exts[pkg], " → ", pkg.name) : pkg.name - name = is_direct_dep ? _name : string(color_string(_name, :light_black)) - !fancyprint && lock(print_lock) do - isempty(pkg_queue) && printpkgstyle(io, :Precompiling, target) - end - push!(pkg_queue, pkg) - started[pkg] = true - fancyprint && notify(first_started) - if interrupted_or_done.set - notify(was_processed[pkg]) - Base.release(parallel_limiter) - return - end - try - # allows processes to wait if another process is precompiling a given package to - # a functionally identical package cache (except for preferences, which may differ) - t = @elapsed ret = maybe_cachefile_lock(io, print_lock, fancyprint, pkg, pkgspidlocked, hascolor) do - Logging.with_logger(Logging.NullLogger()) do - # The false here means we ignore loaded modules, so precompile for a fresh session - Base.compilecache(pkg, sourcepath, std_pipe, std_pipe, false; flags) - end - end - t_str = timing ? string(lpad(round(t * 1e3, digits = 1), 9), " ms") : "" - if ret isa Base.PrecompilableError - push!(precomperr_deps, pkg) - precomp_queue!(get_or_make_pkgspec(pkg_specs, ctx, pkg.uuid)) - !fancyprint && lock(print_lock) do - println(io, t_str, color_string(" ? ", Base.warn_color()), name) - end - else - queued && precomp_dequeue!(get_or_make_pkgspec(pkg_specs, ctx, pkg.uuid)) - !fancyprint && lock(print_lock) do - println(io, t_str, color_string(" ✓ ", loaded ? Base.warn_color() : :green), name) - end - was_recompiled[pkg] = true - end - loaded && (n_loaded += 1) - catch err - close(std_pipe.in) # close pipe to end the std output monitor - wait(t_monitor) - if err isa ErrorException || (err isa ArgumentError && startswith(err.msg, "Invalid header in cache file")) - failed_deps[pkg] = (strict || is_direct_dep) ? string(sprint(showerror, err), "\n", strip(get(std_outputs, pkg, ""))) : "" - delete!(std_outputs, pkg) # so it's not shown as warnings, given error report - !fancyprint && lock(print_lock) do - println(io, timing ? " "^9 : "", color_string(" ✗ ", Base.error_color()), name) - end - queued && precomp_dequeue!(get_or_make_pkgspec(pkg_specs, ctx, pkg.uuid)) - precomp_suspend!(get_or_make_pkgspec(pkg_specs, ctx, pkg.uuid)) - else - rethrow() - end - finally - isopen(std_pipe.in) && close(std_pipe.in) # close pipe to end the std output monitor - wait(t_monitor) - Base.release(parallel_limiter) - end - else - is_stale || (n_already_precomp += 1) - suspended && push!(skipped_deps, pkg) - end - n_done += 1 - notify(was_processed[pkg]) - catch err_outer - handle_interrupt(err_outer) || rethrow() - notify(was_processed[pkg]) - finally - filter!(!istaskdone, tasks) - length(tasks) == 1 && notify(interrupted_or_done) - end - end - push!(tasks, task) - end - isempty(tasks) && notify(interrupted_or_done) - try - wait(interrupted_or_done) - catch err - handle_interrupt(err) || rethrow() - finally - Base.LOADING_CACHE[] = nothing - end - notify(first_started) # in cases of no-op or !fancyprint - save_precompile_state() # save lists to scratch space - fancyprint && wait(t_print) - quick_exit = !all(istaskdone, tasks) || interrupted # if some not finished internal error is likely - seconds_elapsed = round(Int, (time_ns() - time_start) / 1e9) - ndeps = count(values(was_recompiled)) - if ndeps > 0 || !isempty(failed_deps) || (quick_exit && !isempty(std_outputs)) - str = sprint() do iostr - if !quick_exit - plural = ndeps == 1 ? "y" : "ies" - print(iostr, " $(ndeps) dependenc$(plural) successfully precompiled in $(seconds_elapsed) seconds") - if n_already_precomp > 0 || !isempty(circular_deps) || !isempty(skipped_deps) - n_already_precomp > 0 && (print(iostr, ". $n_already_precomp already precompiled")) - !isempty(circular_deps) && (print(iostr, ". $(length(circular_deps)) skipped due to circular dependency")) - !isempty(skipped_deps) && (print(iostr, ". $(length(skipped_deps)) skipped during auto due to previous errors")) - print(iostr, ".") - end - if n_loaded > 0 - plural1 = n_loaded == 1 ? "y" : "ies" - plural2 = n_loaded == 1 ? "a different version is" : "different versions are" - plural3 = n_loaded == 1 ? "" : "s" - print(iostr, "\n ", - color_string(string(n_loaded), Base.warn_color()), - " dependenc$(plural1) precompiled but $(plural2) currently loaded. Restart julia to access the new version$(plural3)" - ) - end - if !isempty(precomperr_deps) - pluralpc = length(precomperr_deps) == 1 ? "y" : "ies" - print(iostr, "\n ", - color_string(string(length(precomperr_deps)), Base.warn_color()), - " dependenc$(pluralpc) failed but may be precompilable after restarting julia" - ) - end - end - # show any stderr output, even if Pkg.precompile has been interrupted (quick_exit=true), given user may be - # interrupting a hanging precompile job with stderr output. julia#48371 - filter!(kv -> !isempty(strip(last(kv))), std_outputs) # remove empty output - if !isempty(std_outputs) - plural1 = length(std_outputs) == 1 ? "y" : "ies" - plural2 = length(std_outputs) == 1 ? "" : "s" - print(iostr, "\n ", color_string("$(length(std_outputs))", Base.warn_color()), " dependenc$(plural1) had output during precompilation:") - for (pkgid, err) in std_outputs - err = if pkgid == pkg_liveprinted - "[Output was shown above]" - else - join(split(strip(err), "\n"), color_string("\n│ ", Base.warn_color())) - end - name = haskey(exts, pkgid) ? string(exts[pkgid], " → ", pkgid.name) : pkgid.name - print(iostr, color_string("\n┌ ", Base.warn_color()), name, color_string("\n│ ", Base.warn_color()), err, color_string("\n└ ", Base.warn_color())) - end - end - end - let str=str - lock(print_lock) do - println(io, str) - end - end - quick_exit && return - err_str = "" - n_direct_errs = 0 - for (dep, err) in failed_deps - if strict || (dep in direct_deps) - err_str = string(err_str, "\n$dep\n\n$err", (n_direct_errs > 0 ? "\n" : "")) - n_direct_errs += 1 - end - end - if err_str != "" - pluralde = n_direct_errs == 1 ? "y" : "ies" - direct = strict ? "" : "direct " - err_msg = "The following $n_direct_errs $(direct)dependenc$(pluralde) failed to precompile:\n$(err_str[1:end-1])" - if internal_call # aka. auto-precompilation - if isinteractive() && !get(ENV, "CI", false) - plural1 = length(failed_deps) == 1 ? "y" : "ies" - println(io, " ", color_string("$(length(failed_deps))", Base.error_color()), " dependenc$(plural1) errored.") - println(io, " For a report of the errors see `julia> err`. To retry use `pkg> precompile`") - setglobal!(Base.MainInclude, :err, PkgPrecompileError(err_msg)) - else - # auto-precompilation shouldn't throw but if the user can't easily access the - # error messages, just show them - print(io, "\n", err_msg) - end - else - println(io) - pkgerror(err_msg) - end - end - end - nothing -end - -function _color_string(cstr::String, col::Union{Int64, Symbol}, hascolor) - if hascolor - enable_ansi = get(Base.text_colors, col, Base.text_colors[:default]) - disable_ansi = get(Base.disable_text_style, col, Base.text_colors[:default]) - return string(enable_ansi, cstr, disable_ansi) - else - return cstr - end -end - -function maybe_cachefile_lock(f, io::IO, print_lock::ReentrantLock, fancyprint::Bool, pkg::Base.PkgId, pkgspidlocked::Dict{Base.PkgId,String}, hascolor) - stale_age = Base.compilecache_pidlock_stale_age - pidfile = Base.compilecache_pidfile_path(pkg) - cachefile = FileWatching.trymkpidlock(f, pidfile; stale_age) - if cachefile === false - pid, hostname, age = FileWatching.Pidfile.parse_pidfile(pidfile) - pkgspidlocked[pkg] = if isempty(hostname) || hostname == gethostname() - if pid == getpid() - "an async task in this process (pidfile: $pidfile)" - else - "another process (pid: $pid, pidfile: $pidfile)" - end - else - "another machine (hostname: $hostname, pid: $pid, pidfile: $pidfile)" - end - !fancyprint && lock(print_lock) do - println(io, " ", pkg.name, _color_string(" Being precompiled by $(pkgspidlocked[pkg])", Base.info_color(), hascolor)) - end - # wait until the lock is available - FileWatching.mkpidlock(pidfile; stale_age) do - # double-check in case the other process crashed or the lock expired - if Base.isprecompiled(pkg; ignore_loaded=true, flags=cacheflags) # don't use caches for this as the env state will have changed - return nothing # returning nothing indicates a process waited for another - else - delete!(pkgspidlocked, pkg) - return f() # precompile - end - end - end - return cachefile -end - -const pkgs_precompile_suspended = PackageSpec[] # packages that shouldn't be retried during autoprecomp -const pkgs_precompile_pending = PackageSpec[] # packages that need to be retried after restart -function save_precompile_state() - path = Operations.pkg_scratchpath() - for (prefix, store) in (("suspend_cache_", pkgs_precompile_suspended), ("pending_cache_", pkgs_precompile_pending)) - fpath = joinpath(path, string(prefix, hash(string(Base.active_project(), Base.VERSION)))) - if isempty(store) - Base.rm(fpath, force=true) - else - mkpath(path); Base.rm(fpath, force=true) - open(fpath, "w") do io - serialize(io, store) - end - end - end - return nothing -end -function recall_precompile_state() - for (prefix, store) in (("suspend_cache_", pkgs_precompile_suspended), ("pending_cache_", pkgs_precompile_pending)) - fpath = joinpath(Operations.pkg_scratchpath(), string(prefix, hash(string(Base.active_project(), Base.VERSION)))) - if isfile(fpath) - open(fpath) do io - try - pkgspecs = deserialize(io)::Vector{PackageSpec} - append!(empty!(store), pkgspecs) - catch - empty!(store) - end - end - Base.rm(fpath, force=true) - else - empty!(store) - end - end - return nothing -end -function precomp_suspend!(pkg::PackageSpec) - precomp_suspended(pkg) || push!(pkgs_precompile_suspended, pkg) - return -end -precomp_unsuspend!() = empty!(pkgs_precompile_suspended) -precomp_suspended(pkg::PackageSpec) = pkg in pkgs_precompile_suspended -function precomp_prune_suspended!(pkgs::Vector{PackageSpec}) - filter!(in(pkgs), pkgs_precompile_suspended) - unique!(pkgs_precompile_suspended) - return -end - -function precomp_queue!(pkg::PackageSpec) - precomp_suspended(pkg) || push!(pkgs_precompile_pending, pkg) - return end -precomp_dequeue!(pkg::PackageSpec) = filter!(!isequal(pkg), pkgs_precompile_pending) -precomp_queued(pkg::PackageSpec) = pkg in pkgs_precompile_pending function tree_hash(repo::LibGit2.GitRepo, tree_hash::String) try diff --git a/test/test_packages/ShouldPreserveSemver/Manifest.toml b/test/test_packages/ShouldPreserveSemver/Manifest.toml index 6be48fc339..46f561656a 100644 --- a/test/test_packages/ShouldPreserveSemver/Manifest.toml +++ b/test/test_packages/ShouldPreserveSemver/Manifest.toml @@ -154,7 +154,7 @@ uuid = "bac558e1-5e72-5ebc-8fee-abe8a469f55d" version = "1.1.0" [[deps.Pkg]] -deps = ["Artifacts", "Dates", "Downloads", "FileWatching", "LibGit2", "Libdl", "Logging", "Markdown", "Printf", "REPL", "Random", "SHA", "Serialization", "TOML", "Tar", "UUIDs", "p7zip_jll"] +deps = ["Artifacts", "Dates", "Downloads", "FileWatching", "LibGit2", "Libdl", "Logging", "Markdown", "Printf", "REPL", "Random", "SHA", "TOML", "Tar", "UUIDs", "p7zip_jll"] uuid = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f" version = "1.8.0"