Package evaluation of ComradeNested on Julia 1.13.0-DEV.449 (8d6b63c3a6*) started at 2025-04-29T09:03:44.372 ################################################################################ # Set-up # Set-up completed after 0.23s ################################################################################ # Installation # Installing ComradeNested... Resolving package versions... Updating `~/.julia/environments/v1.13/Project.toml` [233675ba] + ComradeNested v0.3.0 Updating `~/.julia/environments/v1.13/Manifest.toml` [621f4979] + AbstractFFTs v1.5.0 ⌅ [80f14c24] + AbstractMCMC v4.4.2 [7f219486] + AbstractNFFTs v0.8.2 [1520ce14] + AbstractTrees v0.4.5 [7d9f7c33] + Accessors v0.1.42 [79e6a3ab] + Adapt v4.3.0 [66dad0bd] + AliasTables v1.1.3 [dce04be8] + ArgCheck v2.5.0 ⌅ [ec485272] + ArnoldiMethod v0.1.0 [4fba245c] + ArrayInterface v7.18.0 [c61b5328] + AstroTime v0.7.1 [13072b0f] + AxisAlgorithms v1.1.0 [39de3d68] + AxisArrays v0.4.7 ⌅ [198e06fe] + BangBang v0.3.40 [9718e550] + Baselet v0.1.1 [26cce99e] + BasicInterpolators v0.7.1 [0e736298] + Bessels v0.2.8 [d1d4a3ce] + BitFlags v0.1.9 [62783981] + BitTwiddlingConvenienceFunctions v0.1.6 [fa961155] + CEnum v0.5.0 [3b1b4be9] + CFITSIO v1.4.2 [2a0fbf3d] + CPUSummary v0.2.6 [d360d2e6] + ChainRulesCore v1.25.1 [fb6a15b2] + CloseOpenIntervals v0.1.13 [aaaa29a8] + Clustering v0.15.8 [944b1d66] + CodecZlib v0.7.8 [bbf7d656] + CommonSubexpressions v0.3.1 [34da2185] + Compat v4.16.0 [a33af91c] + CompositionsBase v0.1.2 ⌅ [99d987ce] + Comrade v0.9.4 ⌅ [6d8c423b] + ComradeBase v0.6.6 [233675ba] + ComradeNested v0.3.0 [f0e56b4a] + ConcurrentUtilities v2.5.0 [88cd18e8] + ConsoleProgressMonitor v0.1.2 [187b0558] + ConstructionBase v1.5.8 [6add18c4] + ContextVariablesX v0.1.3 [adafc99b] + CpuId v0.3.1 [a8cc5b0e] + Crayons v4.1.1 [9a962f9c] + DataAPI v1.16.0 [864edb3b] + DataStructures v0.18.22 [e2d170a0] + DataValueInterfaces v1.0.0 [244e2a9f] + DefineSingletons v0.1.2 [8bb1440f] + DelimitedFiles v1.9.1 [b429d917] + DensityInterface v0.4.0 [85a47980] + Dictionaries v0.4.5 [163ba53b] + DiffResults v1.1.0 [b552c78f] + DiffRules v1.15.1 ⌅ [0703355e] + DimensionalData v0.26.8 [b4f34e82] + Distances v0.10.12 [31c24e10] + Distributions v0.25.119 [ffbed154] + DocStringExtensions v0.9.4 [732a3c5d] + EarthOrientation v0.7.3 ⌅ [7da242da] + Enzyme v0.11.20 ⌅ [f151be2c] + EnzymeCore v0.6.6 [460bff9d] + ExceptionUnwrapping v0.1.11 [e2ba6199] + ExprTools v0.1.10 [411431e0] + Extents v0.1.5 [7a1cc6ca] + FFTW v1.8.1 [525bcba6] + FITSIO v0.17.4 [cc61a311] + FLoops v0.2.2 [b9860ae5] + FLoopsBase v0.1.1 ⌅ [7034ab61] + FastBroadcast v0.2.8 [5789e2e9] + FileIO v1.17.0 [1a297f60] + FillArrays v1.13.0 ⌅ [f6369f11] + ForwardDiff v0.10.38 ⌅ [61eb1bfa] + GPUCompiler v0.25.0 [cd3eb016] + HTTP v1.10.16 [9ec9aee3] + HypercubeTransform v0.4.3 [34004b35] + HypergeometricFunctions v0.3.28 [615f187c] + IfElse v0.1.1 [313cdc1a] + Indexing v1.1.1 [d25df0c9] + Inflate v0.1.5 [22cec73e] + InitialValues v0.3.1 [85a1e053] + Interfaces v0.3.2 [a98d9a8b] + Interpolations v0.15.1 [8197267c] + IntervalSets v0.7.11 [3587e190] + InverseFunctions v0.1.17 [41ab1584] + InvertedIndices v1.3.1 [92d709cd] + IrrationalConstants v0.2.4 [d5eda45b] + ItemGraphs v0.4.0 [c8e1da08] + IterTools v1.10.0 [82899510] + IteratorInterfaceExtensions v1.0.0 [692b3bcd] + JLLWrappers v1.7.0 [b14d175d] + JuliaVariables v0.2.4 [5ab0869b] + KernelDensity v0.6.9 ⌅ [929cbde3] + LLVM v6.6.3 [b964fa9f] + LaTeXStrings v1.4.0 [10f19ff3] + LayoutPointers v0.1.17 [2f5f767c] + LeapSeconds v1.1.0 [1d6d02ad] + LeftChildRightSiblingTrees v0.2.0 [093fc24a] + LightGraphs v1.3.5 [6fdf6af0] + LogDensityProblems v2.1.2 [2ab3a3ac] + LogExpFunctions v0.3.29 [e6f89c97] + LoggingExtras v1.1.0 [c7f686f2] + MCMCChains v6.0.7 [be115224] + MCMCDiagnosticTools v0.3.14 [e80e1ace] + MLJModelInterface v1.11.1 [d8e11817] + MLStyle v0.4.17 [1914dd2f] + MacroTools v0.5.16 [d125e4d3] + ManualMemory v0.1.8 [739be429] + MbedTLS v1.1.9 [c03570c3] + Memoize v0.4.4 ⌅ [128add7d] + MicroCollections v0.1.4 [e1d29d7a] + Missings v1.2.0 [46d2c3a1] + MuladdMacro v0.2.4 [efe261a4] + NFFT v0.13.7 [77ba4419] + NaNMath v1.1.3 [71a1bf82] + NameResolution v0.1.5 [d9ec5142] + NamedTupleTools v0.14.3 [c020b1a1] + NaturalSort v1.0.0 [b8a86587] + NearestNeighbors v0.4.21 [41ceaf6f] + NestedSamplers v0.8.3 [d8793406] + ObjectFile v0.4.4 [6fe1bfb0] + OffsetArrays v1.17.0 [4d8831e6] + OpenSSL v1.4.3 [fbd9d27c] + OptionalData v1.0.0 [bac558e1] + OrderedCollections v1.8.0 [90014a1f] + PDMats v0.11.34 [5432bcbf] + PaddedViews v0.5.12 [2412ca09] + ParameterHandling v0.5.0 [d96e819e] + Parameters v0.12.3 [d3c5d4cd] + PolarizedTypes v0.1.2 [f517fe37] + Polyester v0.7.16 [1d0040c9] + PolyesterWeave v0.2.2 [aea7be01] + PrecompileTools v1.3.2 [21216c6a] + Preferences v1.4.3 [8162dcfd] + PrettyPrint v0.2.0 [08abe8d2] + PrettyTables v2.4.0 [33c8b6b6] + ProgressLogging v0.1.4 [92933f4c] + ProgressMeter v1.10.4 [43287f4e] + PtrArrays v1.3.0 ⌃ [1fd47b50] + QuadGK v2.10.1 [b3c3ace0] + RangeArrays v0.3.2 [c84ed2f1] + Ratios v0.4.5 [3cdcf5f2] + RecipesBase v1.3.4 [189a3867] + Reexport v1.2.2 [cbe49d4c] + RemoteFiles v0.5.0 [ae029012] + Requires v1.3.1 [79098fc4] + Rmath v0.8.0 [94e857df] + SIMDTypes v0.1.0 [30f210dd] + ScientificTypesBase v3.0.0 [6c6a2e73] + Scratch v1.2.1 [efcf1570] + Setfield v1.1.2 [777ac1f9] + SimpleBufferStream v1.2.0 [699a6c99] + SimpleTraits v0.9.4 [a2af1166] + SortingAlgorithms v1.2.1 [276daf66] + SpecialFunctions v2.5.1 [03a91e81] + SplitApplyCombine v1.2.3 [171d559e] + SplittablesBase v0.1.15 ⌅ [aedffcd0] + Static v0.8.10 [0d7ed370] + StaticArrayInterface v1.8.0 [90137ffa] + StaticArrays v1.9.13 [1e83bf80] + StaticArraysCore v1.4.3 [64bff920] + StatisticalTraits v3.4.0 [10745b16] + Statistics v1.11.1 [82ae8749] + StatsAPI v1.7.0 [2913bbd2] + StatsBase v0.34.4 [4c63d2b9] + StatsFuns v1.5.0 [7792a7ef] + StrideArraysCore v0.5.7 [892a3eda] + StringManipulation v0.4.1 ⌅ [09ab397b] + StructArrays v0.6.21 [53d494c1] + StructIO v0.3.1 [3783bdb8] + TableTraits v1.0.1 [bd369af6] + Tables v1.12.0 [5d786b92] + TerminalLoggers v0.1.7 [8290d209] + ThreadingUtilities v0.5.3 [a759f4b9] + TimerOutputs v0.5.28 [3bb67fe8] + TranscodingStreams v0.11.3 ⌃ [28d57a85] + Transducers v0.4.80 [84d833dd] + TransformVariables v0.8.16 [410a4b4d] + Tricks v0.1.10 [9d95f2ec] + TypedTables v1.4.6 [5c2747f8] + URIs v1.5.2 [3a884ed6] + UnPack v1.0.2 ⌅ [90db92cd] + VLBILikelihoods v0.2.3 ⌅ [d6343c73] + VLBISkyModels v0.4.8 [efce3f68] + WoodburyMatrices v1.0.0 [b3e40c51] + CFITSIO_jll v4.4.0+0 ⌅ [7cc45869] + Enzyme_jll v0.0.102+0 [f5851436] + FFTW_jll v3.3.11+0 [1d5cc7b8] + IntelOpenMP_jll v2025.0.4+0 ⌅ [dad2f222] + LLVMExtra_jll v0.0.29+0 [856f044c] + MKL_jll v2025.0.1+1 [c8ffd9c3] + MbedTLS_jll v2.28.6+2 [efe28fd5] + OpenSpecFun_jll v0.5.6+0 [f50d1b31] + Rmath_jll v0.5.1+0 [1317d2d5] + oneTBB_jll v2022.0.0+0 [0dad84c5] + ArgTools v1.1.2 [56f22d72] + Artifacts v1.11.0 [2a0f44e3] + Base64 v1.11.0 [ade2ca70] + Dates v1.11.0 [8ba89e20] + Distributed v1.11.0 [f43a241f] + Downloads v1.7.0 [7b1f6079] + FileWatching v1.11.0 [9fa8497b] + Future v1.11.0 [b77e0a4c] + InteractiveUtils v1.11.0 [ac6e5ff7] + JuliaSyntaxHighlighting v1.12.0 [4af54fe1] + LazyArtifacts v1.11.0 [b27032c2] + LibCURL v0.6.4 [76f85450] + LibGit2 v1.11.0 [8f399da3] + Libdl v1.11.0 [37e2e46d] + LinearAlgebra v1.12.0 [56ddb016] + Logging v1.11.0 [d6f4376e] + Markdown v1.11.0 [a63ad114] + Mmap v1.11.0 [ca575930] + NetworkOptions v1.3.0 [44cfe95a] + Pkg v1.12.0 [de0858da] + Printf v1.11.0 [3fa0cd96] + REPL v1.11.0 [9a3f8284] + Random v1.11.0 [ea8e919c] + SHA v0.7.0 [9e88b42a] + Serialization v1.11.0 [1a1011a3] + SharedArrays v1.11.0 [6462fe0b] + Sockets v1.11.0 [2f01184e] + SparseArrays v1.12.0 [f489334b] + StyledStrings v1.11.0 [4607b0f0] + SuiteSparse [fa267f1f] + TOML v1.0.3 [a4e569a6] + Tar v1.10.0 [8dfed614] + Test v1.11.0 [cf7118a7] + UUIDs v1.11.0 [4ec0a83e] + Unicode v1.11.0 [e66e0078] + CompilerSupportLibraries_jll v1.3.0+1 [deac9b47] + LibCURL_jll v8.12.1+1 [e37daf67] + LibGit2_jll v1.9.0+0 [29816b5a] + LibSSH2_jll v1.11.3+1 [14a3606d] + MozillaCACerts_jll v2024.12.31 [4536629a] + OpenBLAS_jll v0.3.29+0 [05823500] + OpenLibm_jll v0.8.5+0 [458c3c95] + OpenSSL_jll v3.0.16+0 [bea87d4a] + SuiteSparse_jll v7.10.1+0 [83775a58] + Zlib_jll v1.3.1+2 [8e850b90] + libblastrampoline_jll v5.12.0+0 [8e850ede] + nghttp2_jll v1.65.0+0 [3f19e933] + p7zip_jll v17.5.0+2 Info Packages marked with ⌃ and ⌅ have new versions available. Those with ⌃ may be upgradable, but those with ⌅ are restricted by compatibility constraints from upgrading. To see why use `status --outdated -m` Installation completed after 11.25s ################################################################################ # Precompilation # Precompiling PkgEval dependencies... No packages added to or removed from `~/.julia/environments/pkgeval/Project.toml` No packages added to or removed from `~/.julia/environments/pkgeval/Manifest.toml` Precompiling package dependencies... Precompiling packages... 18226.8 ms ✓ AbstractMCMC 13028.8 ms ✓ ComradeBase 10205.2 ms ? GPUCompiler 9732.4 ms ✓ Distributions 35072.5 ms ✓ NFFT 26042.8 ms ? Enzyme 4741.6 ms ✓ Distributions → DistributionsDensityInterfaceExt 5034.0 ms ✓ Distributions → DistributionsTestExt 5204.8 ms ✓ Distributions → DistributionsChainRulesCoreExt 20237.4 ms ✓ HypercubeTransform 23489.5 ms ? MCMCDiagnosticTools 49717.5 ms ? Enzyme → EnzymeSpecialFunctionsExt 21372.2 ms ✓ KernelDensity 56998.7 ms ✓ VLBILikelihoods 53732.2 ms ? VLBISkyModels 10587.3 ms ? MCMCChains 116417.3 ms ? Comrade 22868.9 ms ? NestedSamplers 36920.0 ms ? ComradeNested 10 dependencies successfully precompiled in 553 seconds. 262 already precompiled. 9 dependencies failed but may be precompilable after restarting julia 9 dependencies had output during precompilation: ┌ MCMCChains │ WARNING: Method definition kwcall(NamedTuple{names, T} where T<:Tuple where names, typeof(Statistics.cov), SparseArrays.SparseMatrixCSC{Tv, Ti} where Ti<:Integer where Tv) in module SparseArraysExt at /home/pkgeval/.julia/packages/Statistics/gbcbG/ext/SparseArraysExt.jl:14 overwritten in module SparseArraysExt on the same line (check for duplicate calls to `include`). │ ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. └ ┌ NestedSamplers │ WARNING: Method definition adapt_structure(Any, OffsetArrays.OffsetArray{T, N, AA} where AA<:AbstractArray{T, N} where N where T) in module OffsetArraysAdaptExt at /home/pkgeval/.julia/packages/OffsetArrays/b7qpm/ext/OffsetArraysAdaptExt.jl:9 overwritten in module OffsetArraysAdaptExt on the same line (check for duplicate calls to `include`). │ ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. └ ┌ VLBISkyModels │ ┌ Warning: LLVM.jl has not been tested with LLVM versions newer than 16. │ └ @ LLVM.API ~/.julia/packages/LLVM/bzSzE/src/LLVM.jl:44 │ ┌ Error: LLVM extensions library unavailable for your platform: │ │ x86_64-linux-gnu-libgfortran5-cxx11-llvm_version+19.asserts-julia_version+1.13.0 │ │ LLVM.jl will not be functional. │ │ │ │ If you are using a custom version of LLVM, try building a │ │ custom version of LLVMExtra_jll using `deps/build_local.jl` │ └ @ LLVM ~/.julia/packages/LLVM/bzSzE/src/LLVM.jl:103 │ ┌ Error: LLVM extensions library unavailable for your platform: │ │ x86_64-linux-gnu-libgfortran5-cxx11-llvm_version+19.asserts-julia_version+1.13.0 │ │ LLVM.jl will not be functional. │ │ │ │ If you are using a custom version of LLVM, try building a │ │ custom version of LLVMExtra_jll using `deps/build_local.jl` │ └ @ LLVM ~/.julia/packages/LLVM/bzSzE/src/LLVM.jl:103 │ WARNING: Constructor for type "MethodError" was extended in `GPUCompiler` without explicit qualification or import. │ NOTE: Assumed "MethodError" refers to `Base.MethodError`. This behavior is deprecated and may differ in future versions. │ NOTE: This behavior may have differed in Julia versions prior to 1.12. │ Hint: If you intended to create a new generic function of the same name, use `function MethodError end`. │ Hint: To silence the warning, qualify `MethodError` as `Base.MethodError` in the method signature or explicitly `import Base: MethodError`. │ WARNING: Method definition (::Type{MethodError})(Any, Any) in module Core at boot.jl:446 overwritten in module GPUCompiler at /home/pkgeval/.julia/packages/GPUCompiler/U36Ed/src/jlgen.jl:35. │ ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. └ ┌ Comrade │ WARNING: Detected access to binding `Dimensions.X` in a world prior to its definition world. │ Julia 1.12 has introduced more strict world age semantics for global bindings. │ !!! This code may malfunction under Revise. │ !!! This code will error in future versions of Julia. │ Hint: Add an appropriate `invokelatest` around the access to this binding. │ WARNING: Detected access to binding `Dimensions.Y` in a world prior to its definition world. │ Julia 1.12 has introduced more strict world age semantics for global bindings. │ !!! This code may malfunction under Revise. │ !!! This code will error in future versions of Julia. │ Hint: Add an appropriate `invokelatest` around the access to this binding. │ WARNING: Detected access to binding `Dimensions.Z` in a world prior to its definition world. │ Julia 1.12 has introduced more strict world age semantics for global bindings. │ !!! This code may malfunction under Revise. │ !!! This code will error in future versions of Julia. │ Hint: Add an appropriate `invokelatest` around the access to this binding. │ WARNING: Detected access to binding `DimensionalData.DimStack` in a world prior to its definition world. │ Julia 1.12 has introduced more strict world age semantics for global bindings. │ !!! This code may malfunction under Revise. │ !!! This code will error in future versions of Julia. │ Hint: Add an appropriate `invokelatest` around the access to this binding. │ ┌ Error: LLVM extensions library unavailable for your platform: │ │ x86_64-linux-gnu-libgfortran5-cxx11-llvm_version+19.asserts-julia_version+1.13.0 │ │ LLVM.jl will not be functional. │ │ │ │ If you are using a custom version of LLVM, try building a │ │ custom version of LLVMExtra_jll using `deps/build_local.jl` │ └ @ LLVM ~/.julia/packages/LLVM/bzSzE/src/LLVM.jl:103 │ ┌ Error: LLVM extensions library unavailable for your platform: │ │ x86_64-linux-gnu-libgfortran5-cxx11-llvm_version+19.asserts-julia_version+1.13.0 │ │ LLVM.jl will not be functional. │ │ │ │ If you are using a custom version of LLVM, try building a │ │ custom version of LLVMExtra_jll using `deps/build_local.jl` │ └ @ LLVM ~/.julia/packages/LLVM/bzSzE/src/LLVM.jl:103 │ WARNING: Constructor for type "MethodError" was extended in `GPUCompiler` without explicit qualification or import. │ NOTE: Assumed "MethodError" refers to `Base.MethodError`. This behavior is deprecated and may differ in future versions. │ NOTE: This behavior may have differed in Julia versions prior to 1.12. │ Hint: If you intended to create a new generic function of the same name, use `function MethodError end`. │ Hint: To silence the warning, qualify `MethodError` as `Base.MethodError` in the method signature or explicitly `import Base: MethodError`. │ WARNING: Method definition (::Type{MethodError})(Any, Any) in module Core at boot.jl:446 overwritten in module GPUCompiler at /home/pkgeval/.julia/packages/GPUCompiler/U36Ed/src/jlgen.jl:35. │ ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. └ ┌ Enzyme → EnzymeSpecialFunctionsExt │ ┌ Warning: LLVM.jl has not been tested with LLVM versions newer than 16. │ └ @ LLVM.API ~/.julia/packages/LLVM/bzSzE/src/LLVM.jl:44 │ ┌ Error: LLVM extensions library unavailable for your platform: │ │ x86_64-linux-gnu-libgfortran5-cxx11-llvm_version+19.asserts-julia_version+1.13.0 │ │ LLVM.jl will not be functional. │ │ │ │ If you are using a custom version of LLVM, try building a │ │ custom version of LLVMExtra_jll using `deps/build_local.jl` │ └ @ LLVM ~/.julia/packages/LLVM/bzSzE/src/LLVM.jl:103 │ ┌ Error: LLVM extensions library unavailable for your platform: │ │ x86_64-linux-gnu-libgfortran5-cxx11-llvm_version+19.asserts-julia_version+1.13.0 │ │ LLVM.jl will not be functional. │ │ │ │ If you are using a custom version of LLVM, try building a │ │ custom version of LLVMExtra_jll using `deps/build_local.jl` │ └ @ LLVM ~/.julia/packages/LLVM/bzSzE/src/LLVM.jl:103 │ WARNING: Constructor for type "MethodError" was extended in `GPUCompiler` without explicit qualification or import. │ NOTE: Assumed "MethodError" refers to `Base.MethodError`. This behavior is deprecated and may differ in future versions. │ NOTE: This behavior may have differed in Julia versions prior to 1.12. │ Hint: If you intended to create a new generic function of the same name, use `function MethodError end`. │ Hint: To silence the warning, qualify `MethodError` as `Base.MethodError` in the method signature or explicitly `import Base: MethodError`. │ WARNING: Method definition (::Type{MethodError})(Any, Any) in module Core at boot.jl:446 overwritten in module GPUCompiler at /home/pkgeval/.julia/packages/GPUCompiler/U36Ed/src/jlgen.jl:35. │ ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. └ ┌ ComradeNested │ ┌ Error: LLVM extensions library unavailable for your platform: │ │ x86_64-linux-gnu-libgfortran5-cxx11-llvm_version+19.asserts-julia_version+1.13.0 │ │ LLVM.jl will not be functional. │ │ │ │ If you are using a custom version of LLVM, try building a │ │ custom version of LLVMExtra_jll using `deps/build_local.jl` │ └ @ LLVM ~/.julia/packages/LLVM/bzSzE/src/LLVM.jl:103 │ ┌ Error: LLVM extensions library unavailable for your platform: │ │ x86_64-linux-gnu-libgfortran5-cxx11-llvm_version+19.asserts-julia_version+1.13.0 │ │ LLVM.jl will not be functional. │ │ │ │ If you are using a custom version of LLVM, try building a │ │ custom version of LLVMExtra_jll using `deps/build_local.jl` │ └ @ LLVM ~/.julia/packages/LLVM/bzSzE/src/LLVM.jl:103 │ WARNING: Constructor for type "MethodError" was extended in `GPUCompiler` without explicit qualification or import. │ NOTE: Assumed "MethodError" refers to `Base.MethodError`. This behavior is deprecated and may differ in future versions. │ NOTE: This behavior may have differed in Julia versions prior to 1.12. │ Hint: If you intended to create a new generic function of the same name, use `function MethodError end`. │ Hint: To silence the warning, qualify `MethodError` as `Base.MethodError` in the method signature or explicitly `import Base: MethodError`. │ WARNING: Method definition (::Type{MethodError})(Any, Any) in module Core at boot.jl:446 overwritten in module GPUCompiler at /home/pkgeval/.julia/packages/GPUCompiler/U36Ed/src/jlgen.jl:35. │ ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. └ ┌ Enzyme │ ┌ Error: LLVM extensions library unavailable for your platform: │ │ x86_64-linux-gnu-libgfortran5-cxx11-llvm_version+19.asserts-julia_version+1.13.0 │ │ LLVM.jl will not be functional. │ │ │ │ If you are using a custom version of LLVM, try building a │ │ custom version of LLVMExtra_jll using `deps/build_local.jl` │ └ @ LLVM ~/.julia/packages/LLVM/bzSzE/src/LLVM.jl:103 │ ┌ Error: LLVM extensions library unavailable for your platform: │ │ x86_64-linux-gnu-libgfortran5-cxx11-llvm_version+19.asserts-julia_version+1.13.0 │ │ LLVM.jl will not be functional. │ │ │ │ If you are using a custom version of LLVM, try building a │ │ custom version of LLVMExtra_jll using `deps/build_local.jl` │ └ @ LLVM ~/.julia/packages/LLVM/bzSzE/src/LLVM.jl:103 │ WARNING: Constructor for type "MethodError" was extended in `GPUCompiler` without explicit qualification or import. │ NOTE: Assumed "MethodError" refers to `Base.MethodError`. This behavior is deprecated and may differ in future versions. │ NOTE: This behavior may have differed in Julia versions prior to 1.12. │ Hint: If you intended to create a new generic function of the same name, use `function MethodError end`. │ Hint: To silence the warning, qualify `MethodError` as `Base.MethodError` in the method signature or explicitly `import Base: MethodError`. │ WARNING: Method definition (::Type{MethodError})(Any, Any) in module Core at boot.jl:446 overwritten in module GPUCompiler at /home/pkgeval/.julia/packages/GPUCompiler/U36Ed/src/jlgen.jl:35. │ ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. └ ┌ GPUCompiler │ ┌ Error: LLVM extensions library unavailable for your platform: │ │ x86_64-linux-gnu-libgfortran5-cxx11-llvm_version+19.asserts-julia_version+1.13.0 │ │ LLVM.jl will not be functional. │ │ │ │ If you are using a custom version of LLVM, try building a │ │ custom version of LLVMExtra_jll using `deps/build_local.jl` │ └ @ LLVM ~/.julia/packages/LLVM/bzSzE/src/LLVM.jl:103 │ WARNING: Constructor for type "MethodError" was extended in `GPUCompiler` without explicit qualification or import. │ NOTE: Assumed "MethodError" refers to `Base.MethodError`. This behavior is deprecated and may differ in future versions. │ NOTE: This behavior may have differed in Julia versions prior to 1.12. │ Hint: If you intended to create a new generic function of the same name, use `function MethodError end`. │ Hint: To silence the warning, qualify `MethodError` as `Base.MethodError` in the method signature or explicitly `import Base: MethodError`. │ WARNING: Method definition (::Type{MethodError})(Any, Any) in module Core at boot.jl:446 overwritten in module GPUCompiler at /home/pkgeval/.julia/packages/GPUCompiler/U36Ed/src/jlgen.jl:35. │ ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. └ ┌ MCMCDiagnosticTools │ WARNING: Method definition kwcall(NamedTuple{names, T} where T<:Tuple where names, typeof(Statistics.cov), SparseArrays.SparseMatrixCSC{Tv, Ti} where Ti<:Integer where Tv) in module SparseArraysExt at /home/pkgeval/.julia/packages/Statistics/gbcbG/ext/SparseArraysExt.jl:14 overwritten in module SparseArraysExt on the same line (check for duplicate calls to `include`). │ ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. └ Precompilation completed after 559.94s ################################################################################ # Loading # Loading ComradeNested... Precompiling packages... 10760.8 ms ? GPUCompiler 18697.0 ms ✓ HypercubeTransform 6166.9 ms ✓ MCMCDiagnosticTools 8053.0 ms ✓ VLBILikelihoods 20653.2 ms ? Enzyme 11848.1 ms ✓ MCMCChains 21504.0 ms ? Enzyme → EnzymeSpecialFunctionsExt 12388.1 ms ✓ NestedSamplers 25186.3 ms ? VLBISkyModels 34966.4 ms ? Comrade Info Given ComradeNested was explicitly requested, output will be shown live  ┌ Error: LLVM extensions library unavailable for your platform: │ x86_64-linux-gnu-libgfortran5-cxx11-llvm_version+19.asserts-julia_version+1.13.0 │ LLVM.jl will not be functional. │ │ If you are using a custom version of LLVM, try building a │ custom version of LLVMExtra_jll using `deps/build_local.jl` └ @ LLVM ~/.julia/packages/LLVM/bzSzE/src/LLVM.jl:103 ┌ Error: LLVM extensions library unavailable for your platform: │ x86_64-linux-gnu-libgfortran5-cxx11-llvm_version+19.asserts-julia_version+1.13.0 │ LLVM.jl will not be functional. │ │ If you are using a custom version of LLVM, try building a │ custom version of LLVMExtra_jll using `deps/build_local.jl` └ @ LLVM ~/.julia/packages/LLVM/bzSzE/src/LLVM.jl:103 WARNING: Constructor for type "MethodError" was extended in `GPUCompiler` without explicit qualification or import.  NOTE: Assumed "MethodError" refers to `Base.MethodError`. This behavior is deprecated and may differ in future versions.  NOTE: This behavior may have differed in Julia versions prior to 1.12.  Hint: If you intended to create a new generic function of the same name, use `function MethodError end`.  Hint: To silence the warning, qualify `MethodError` as `Base.MethodError` in the method signature or explicitly `import Base: MethodError`. WARNING: Method definition (::Type{MethodError})(Any, Any) in module Core at boot.jl:446 overwritten in module GPUCompiler at /home/pkgeval/.julia/packages/GPUCompiler/U36Ed/src/jlgen.jl:35. ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. 35816.9 ms ? ComradeNested 5 dependencies successfully precompiled in 210 seconds. 270 already precompiled. 6 dependencies failed but may be precompilable after restarting julia 6 dependencies had output during precompilation: ┌ VLBISkyModels │ ┌ Error: LLVM extensions library unavailable for your platform: │ │ x86_64-linux-gnu-libgfortran5-cxx11-llvm_version+19.asserts-julia_version+1.13.0 │ │ LLVM.jl will not be functional. │ │ │ │ If you are using a custom version of LLVM, try building a │ │ custom version of LLVMExtra_jll using `deps/build_local.jl` │ └ @ LLVM ~/.julia/packages/LLVM/bzSzE/src/LLVM.jl:103 │ ┌ Error: LLVM extensions library unavailable for your platform: │ │ x86_64-linux-gnu-libgfortran5-cxx11-llvm_version+19.asserts-julia_version+1.13.0 │ │ LLVM.jl will not be functional. │ │ │ │ If you are using a custom version of LLVM, try building a │ │ custom version of LLVMExtra_jll using `deps/build_local.jl` │ └ @ LLVM ~/.julia/packages/LLVM/bzSzE/src/LLVM.jl:103 │ WARNING: Constructor for type "MethodError" was extended in `GPUCompiler` without explicit qualification or import. │ NOTE: Assumed "MethodError" refers to `Base.MethodError`. This behavior is deprecated and may differ in future versions. │ NOTE: This behavior may have differed in Julia versions prior to 1.12. │ Hint: If you intended to create a new generic function of the same name, use `function MethodError end`. │ Hint: To silence the warning, qualify `MethodError` as `Base.MethodError` in the method signature or explicitly `import Base: MethodError`. │ WARNING: Method definition (::Type{MethodError})(Any, Any) in module Core at boot.jl:446 overwritten in module GPUCompiler at /home/pkgeval/.julia/packages/GPUCompiler/U36Ed/src/jlgen.jl:35. │ ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. └ ┌ Comrade │ ┌ Error: LLVM extensions library unavailable for your platform: │ │ x86_64-linux-gnu-libgfortran5-cxx11-llvm_version+19.asserts-julia_version+1.13.0 │ │ LLVM.jl will not be functional. │ │ │ │ If you are using a custom version of LLVM, try building a │ │ custom version of LLVMExtra_jll using `deps/build_local.jl` │ └ @ LLVM ~/.julia/packages/LLVM/bzSzE/src/LLVM.jl:103 │ ┌ Error: LLVM extensions library unavailable for your platform: │ │ x86_64-linux-gnu-libgfortran5-cxx11-llvm_version+19.asserts-julia_version+1.13.0 │ │ LLVM.jl will not be functional. │ │ │ │ If you are using a custom version of LLVM, try building a │ │ custom version of LLVMExtra_jll using `deps/build_local.jl` │ └ @ LLVM ~/.julia/packages/LLVM/bzSzE/src/LLVM.jl:103 │ WARNING: Constructor for type "MethodError" was extended in `GPUCompiler` without explicit qualification or import. │ NOTE: Assumed "MethodError" refers to `Base.MethodError`. This behavior is deprecated and may differ in future versions. │ NOTE: This behavior may have differed in Julia versions prior to 1.12. │ Hint: If you intended to create a new generic function of the same name, use `function MethodError end`. │ Hint: To silence the warning, qualify `MethodError` as `Base.MethodError` in the method signature or explicitly `import Base: MethodError`. │ WARNING: Method definition (::Type{MethodError})(Any, Any) in module Core at boot.jl:446 overwritten in module GPUCompiler at /home/pkgeval/.julia/packages/GPUCompiler/U36Ed/src/jlgen.jl:35. │ ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. └ ┌ Enzyme → EnzymeSpecialFunctionsExt │ ┌ Error: LLVM extensions library unavailable for your platform: │ │ x86_64-linux-gnu-libgfortran5-cxx11-llvm_version+19.asserts-julia_version+1.13.0 │ │ LLVM.jl will not be functional. │ │ │ │ If you are using a custom version of LLVM, try building a │ │ custom version of LLVMExtra_jll using `deps/build_local.jl` │ └ @ LLVM ~/.julia/packages/LLVM/bzSzE/src/LLVM.jl:103 │ ┌ Error: LLVM extensions library unavailable for your platform: │ │ x86_64-linux-gnu-libgfortran5-cxx11-llvm_version+19.asserts-julia_version+1.13.0 │ │ LLVM.jl will not be functional. │ │ │ │ If you are using a custom version of LLVM, try building a │ │ custom version of LLVMExtra_jll using `deps/build_local.jl` │ └ @ LLVM ~/.julia/packages/LLVM/bzSzE/src/LLVM.jl:103 │ WARNING: Constructor for type "MethodError" was extended in `GPUCompiler` without explicit qualification or import. │ NOTE: Assumed "MethodError" refers to `Base.MethodError`. This behavior is deprecated and may differ in future versions. │ NOTE: This behavior may have differed in Julia versions prior to 1.12. │ Hint: If you intended to create a new generic function of the same name, use `function MethodError end`. │ Hint: To silence the warning, qualify `MethodError` as `Base.MethodError` in the method signature or explicitly `import Base: MethodError`. │ WARNING: Method definition (::Type{MethodError})(Any, Any) in module Core at boot.jl:446 overwritten in module GPUCompiler at /home/pkgeval/.julia/packages/GPUCompiler/U36Ed/src/jlgen.jl:35. │ ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. └ ┌ ComradeNested │ [Output was shown above] └ ┌ Enzyme │ ┌ Error: LLVM extensions library unavailable for your platform: │ │ x86_64-linux-gnu-libgfortran5-cxx11-llvm_version+19.asserts-julia_version+1.13.0 │ │ LLVM.jl will not be functional. │ │ │ │ If you are using a custom version of LLVM, try building a │ │ custom version of LLVMExtra_jll using `deps/build_local.jl` │ └ @ LLVM ~/.julia/packages/LLVM/bzSzE/src/LLVM.jl:103 │ ┌ Error: LLVM extensions library unavailable for your platform: │ │ x86_64-linux-gnu-libgfortran5-cxx11-llvm_version+19.asserts-julia_version+1.13.0 │ │ LLVM.jl will not be functional. │ │ │ │ If you are using a custom version of LLVM, try building a │ │ custom version of LLVMExtra_jll using `deps/build_local.jl` │ └ @ LLVM ~/.julia/packages/LLVM/bzSzE/src/LLVM.jl:103 │ WARNING: Constructor for type "MethodError" was extended in `GPUCompiler` without explicit qualification or import. │ NOTE: Assumed "MethodError" refers to `Base.MethodError`. This behavior is deprecated and may differ in future versions. │ NOTE: This behavior may have differed in Julia versions prior to 1.12. │ Hint: If you intended to create a new generic function of the same name, use `function MethodError end`. │ Hint: To silence the warning, qualify `MethodError` as `Base.MethodError` in the method signature or explicitly `import Base: MethodError`. │ WARNING: Method definition (::Type{MethodError})(Any, Any) in module Core at boot.jl:446 overwritten in module GPUCompiler at /home/pkgeval/.julia/packages/GPUCompiler/U36Ed/src/jlgen.jl:35. │ ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. └ ┌ GPUCompiler │ ┌ Error: LLVM extensions library unavailable for your platform: │ │ x86_64-linux-gnu-libgfortran5-cxx11-llvm_version+19.asserts-julia_version+1.13.0 │ │ LLVM.jl will not be functional. │ │ │ │ If you are using a custom version of LLVM, try building a │ │ custom version of LLVMExtra_jll using `deps/build_local.jl` │ └ @ LLVM ~/.julia/packages/LLVM/bzSzE/src/LLVM.jl:103 │ WARNING: Constructor for type "MethodError" was extended in `GPUCompiler` without explicit qualification or import. │ NOTE: Assumed "MethodError" refers to `Base.MethodError`. This behavior is deprecated and may differ in future versions. │ NOTE: This behavior may have differed in Julia versions prior to 1.12. │ Hint: If you intended to create a new generic function of the same name, use `function MethodError end`. │ Hint: To silence the warning, qualify `MethodError` as `Base.MethodError` in the method signature or explicitly `import Base: MethodError`. │ WARNING: Method definition (::Type{MethodError})(Any, Any) in module Core at boot.jl:446 overwritten in module GPUCompiler at /home/pkgeval/.julia/packages/GPUCompiler/U36Ed/src/jlgen.jl:35. │ ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. └ ┌ Error: LLVM extensions library unavailable for your platform: │ x86_64-linux-gnu-libgfortran5-cxx11-llvm_version+19.asserts-julia_version+1.13.0 │ LLVM.jl will not be functional. │ │ If you are using a custom version of LLVM, try building a │ custom version of LLVMExtra_jll using `deps/build_local.jl` └ @ LLVM ~/.julia/packages/LLVM/bzSzE/src/LLVM.jl:103 ┌ Error: LLVM extensions library unavailable for your platform: │ x86_64-linux-gnu-libgfortran5-cxx11-llvm_version+19.asserts-julia_version+1.13.0 │ LLVM.jl will not be functional. │ │ If you are using a custom version of LLVM, try building a │ custom version of LLVMExtra_jll using `deps/build_local.jl` └ @ LLVM ~/.julia/packages/LLVM/bzSzE/src/LLVM.jl:103 WARNING: Constructor for type "MethodError" was extended in `GPUCompiler` without explicit qualification or import. NOTE: Assumed "MethodError" refers to `Base.MethodError`. This behavior is deprecated and may differ in future versions. NOTE: This behavior may have differed in Julia versions prior to 1.12. Hint: If you intended to create a new generic function of the same name, use `function MethodError end`. Hint: To silence the warning, qualify `MethodError` as `Base.MethodError` in the method signature or explicitly `import Base: MethodError`. WARNING: Method definition (::Type{MethodError})(Any, Any) in module Core at boot.jl:446 overwritten in module GPUCompiler at /home/pkgeval/.julia/packages/GPUCompiler/U36Ed/src/jlgen.jl:35. ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. Precompiling packages... 10405.7 ms ? GPUCompiler 19714.9 ms ? Enzyme 20659.6 ms ? Enzyme → EnzymeSpecialFunctionsExt 24123.2 ms ? VLBISkyModels Info Given Comrade was explicitly requested, output will be shown live  ┌ Error: LLVM extensions library unavailable for your platform: │ x86_64-linux-gnu-libgfortran5-cxx11-llvm_version+19.asserts-julia_version+1.13.0 │ LLVM.jl will not be functional. │ │ If you are using a custom version of LLVM, try building a │ custom version of LLVMExtra_jll using `deps/build_local.jl` └ @ LLVM ~/.julia/packages/LLVM/bzSzE/src/LLVM.jl:103 ┌ Error: LLVM extensions library unavailable for your platform: │ x86_64-linux-gnu-libgfortran5-cxx11-llvm_version+19.asserts-julia_version+1.13.0 │ LLVM.jl will not be functional. │ │ If you are using a custom version of LLVM, try building a │ custom version of LLVMExtra_jll using `deps/build_local.jl` └ @ LLVM ~/.julia/packages/LLVM/bzSzE/src/LLVM.jl:103 WARNING: Constructor for type "MethodError" was extended in `GPUCompiler` without explicit qualification or import.  NOTE: Assumed "MethodError" refers to `Base.MethodError`. This behavior is deprecated and may differ in future versions.  NOTE: This behavior may have differed in Julia versions prior to 1.12.  Hint: If you intended to create a new generic function of the same name, use `function MethodError end`.  Hint: To silence the warning, qualify `MethodError` as `Base.MethodError` in the method signature or explicitly `import Base: MethodError`. WARNING: Method definition (::Type{MethodError})(Any, Any) in module Core at boot.jl:446 overwritten in module GPUCompiler at /home/pkgeval/.julia/packages/GPUCompiler/U36Ed/src/jlgen.jl:35. ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. 35652.4 ms ? Comrade ┌ Error: LLVM extensions library unavailable for your platform: │ x86_64-linux-gnu-libgfortran5-cxx11-llvm_version+19.asserts-julia_version+1.13.0 │ LLVM.jl will not be functional. │ │ If you are using a custom version of LLVM, try building a │ custom version of LLVMExtra_jll using `deps/build_local.jl` └ @ LLVM ~/.julia/packages/LLVM/bzSzE/src/LLVM.jl:103 ┌ Error: LLVM extensions library unavailable for your platform: │ x86_64-linux-gnu-libgfortran5-cxx11-llvm_version+19.asserts-julia_version+1.13.0 │ LLVM.jl will not be functional. │ │ If you are using a custom version of LLVM, try building a │ custom version of LLVMExtra_jll using `deps/build_local.jl` └ @ LLVM ~/.julia/packages/LLVM/bzSzE/src/LLVM.jl:103 WARNING: Constructor for type "MethodError" was extended in `GPUCompiler` without explicit qualification or import. NOTE: Assumed "MethodError" refers to `Base.MethodError`. This behavior is deprecated and may differ in future versions. NOTE: This behavior may have differed in Julia versions prior to 1.12. Hint: If you intended to create a new generic function of the same name, use `function MethodError end`. Hint: To silence the warning, qualify `MethodError` as `Base.MethodError` in the method signature or explicitly `import Base: MethodError`. WARNING: Method definition (::Type{MethodError})(Any, Any) in module Core at boot.jl:446 overwritten in module GPUCompiler at /home/pkgeval/.julia/packages/GPUCompiler/U36Ed/src/jlgen.jl:35. ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. Precompiling packages... 6271.1 ms ✓ Accessors → IntervalSetsExt 9302.7 ms ✓ StaticArrayInterface 15596.6 ms ✓ FLoops 10650.6 ms ? GPUCompiler 1954.4 ms ✓ StaticArrayInterface → StaticArrayInterfaceStaticArraysExt 1322.5 ms ✓ StaticArrayInterface → StaticArrayInterfaceOffsetArraysExt 1315.4 ms ✓ CloseOpenIntervals 1507.6 ms ✓ LayoutPointers 34221.7 ms ✓ NFFT 20007.4 ms ? Enzyme 2306.1 ms ✓ StrideArraysCore 21208.5 ms ? Enzyme → EnzymeSpecialFunctionsExt 2946.5 ms ✓ Polyester 2861.7 ms ✓ FastBroadcast Info Given VLBISkyModels was explicitly requested, output will be shown live  ┌ Error: LLVM extensions library unavailable for your platform: │ x86_64-linux-gnu-libgfortran5-cxx11-llvm_version+19.asserts-julia_version+1.13.0 │ LLVM.jl will not be functional. │ │ If you are using a custom version of LLVM, try building a │ custom version of LLVMExtra_jll using `deps/build_local.jl` └ @ LLVM ~/.julia/packages/LLVM/bzSzE/src/LLVM.jl:103 ┌ Error: LLVM extensions library unavailable for your platform: │ x86_64-linux-gnu-libgfortran5-cxx11-llvm_version+19.asserts-julia_version+1.13.0 │ LLVM.jl will not be functional. │ │ If you are using a custom version of LLVM, try building a │ custom version of LLVMExtra_jll using `deps/build_local.jl` └ @ LLVM ~/.julia/packages/LLVM/bzSzE/src/LLVM.jl:103 WARNING: Constructor for type "MethodError" was extended in `GPUCompiler` without explicit qualification or import.  NOTE: Assumed "MethodError" refers to `Base.MethodError`. This behavior is deprecated and may differ in future versions.  NOTE: This behavior may have differed in Julia versions prior to 1.12.  Hint: If you intended to create a new generic function of the same name, use `function MethodError end`.  Hint: To silence the warning, qualify `MethodError` as `Base.MethodError` in the method signature or explicitly `import Base: MethodError`. WARNING: Method definition (::Type{MethodError})(Any, Any) in module Core at boot.jl:446 overwritten in module GPUCompiler at /home/pkgeval/.julia/packages/GPUCompiler/U36Ed/src/jlgen.jl:35. ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. 24651.2 ms ? VLBISkyModels 11 dependencies successfully precompiled in 157 seconds. 168 already precompiled. 4 dependencies failed but may be precompilable after restarting julia 4 dependencies had output during precompilation: ┌ VLBISkyModels │ [Output was shown above] └ ┌ Enzyme → EnzymeSpecialFunctionsExt │ ┌ Error: LLVM extensions library unavailable for your platform: │ │ x86_64-linux-gnu-libgfortran5-cxx11-llvm_version+19.asserts-julia_version+1.13.0 │ │ LLVM.jl will not be functional. │ │ │ │ If you are using a custom version of LLVM, try building a │ │ custom version of LLVMExtra_jll using `deps/build_local.jl` │ └ @ LLVM ~/.julia/packages/LLVM/bzSzE/src/LLVM.jl:103 │ ┌ Error: LLVM extensions library unavailable for your platform: │ │ x86_64-linux-gnu-libgfortran5-cxx11-llvm_version+19.asserts-julia_version+1.13.0 │ │ LLVM.jl will not be functional. │ │ │ │ If you are using a custom version of LLVM, try building a │ │ custom version of LLVMExtra_jll using `deps/build_local.jl` │ └ @ LLVM ~/.julia/packages/LLVM/bzSzE/src/LLVM.jl:103 │ WARNING: Constructor for type "MethodError" was extended in `GPUCompiler` without explicit qualification or import. │ NOTE: Assumed "MethodError" refers to `Base.MethodError`. This behavior is deprecated and may differ in future versions. │ NOTE: This behavior may have differed in Julia versions prior to 1.12. │ Hint: If you intended to create a new generic function of the same name, use `function MethodError end`. │ Hint: To silence the warning, qualify `MethodError` as `Base.MethodError` in the method signature or explicitly `import Base: MethodError`. │ WARNING: Method definition (::Type{MethodError})(Any, Any) in module Core at boot.jl:446 overwritten in module GPUCompiler at /home/pkgeval/.julia/packages/GPUCompiler/U36Ed/src/jlgen.jl:35. │ ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. └ ┌ Enzyme │ ┌ Error: LLVM extensions library unavailable for your platform: │ │ x86_64-linux-gnu-libgfortran5-cxx11-llvm_version+19.asserts-julia_version+1.13.0 │ │ LLVM.jl will not be functional. │ │ │ │ If you are using a custom version of LLVM, try building a │ │ custom version of LLVMExtra_jll using `deps/build_local.jl` │ └ @ LLVM ~/.julia/packages/LLVM/bzSzE/src/LLVM.jl:103 │ ┌ Error: LLVM extensions library unavailable for your platform: │ │ x86_64-linux-gnu-libgfortran5-cxx11-llvm_version+19.asserts-julia_version+1.13.0 │ │ LLVM.jl will not be functional. │ │ │ │ If you are using a custom version of LLVM, try building a │ │ custom version of LLVMExtra_jll using `deps/build_local.jl` │ └ @ LLVM ~/.julia/packages/LLVM/bzSzE/src/LLVM.jl:103 │ WARNING: Constructor for type "MethodError" was extended in `GPUCompiler` without explicit qualification or import. │ NOTE: Assumed "MethodError" refers to `Base.MethodError`. This behavior is deprecated and may differ in future versions. │ NOTE: This behavior may have differed in Julia versions prior to 1.12. │ Hint: If you intended to create a new generic function of the same name, use `function MethodError end`. │ Hint: To silence the warning, qualify `MethodError` as `Base.MethodError` in the method signature or explicitly `import Base: MethodError`. │ WARNING: Method definition (::Type{MethodError})(Any, Any) in module Core at boot.jl:446 overwritten in module GPUCompiler at /home/pkgeval/.julia/packages/GPUCompiler/U36Ed/src/jlgen.jl:35. │ ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. └ ┌ GPUCompiler │ ┌ Error: LLVM extensions library unavailable for your platform: │ │ x86_64-linux-gnu-libgfortran5-cxx11-llvm_version+19.asserts-julia_version+1.13.0 │ │ LLVM.jl will not be functional. │ │ │ │ If you are using a custom version of LLVM, try building a │ │ custom version of LLVMExtra_jll using `deps/build_local.jl` │ └ @ LLVM ~/.julia/packages/LLVM/bzSzE/src/LLVM.jl:103 │ WARNING: Constructor for type "MethodError" was extended in `GPUCompiler` without explicit qualification or import. │ NOTE: Assumed "MethodError" refers to `Base.MethodError`. This behavior is deprecated and may differ in future versions. │ NOTE: This behavior may have differed in Julia versions prior to 1.12. │ Hint: If you intended to create a new generic function of the same name, use `function MethodError end`. │ Hint: To silence the warning, qualify `MethodError` as `Base.MethodError` in the method signature or explicitly `import Base: MethodError`. │ WARNING: Method definition (::Type{MethodError})(Any, Any) in module Core at boot.jl:446 overwritten in module GPUCompiler at /home/pkgeval/.julia/packages/GPUCompiler/U36Ed/src/jlgen.jl:35. │ ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. └ ┌ Error: LLVM extensions library unavailable for your platform: │ x86_64-linux-gnu-libgfortran5-cxx11-llvm_version+19.asserts-julia_version+1.13.0 │ LLVM.jl will not be functional. │ │ If you are using a custom version of LLVM, try building a │ custom version of LLVMExtra_jll using `deps/build_local.jl` └ @ LLVM ~/.julia/packages/LLVM/bzSzE/src/LLVM.jl:103 ┌ Error: LLVM extensions library unavailable for your platform: │ x86_64-linux-gnu-libgfortran5-cxx11-llvm_version+19.asserts-julia_version+1.13.0 │ LLVM.jl will not be functional. │ │ If you are using a custom version of LLVM, try building a │ custom version of LLVMExtra_jll using `deps/build_local.jl` └ @ LLVM ~/.julia/packages/LLVM/bzSzE/src/LLVM.jl:103 WARNING: Constructor for type "MethodError" was extended in `GPUCompiler` without explicit qualification or import. NOTE: Assumed "MethodError" refers to `Base.MethodError`. This behavior is deprecated and may differ in future versions. NOTE: This behavior may have differed in Julia versions prior to 1.12. Hint: If you intended to create a new generic function of the same name, use `function MethodError end`. Hint: To silence the warning, qualify `MethodError` as `Base.MethodError` in the method signature or explicitly `import Base: MethodError`. WARNING: Method definition (::Type{MethodError})(Any, Any) in module Core at boot.jl:446 overwritten in module GPUCompiler at /home/pkgeval/.julia/packages/GPUCompiler/U36Ed/src/jlgen.jl:35. ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. Precompiling packages... 14426.5 ms ? GPUCompiler Info Given Enzyme was explicitly requested, output will be shown live  ┌ Error: LLVM extensions library unavailable for your platform: │ x86_64-linux-gnu-libgfortran5-cxx11-llvm_version+19.asserts-julia_version+1.13.0 │ LLVM.jl will not be functional. │ │ If you are using a custom version of LLVM, try building a │ custom version of LLVMExtra_jll using `deps/build_local.jl` └ @ LLVM ~/.julia/packages/LLVM/bzSzE/src/LLVM.jl:103 ┌ Error: LLVM extensions library unavailable for your platform: │ x86_64-linux-gnu-libgfortran5-cxx11-llvm_version+19.asserts-julia_version+1.13.0 │ LLVM.jl will not be functional. │ │ If you are using a custom version of LLVM, try building a │ custom version of LLVMExtra_jll using `deps/build_local.jl` └ @ LLVM ~/.julia/packages/LLVM/bzSzE/src/LLVM.jl:103 WARNING: Constructor for type "MethodError" was extended in `GPUCompiler` without explicit qualification or import.  NOTE: Assumed "MethodError" refers to `Base.MethodError`. This behavior is deprecated and may differ in future versions.  NOTE: This behavior may have differed in Julia versions prior to 1.12.  Hint: If you intended to create a new generic function of the same name, use `function MethodError end`.  Hint: To silence the warning, qualify `MethodError` as `Base.MethodError` in the method signature or explicitly `import Base: MethodError`. WARNING: Method definition (::Type{MethodError})(Any, Any) in module Core at boot.jl:446 overwritten in module GPUCompiler at /home/pkgeval/.julia/packages/GPUCompiler/U36Ed/src/jlgen.jl:35. ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. 20355.6 ms ? Enzyme ┌ Error: LLVM extensions library unavailable for your platform: │ x86_64-linux-gnu-libgfortran5-cxx11-llvm_version+19.asserts-julia_version+1.13.0 │ LLVM.jl will not be functional. │ │ If you are using a custom version of LLVM, try building a │ custom version of LLVMExtra_jll using `deps/build_local.jl` └ @ LLVM ~/.julia/packages/LLVM/bzSzE/src/LLVM.jl:103 ┌ Error: LLVM extensions library unavailable for your platform: │ x86_64-linux-gnu-libgfortran5-cxx11-llvm_version+19.asserts-julia_version+1.13.0 │ LLVM.jl will not be functional. │ │ If you are using a custom version of LLVM, try building a │ custom version of LLVMExtra_jll using `deps/build_local.jl` └ @ LLVM ~/.julia/packages/LLVM/bzSzE/src/LLVM.jl:103 WARNING: Constructor for type "MethodError" was extended in `GPUCompiler` without explicit qualification or import. NOTE: Assumed "MethodError" refers to `Base.MethodError`. This behavior is deprecated and may differ in future versions. NOTE: This behavior may have differed in Julia versions prior to 1.12. Hint: If you intended to create a new generic function of the same name, use `function MethodError end`. Hint: To silence the warning, qualify `MethodError` as `Base.MethodError` in the method signature or explicitly `import Base: MethodError`. WARNING: Method definition (::Type{MethodError})(Any, Any) in module Core at boot.jl:446 overwritten in module GPUCompiler at /home/pkgeval/.julia/packages/GPUCompiler/U36Ed/src/jlgen.jl:35. ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. ┌ Error: LLVM extensions library unavailable for your platform: │ x86_64-linux-gnu-libgfortran5-cxx11-llvm_version+19.asserts-julia_version+1.13.0 │ LLVM.jl will not be functional. │ │ If you are using a custom version of LLVM, try building a │ custom version of LLVMExtra_jll using `deps/build_local.jl` └ @ LLVM ~/.julia/packages/LLVM/bzSzE/src/LLVM.jl:103 Precompiling packages... Info Given GPUCompiler was explicitly requested, output will be shown live  ┌ Error: LLVM extensions library unavailable for your platform: │ x86_64-linux-gnu-libgfortran5-cxx11-llvm_version+19.asserts-julia_version+1.13.0 │ LLVM.jl will not be functional. │ │ If you are using a custom version of LLVM, try building a │ custom version of LLVMExtra_jll using `deps/build_local.jl` └ @ LLVM ~/.julia/packages/LLVM/bzSzE/src/LLVM.jl:103 WARNING: Constructor for type "MethodError" was extended in `GPUCompiler` without explicit qualification or import.  NOTE: Assumed "MethodError" refers to `Base.MethodError`. This behavior is deprecated and may differ in future versions.  NOTE: This behavior may have differed in Julia versions prior to 1.12.  Hint: If you intended to create a new generic function of the same name, use `function MethodError end`.  Hint: To silence the warning, qualify `MethodError` as `Base.MethodError` in the method signature or explicitly `import Base: MethodError`. WARNING: Method definition (::Type{MethodError})(Any, Any) in module Core at boot.jl:446 overwritten in module GPUCompiler at /home/pkgeval/.julia/packages/GPUCompiler/U36Ed/src/jlgen.jl:35. ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. 10599.9 ms ? GPUCompiler ┌ Error: LLVM extensions library unavailable for your platform: │ x86_64-linux-gnu-libgfortran5-cxx11-llvm_version+19.asserts-julia_version+1.13.0 │ LLVM.jl will not be functional. │ │ If you are using a custom version of LLVM, try building a │ custom version of LLVMExtra_jll using `deps/build_local.jl` └ @ LLVM ~/.julia/packages/LLVM/bzSzE/src/LLVM.jl:103 WARNING: Constructor for type "MethodError" was extended in `GPUCompiler` without explicit qualification or import. NOTE: Assumed "MethodError" refers to `Base.MethodError`. This behavior is deprecated and may differ in future versions. NOTE: This behavior may have differed in Julia versions prior to 1.12. Hint: If you intended to create a new generic function of the same name, use `function MethodError end`. Hint: To silence the warning, qualify `MethodError` as `Base.MethodError` in the method signature or explicitly `import Base: MethodError`. WARNING: Method definition (::Type{MethodError})(Any, Any) in module Core at boot.jl:446 overwritten in module GPUCompiler at /home/pkgeval/.julia/packages/GPUCompiler/U36Ed/src/jlgen.jl:35. ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. WARNING: Constructor for type "MethodError" was extended in `GPUCompiler` without explicit qualification or import. NOTE: Assumed "MethodError" refers to `Base.MethodError`. This behavior is deprecated and may differ in future versions. NOTE: This behavior may have differed in Julia versions prior to 1.12. Hint: If you intended to create a new generic function of the same name, use `function MethodError end`. Hint: To silence the warning, qualify `MethodError` as `Base.MethodError` in the method signature or explicitly `import Base: MethodError`. ERROR: LoadError: UndefVarError: `verbose_stmt_info` not defined in `Compiler` Suggestion: check for spelling errors or missing imports. Stacktrace: [1] getproperty(x::Module, f::Symbol) @ Base ./Base_compiler.jl:47 [2] top-level scope @ ~/.julia/packages/GPUCompiler/U36Ed/src/jlgen.jl:308 [3] include(mapexpr::Function, mod::Module, _path::String) @ Base ./Base.jl:304 [4] top-level scope @ ~/.julia/packages/GPUCompiler/U36Ed/src/GPUCompiler.jl:35 [5] include(mod::Module, _path::String) @ Base ./Base.jl:303 [6] __require_prelocked(pkg::Base.PkgId, env::String) @ Base ./loading.jl:2690 [7] _require_prelocked(uuidkey::Base.PkgId, env::String) @ Base ./loading.jl:2465 [8] macro expansion @ ./loading.jl:2393 [inlined] [9] macro expansion @ ./lock.jl:376 [inlined] [10] __require(into::Module, mod::Symbol) @ Base ./loading.jl:2358 [11] require(into::Module, mod::Symbol) @ Base ./loading.jl:2334 [12] include(mapexpr::Function, mod::Module, _path::String) @ Base ./Base.jl:304 [13] top-level scope @ ~/.julia/packages/Enzyme/l4FS0/src/Enzyme.jl:43 [14] include(mod::Module, _path::String) @ Base ./Base.jl:303 [15] __require_prelocked(pkg::Base.PkgId, env::String) @ Base ./loading.jl:2690 [16] _require_prelocked(uuidkey::Base.PkgId, env::String) @ Base ./loading.jl:2465 [17] macro expansion @ ./loading.jl:2393 [inlined] [18] macro expansion @ ./lock.jl:376 [inlined] [19] __require(into::Module, mod::Symbol) @ Base ./loading.jl:2358 [20] require(into::Module, mod::Symbol) @ Base ./loading.jl:2334 [21] top-level scope @ ~/.julia/packages/VLBISkyModels/vjjXZ/src/VLBISkyModels.jl:11 [22] include(mod::Module, _path::String) @ Base ./Base.jl:303 [23] __require_prelocked(pkg::Base.PkgId, env::String) @ Base ./loading.jl:2690 [24] _require_prelocked(uuidkey::Base.PkgId, env::String) @ Base ./loading.jl:2465 [25] macro expansion @ ./loading.jl:2393 [inlined] [26] macro expansion @ ./lock.jl:376 [inlined] [27] __require(into::Module, mod::Symbol) @ Base ./loading.jl:2358 [28] require(into::Module, mod::Symbol) @ Base ./loading.jl:2334 [29] include(mod::Module, _path::String) @ Base ./Base.jl:303 [30] __require_prelocked(pkg::Base.PkgId, env::String) @ Base ./loading.jl:2690 [31] _require_prelocked(uuidkey::Base.PkgId, env::String) @ Base ./loading.jl:2465 [32] macro expansion @ ./loading.jl:2393 [inlined] [33] macro expansion @ ./lock.jl:376 [inlined] [34] __require(into::Module, mod::Symbol) @ Base ./loading.jl:2358 [35] require(into::Module, mod::Symbol) @ Base ./loading.jl:2334 [36] top-level scope @ ~/.julia/packages/ComradeNested/Thblw/src/ComradeNested.jl:3 [37] include(mod::Module, _path::String) @ Base ./Base.jl:303 [38] __require_prelocked(pkg::Base.PkgId, env::String) @ Base ./loading.jl:2690 [39] _require_prelocked(uuidkey::Base.PkgId, env::String) @ Base ./loading.jl:2465 [40] macro expansion @ ./loading.jl:2393 [inlined] [41] macro expansion @ ./lock.jl:376 [inlined] [42] __require(into::Module, mod::Symbol) @ Base ./loading.jl:2358 [43] require(into::Module, mod::Symbol) @ Base ./loading.jl:2334 [44] eval(m::Module, e::Any) @ Core ./boot.jl:489 [45] exec_options(opts::Base.JLOptions) @ Base ./client.jl:297 [46] _start() @ Base ./client.jl:563 in expression starting at /home/pkgeval/.julia/packages/GPUCompiler/U36Ed/src/jlgen.jl:308 in expression starting at /home/pkgeval/.julia/packages/GPUCompiler/U36Ed/src/GPUCompiler.jl:1 in expression starting at /home/pkgeval/.julia/packages/Enzyme/l4FS0/src/typetree.jl:6 in expression starting at /home/pkgeval/.julia/packages/Enzyme/l4FS0/src/Enzyme.jl:1 in expression starting at /home/pkgeval/.julia/packages/VLBISkyModels/vjjXZ/src/VLBISkyModels.jl:1 in expression starting at /home/pkgeval/.julia/packages/Comrade/cqv1l/src/Comrade.jl:1 in expression starting at /home/pkgeval/.julia/packages/ComradeNested/Thblw/src/ComradeNested.jl:1 Loading failed after 694.85s ERROR: LoadError: failed process: Process(`/opt/julia/bin/julia -C native -J/opt/julia/lib/julia/sys.so -g1 --check-bounds=yes --inline=yes --pkgimages=existing -e 'using ComradeNested'`, ProcessExited(1)) [1] Stacktrace: [1] pipeline_error @ ./process.jl:602 [inlined] [2] run(::Cmd; wait::Bool) @ Base ./process.jl:517 [3] run(::Cmd) @ Base ./process.jl:514 [4] top-level scope @ /PkgEval.jl/scripts/evaluate.jl:193 [5] include(mod::Module, _path::String) @ Base ./Base.jl:303 [6] exec_options(opts::Base.JLOptions) @ Base ./client.jl:331 [7] _start() @ Base ./client.jl:563 in expression starting at /PkgEval.jl/scripts/evaluate.jl:184 PkgEval failed after 1291.76s: illegal method overwrites during precompilation