Package evaluation of GPDiffEq on Julia 1.13.0-DEV.464 (abc56fde89*) started at 2025-05-02T03:15:54.687 ################################################################################ # Set-up # Set-up completed after 0.2s ################################################################################ # Installation # Installing GPDiffEq... Resolving package versions... Updating `~/.julia/environments/v1.13/Project.toml` [4de859cf] + GPDiffEq v0.1.0 Updating `~/.julia/environments/v1.13/Manifest.toml` ⌅ [47edcb42] + ADTypes v0.2.7 [99985d1d] + AbstractGPs v0.5.24 [1520ce14] + AbstractTrees v0.4.5 [7d9f7c33] + Accessors v0.1.42 ⌅ [79e6a3ab] + Adapt v3.7.2 [66dad0bd] + AliasTables v1.1.3 [298c2ebc] + ApproximateGPs v0.4.5 [ec485272] + ArnoldiMethod v0.4.0 ⌃ [4fba245c] + ArrayInterface v7.7.1 ⌃ [13072b0f] + AxisAlgorithms v1.0.1 [62783981] + BitTwiddlingConvenienceFunctions v0.1.6 [fa961155] + CEnum v0.5.0 [2a0fbf3d] + CPUSummary v0.2.6 [d360d2e6] + ChainRulesCore v1.25.1 [fb6a15b2] + CloseOpenIntervals v0.1.13 [38540f10] + CommonSolve v0.2.4 [bbf7d656] + CommonSubexpressions v0.3.1 [34da2185] + Compat v4.16.0 [a33af91c] + CompositionsBase v0.1.2 [2569d6c7] + ConcreteStructs v0.2.3 [88cd18e8] + ConsoleProgressMonitor v0.1.2 [187b0558] + ConstructionBase v1.5.8 [adafc99b] + CpuId v0.3.1 [9a962f9c] + DataAPI v1.16.0 [864edb3b] + DataStructures v0.18.22 [e2d170a0] + DataValueInterfaces v1.0.0 ⌃ [2b5f629d] + DiffEqBase v6.130.0 [163ba53b] + DiffResults v1.1.0 [b552c78f] + DiffRules v1.15.1 [b4f34e82] + Distances v0.10.12 [31c24e10] + Distributions v0.25.119 [ffbed154] + DocStringExtensions v0.9.4 [4e289a0a] + EnumX v1.0.5 ⌅ [7da242da] + Enzyme v0.11.20 ⌅ [f151be2c] + EnzymeCore v0.6.6 [d4d017d3] + ExponentialUtilities v1.27.0 [e2ba6199] + ExprTools v0.1.10 ⌅ [7034ab61] + FastBroadcast v0.2.8 [9aa1b823] + FastClosures v0.3.2 ⌅ [442a2c76] + FastGaussQuadrature v0.5.1 [29a986be] + FastLapackInterface v2.0.4 [1a297f60] + FillArrays v1.13.0 [6a86dc24] + FiniteDiff v2.27.0 ⌅ [f6369f11] + ForwardDiff v0.10.38 [069b7b12] + FunctionWrappers v1.1.3 [77dc65aa] + FunctionWrappersWrappers v0.1.3 ⌅ [d9f16b24] + Functors v0.4.12 [4de859cf] + GPDiffEq v0.1.0 [6031954c] + GPLikelihoods v0.4.7 ⌅ [46192b85] + GPUArraysCore v0.1.5 ⌅ [61eb1bfa] + GPUCompiler v0.25.0 [c145ed77] + GenericSchur v0.5.5 [86223c79] + Graphs v1.12.1 [3e5b6fbb] + HostCPUFeatures v0.1.17 [34004b35] + HypergeometricFunctions v0.3.28 [615f187c] + IfElse v0.1.1 [d25df0c9] + Inflate v0.1.5 ⌅ [a98d9a8b] + Interpolations v0.14.7 [3587e190] + InverseFunctions v0.1.17 [92d709cd] + IrrationalConstants v0.2.4 [82899510] + IteratorInterfaceExtensions v1.0.0 [692b3bcd] + JLLWrappers v1.7.0 ⌅ [ef3ab10e] + KLU v0.4.1 [ec8451be] + KernelFunctions v0.10.65 ⌅ [ba0b0d4f] + Krylov v0.9.10 ⌅ [929cbde3] + LLVM v6.6.3 [10f19ff3] + LayoutPointers v0.1.17 [1d6d02ad] + LeftChildRightSiblingTrees v0.2.0 [d3d80556] + LineSearches v7.3.0 ⌅ [7ed4a6bd] + LinearSolve v2.16.2 [2ab3a3ac] + LogExpFunctions v0.3.29 [e6f89c97] + LoggingExtras v1.1.0 [bdcacae8] + LoopVectorization v0.12.172 ⌅ [33e6dc65] + MKL v0.6.3 [1914dd2f] + MacroTools v0.5.16 [d125e4d3] + ManualMemory v0.1.8 [e1d29d7a] + Missings v1.2.0 [46d2c3a1] + MuladdMacro v0.2.4 ⌃ [d41bc354] + NLSolversBase v7.8.3 [2774e3e8] + NLsolve v4.5.1 [77ba4419] + NaNMath v1.1.3 ⌅ [8913a72c] + NonlinearSolve v2.1.0 [d8793406] + ObjectFile v0.4.4 [6fe1bfb0] + OffsetArrays v1.17.0 [a15396b6] + OnlineStats v1.7.1 [925886fa] + OnlineStatsBase v1.7.1 ⌃ [429524aa] + Optim v1.11.0 ⌅ [3bd65402] + Optimisers v0.2.20 ⌅ [7f7a1694] + Optimization v3.19.3 ⌅ [36348300] + OptimizationOptimJL v0.1.14 [bac558e1] + OrderedCollections v1.8.0 ⌃ [1dea7af3] + OrdinaryDiffEq v6.58.2 [90014a1f] + PDMats v0.11.34 [65ce6f38] + PackageExtensionCompat v1.0.2 [d96e819e] + Parameters v0.12.3 [f517fe37] + Polyester v0.7.16 [1d0040c9] + PolyesterWeave v0.2.2 [85a6dd25] + PositiveFactorizations v0.2.4 ⌃ [d236fae5] + PreallocationTools v0.4.24 [aea7be01] + PrecompileTools v1.3.2 [21216c6a] + Preferences v1.4.3 [33c8b6b6] + ProgressLogging v0.1.4 [92933f4c] + ProgressMeter v1.10.4 [43287f4e] + PtrArrays v1.3.0 ⌃ [1fd47b50] + QuadGK v2.10.1 [c84ed2f1] + Ratios v0.4.5 [3cdcf5f2] + RecipesBase v1.3.4 ⌅ [731186ca] + RecursiveArrayTools v2.38.10 [f2c3362d] + RecursiveFactorization v0.2.23 [189a3867] + Reexport v1.2.2 [ae029012] + Requires v1.3.1 [79098fc4] + Rmath v0.8.0 [7e49a35a] + RuntimeGeneratedFunctions v0.5.14 [94e857df] + SIMDTypes v0.1.0 [476501e8] + SLEEFPirates v0.6.43 ⌅ [0bca4576] + SciMLBase v1.98.1 [e9a6253c] + SciMLNLSolve v0.1.9 [c0aeaf25] + SciMLOperators v0.3.13 [6c6a2e73] + Scratch v1.2.1 [efcf1570] + Setfield v1.1.2 ⌅ [727e6d20] + SimpleNonlinearSolve v0.1.23 [699a6c99] + SimpleTraits v0.9.4 [ce78b400] + SimpleUnPack v1.1.0 [a2af1166] + SortingAlgorithms v1.2.1 ⌃ [47a9eef4] + SparseDiffTools v2.18.0 [e56a9233] + Sparspak v0.3.11 [276daf66] + SpecialFunctions v2.5.1 ⌅ [aedffcd0] + Static v0.8.10 [0d7ed370] + StaticArrayInterface v1.8.0 [90137ffa] + StaticArrays v1.9.13 [1e83bf80] + StaticArraysCore v1.4.3 [10745b16] + Statistics v1.11.1 [82ae8749] + StatsAPI v1.7.0 ⌅ [2913bbd2] + StatsBase v0.33.21 [4c63d2b9] + StatsFuns v1.5.0 [7792a7ef] + StrideArraysCore v0.5.7 [53d494c1] + StructIO v0.3.1 ⌅ [2efcf032] + SymbolicIndexingInterface v0.2.2 [3783bdb8] + TableTraits v1.0.1 [bd369af6] + Tables v1.12.0 [62fd8b95] + TensorCore v0.1.1 [5d786b92] + TerminalLoggers v0.1.7 [8290d209] + ThreadingUtilities v0.5.3 [a759f4b9] + TimerOutputs v0.5.28 [d5829a12] + TriangularSolve v0.2.1 [410a4b4d] + Tricks v0.1.10 [781d530d] + TruncatedStacktraces v1.4.0 [3a884ed6] + UnPack v1.0.2 [3d5dd08c] + VectorizationBase v0.21.71 [19fa3120] + VertexSafeGraphs v0.2.0 ⌅ [efce3f68] + WoodburyMatrices v0.5.6 [700de1a5] + ZygoteRules v0.2.7 ⌅ [7cc45869] + Enzyme_jll v0.0.102+0 ⌅ [1d5cc7b8] + IntelOpenMP_jll v2024.2.1+0 ⌅ [dad2f222] + LLVMExtra_jll v0.0.29+0 ⌅ [856f044c] + MKL_jll v2024.2.0+0 [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 [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 8.79s ################################################################################ # 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... 14455.9 ms ✓ KernelFunctions 18185.4 ms ? SciMLBase 52386.0 ms ✓ LoopVectorization → SpecialFunctionsExt 10751.1 ms ? GPUCompiler 18862.4 ms ✓ Distributions 43033.3 ms ✓ SparseDiffTools → SparseDiffToolsPolyesterExt ✗ Optim 7716.4 ms ? Optimization 21129.4 ms ? DiffEqBase 23536.7 ms ? LinearSolve 20341.4 ms ? Enzyme 7414.5 ms ✓ Distributions → DistributionsTestExt 6901.7 ms ✓ Distributions → DistributionsChainRulesCoreExt 26218.2 ms ✓ OnlineStats 11918.7 ms ? Optimization → OptimizationFiniteDiffExt 8056.7 ms ? Optimization → OptimizationForwardDiffExt 49958.6 ms ? DiffEqBase → DiffEqBaseDistributionsExt 14643.2 ms ? SciMLNLSolve 15030.7 ms ? SimpleNonlinearSolve 13107.6 ms ? LinearSolve → LinearSolveRecursiveArrayToolsExt 21071.3 ms ? Enzyme → EnzymeSpecialFunctionsExt 25087.1 ms ? SparseDiffTools → SparseDiffToolsEnzymeExt 7937.8 ms ? Optimization → OptimizationEnzymeExt 13617.5 ms ? LinearSolve → LinearSolveEnzymeExt 40273.4 ms ✓ AbstractGPs 18427.0 ms ✓ GPLikelihoods ✗ OptimizationOptimJL 25504.7 ms ? NonlinearSolve 12472.3 ms ✓ ApproximateGPs 12761.9 ms ? OrdinaryDiffEq 19656.0 ms ? GPDiffEq 10 dependencies successfully precompiled in 630 seconds. 214 already precompiled. 19 dependencies failed but may be precompilable after restarting julia 19 dependencies had output during precompilation: ┌ OrdinaryDiffEq │ WARNING: Method definition islinear(Any) in module SciMLOperators at /home/pkgeval/.julia/packages/SciMLOperators/2UPBq/src/interface.jl:311 overwritten in module SciMLBase at /home/pkgeval/.julia/packages/SciMLBase/szsYq/src/operators/operators.jl:7. │ ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. └ ┌ Optimization → OptimizationEnzymeExt │ WARNING: Method definition islinear(Any) in module SciMLOperators at /home/pkgeval/.julia/packages/SciMLOperators/2UPBq/src/interface.jl:311 overwritten in module SciMLBase at /home/pkgeval/.julia/packages/SciMLBase/szsYq/src/operators/operators.jl:7. │ ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. └ ┌ SimpleNonlinearSolve │ WARNING: Method definition islinear(Any) in module SciMLOperators at /home/pkgeval/.julia/packages/SciMLOperators/2UPBq/src/interface.jl:311 overwritten in module SciMLBase at /home/pkgeval/.julia/packages/SciMLBase/szsYq/src/operators/operators.jl:7. │ ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. └ ┌ SparseDiffTools → SparseDiffToolsEnzymeExt │ ┌ 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. └ ┌ LinearSolve → LinearSolveEnzymeExt │ WARNING: Method definition islinear(Any) in module SciMLOperators at /home/pkgeval/.julia/packages/SciMLOperators/2UPBq/src/interface.jl:311 overwritten in module SciMLBase at /home/pkgeval/.julia/packages/SciMLBase/szsYq/src/operators/operators.jl:7. │ ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. └ ┌ NonlinearSolve │ WARNING: Method definition islinear(Any) in module SciMLOperators at /home/pkgeval/.julia/packages/SciMLOperators/2UPBq/src/interface.jl:311 overwritten in module SciMLBase at /home/pkgeval/.julia/packages/SciMLBase/szsYq/src/operators/operators.jl:7. │ ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. └ ┌ Optimization │ WARNING: Method definition islinear(Any) in module SciMLOperators at /home/pkgeval/.julia/packages/SciMLOperators/2UPBq/src/interface.jl:311 overwritten in module SciMLBase at /home/pkgeval/.julia/packages/SciMLBase/szsYq/src/operators/operators.jl:7. │ ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. └ ┌ LinearSolve │ WARNING: Method definition islinear(Any) in module SciMLOperators at /home/pkgeval/.julia/packages/SciMLOperators/2UPBq/src/interface.jl:311 overwritten in module SciMLBase at /home/pkgeval/.julia/packages/SciMLBase/szsYq/src/operators/operators.jl:7. │ ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. └ ┌ SciMLBase │ WARNING: Method definition islinear(Any) in module SciMLOperators at /home/pkgeval/.julia/packages/SciMLOperators/2UPBq/src/interface.jl:311 overwritten in module SciMLBase at /home/pkgeval/.julia/packages/SciMLBase/szsYq/src/operators/operators.jl:7. │ 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. └ ┌ GPDiffEq │ WARNING: Method definition islinear(Any) in module SciMLOperators at /home/pkgeval/.julia/packages/SciMLOperators/2UPBq/src/interface.jl:311 overwritten in module SciMLBase at /home/pkgeval/.julia/packages/SciMLBase/szsYq/src/operators/operators.jl:7. │ ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. └ ┌ SciMLNLSolve │ WARNING: Method definition islinear(Any) in module SciMLOperators at /home/pkgeval/.julia/packages/SciMLOperators/2UPBq/src/interface.jl:311 overwritten in module SciMLBase at /home/pkgeval/.julia/packages/SciMLBase/szsYq/src/operators/operators.jl:7. │ ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. └ ┌ Optimization → OptimizationForwardDiffExt │ WARNING: Method definition islinear(Any) in module SciMLOperators at /home/pkgeval/.julia/packages/SciMLOperators/2UPBq/src/interface.jl:311 overwritten in module SciMLBase at /home/pkgeval/.julia/packages/SciMLBase/szsYq/src/operators/operators.jl:7. │ 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. └ ┌ DiffEqBase │ WARNING: Method definition islinear(Any) in module SciMLOperators at /home/pkgeval/.julia/packages/SciMLOperators/2UPBq/src/interface.jl:311 overwritten in module SciMLBase at /home/pkgeval/.julia/packages/SciMLBase/szsYq/src/operators/operators.jl:7. │ ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. └ ┌ LinearSolve → LinearSolveRecursiveArrayToolsExt │ WARNING: Method definition islinear(Any) in module SciMLOperators at /home/pkgeval/.julia/packages/SciMLOperators/2UPBq/src/interface.jl:311 overwritten in module SciMLBase at /home/pkgeval/.julia/packages/SciMLBase/szsYq/src/operators/operators.jl:7. │ ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. └ ┌ Optimization → OptimizationFiniteDiffExt │ WARNING: Method definition islinear(Any) in module SciMLOperators at /home/pkgeval/.julia/packages/SciMLOperators/2UPBq/src/interface.jl:311 overwritten in module SciMLBase at /home/pkgeval/.julia/packages/SciMLBase/szsYq/src/operators/operators.jl:7. │ 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. └ ┌ DiffEqBase → DiffEqBaseDistributionsExt │ WARNING: Method definition islinear(Any) in module SciMLOperators at /home/pkgeval/.julia/packages/SciMLOperators/2UPBq/src/interface.jl:311 overwritten in module SciMLBase at /home/pkgeval/.julia/packages/SciMLBase/szsYq/src/operators/operators.jl:7. │ ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. └ Precompilation completed after 627.9s ################################################################################ # Loading # Loading GPDiffEq... Precompiling packages... 6714.0 ms ? SciMLBase 10746.1 ms ? GPUCompiler 23658.8 ms ✓ SparseDiffTools → SparseDiffToolsPolyesterExt ✗ Optim 7340.2 ms ? Optimization 11708.7 ms ? DiffEqBase 152689.8 ms ? LinearSolve 20065.3 ms ? Enzyme 7877.2 ms ? Optimization → OptimizationFiniteDiffExt 8093.3 ms ? Optimization → OptimizationForwardDiffExt 16907.4 ms ? DiffEqBase → DiffEqBaseDistributionsExt 15812.2 ms ? SciMLNLSolve 16148.0 ms ? SimpleNonlinearSolve 15132.5 ms ? LinearSolve → LinearSolveRecursiveArrayToolsExt 26815.6 ms ? Enzyme → EnzymeSpecialFunctionsExt 26410.1 ms ? SparseDiffTools → SparseDiffToolsEnzymeExt 8253.8 ms ? Optimization → OptimizationEnzymeExt 13622.7 ms ? LinearSolve → LinearSolveEnzymeExt ✗ OptimizationOptimJL 12632.6 ms ? NonlinearSolve 12635.4 ms ? OrdinaryDiffEq Info Given GPDiffEq was explicitly requested, output will be shown live  WARNING: Method definition islinear(Any) in module SciMLOperators at /home/pkgeval/.julia/packages/SciMLOperators/2UPBq/src/interface.jl:311 overwritten in module SciMLBase at /home/pkgeval/.julia/packages/SciMLBase/szsYq/src/operators/operators.jl:7. ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. 18455.9 ms ? GPDiffEq 1 dependency successfully precompiled in 470 seconds. 223 already precompiled. 19 dependencies failed but may be precompilable after restarting julia 19 dependencies had output during precompilation: ┌ OrdinaryDiffEq │ WARNING: Method definition islinear(Any) in module SciMLOperators at /home/pkgeval/.julia/packages/SciMLOperators/2UPBq/src/interface.jl:311 overwritten in module SciMLBase at /home/pkgeval/.julia/packages/SciMLBase/szsYq/src/operators/operators.jl:7. │ ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. └ ┌ Optimization → OptimizationEnzymeExt │ WARNING: Method definition islinear(Any) in module SciMLOperators at /home/pkgeval/.julia/packages/SciMLOperators/2UPBq/src/interface.jl:311 overwritten in module SciMLBase at /home/pkgeval/.julia/packages/SciMLBase/szsYq/src/operators/operators.jl:7. │ ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. └ ┌ SimpleNonlinearSolve │ WARNING: Method definition islinear(Any) in module SciMLOperators at /home/pkgeval/.julia/packages/SciMLOperators/2UPBq/src/interface.jl:311 overwritten in module SciMLBase at /home/pkgeval/.julia/packages/SciMLBase/szsYq/src/operators/operators.jl:7. │ ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. └ ┌ SparseDiffTools → SparseDiffToolsEnzymeExt │ ┌ 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. └ ┌ LinearSolve → LinearSolveEnzymeExt │ WARNING: Method definition islinear(Any) in module SciMLOperators at /home/pkgeval/.julia/packages/SciMLOperators/2UPBq/src/interface.jl:311 overwritten in module SciMLBase at /home/pkgeval/.julia/packages/SciMLBase/szsYq/src/operators/operators.jl:7. │ ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. └ ┌ NonlinearSolve │ WARNING: Method definition islinear(Any) in module SciMLOperators at /home/pkgeval/.julia/packages/SciMLOperators/2UPBq/src/interface.jl:311 overwritten in module SciMLBase at /home/pkgeval/.julia/packages/SciMLBase/szsYq/src/operators/operators.jl:7. │ ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. └ ┌ Optimization │ WARNING: Method definition islinear(Any) in module SciMLOperators at /home/pkgeval/.julia/packages/SciMLOperators/2UPBq/src/interface.jl:311 overwritten in module SciMLBase at /home/pkgeval/.julia/packages/SciMLBase/szsYq/src/operators/operators.jl:7. │ ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. └ ┌ LinearSolve │ WARNING: Constructor for type "Int16" was extended in `VectorizationBase` without explicit qualification or import. │ NOTE: Assumed "Int16" refers to `Base.Int16`. 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 Int16 end`. │ Hint: To silence the warning, qualify `Int16` as `Base.Int16` in the method signature or explicitly `import Base: Int16`. │ WARNING: Constructor for type "Int64" was extended in `VectorizationBase` without explicit qualification or import. │ NOTE: Assumed "Int64" refers to `Base.Int64`. 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 Int64 end`. │ Hint: To silence the warning, qualify `Int64` as `Base.Int64` in the method signature or explicitly `import Base: Int64`. │ WARNING: Constructor for type "Int32" was extended in `VectorizationBase` without explicit qualification or import. │ NOTE: Assumed "Int32" refers to `Base.Int32`. 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 Int32 end`. │ Hint: To silence the warning, qualify `Int32` as `Base.Int32` in the method signature or explicitly `import Base: Int32`. │ WARNING: Constructor for type "UInt8" was extended in `VectorizationBase` without explicit qualification or import. │ NOTE: Assumed "UInt8" refers to `Base.UInt8`. 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 UInt8 end`. │ Hint: To silence the warning, qualify `UInt8` as `Base.UInt8` in the method signature or explicitly `import Base: UInt8`. │ WARNING: Constructor for type "UInt16" was extended in `VectorizationBase` without explicit qualification or import. │ NOTE: Assumed "UInt16" refers to `Base.UInt16`. 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 UInt16 end`. │ Hint: To silence the warning, qualify `UInt16` as `Base.UInt16` in the method signature or explicitly `import Base: UInt16`. │ WARNING: Constructor for type "Float32" was extended in `VectorizationBase` without explicit qualification or import. │ NOTE: Assumed "Float32" refers to `Base.Float32`. 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 Float32 end`. │ Hint: To silence the warning, qualify `Float32` as `Base.Float32` in the method signature or explicitly `import Base: Float32`. │ WARNING: Constructor for type "UInt64" was extended in `VectorizationBase` without explicit qualification or import. │ NOTE: Assumed "UInt64" refers to `Base.UInt64`. 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 UInt64 end`. │ Hint: To silence the warning, qualify `UInt64` as `Base.UInt64` in the method signature or explicitly `import Base: UInt64`. │ WARNING: Constructor for type "Bool" was extended in `VectorizationBase` without explicit qualification or import. │ NOTE: Assumed "Bool" refers to `Base.Bool`. 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 Bool end`. │ Hint: To silence the warning, qualify `Bool` as `Base.Bool` in the method signature or explicitly `import Base: Bool`. │ WARNING: Constructor for type "Int8" was extended in `VectorizationBase` without explicit qualification or import. │ NOTE: Assumed "Int8" refers to `Base.Int8`. 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 Int8 end`. │ Hint: To silence the warning, qualify `Int8` as `Base.Int8` in the method signature or explicitly `import Base: Int8`. │ WARNING: Constructor for type "Float64" was extended in `VectorizationBase` without explicit qualification or import. │ NOTE: Assumed "Float64" refers to `Base.Float64`. 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 Float64 end`. │ Hint: To silence the warning, qualify `Float64` as `Base.Float64` in the method signature or explicitly `import Base: Float64`. │ WARNING: Constructor for type "UInt32" was extended in `VectorizationBase` without explicit qualification or import. │ NOTE: Assumed "UInt32" refers to `Base.UInt32`. 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 UInt32 end`. │ Hint: To silence the warning, qualify `UInt32` as `Base.UInt32` in the method signature or explicitly `import Base: UInt32`. │ WARNING: Constructor for type "Float16" was extended in `VectorizationBase` without explicit qualification or import. │ NOTE: Assumed "Float16" refers to `Base.Float16`. 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 Float16 end`. │ Hint: To silence the warning, qualify `Float16` as `Base.Float16` in the method signature or explicitly `import Base: Float16`. │ WARNING: Method definition islinear(Any) in module SciMLOperators at /home/pkgeval/.julia/packages/SciMLOperators/2UPBq/src/interface.jl:311 overwritten in module SciMLBase at /home/pkgeval/.julia/packages/SciMLBase/szsYq/src/operators/operators.jl:7. │ ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. └ ┌ SciMLBase │ WARNING: Method definition islinear(Any) in module SciMLOperators at /home/pkgeval/.julia/packages/SciMLOperators/2UPBq/src/interface.jl:311 overwritten in module SciMLBase at /home/pkgeval/.julia/packages/SciMLBase/szsYq/src/operators/operators.jl:7. │ 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. └ ┌ GPDiffEq │ [Output was shown above] └ ┌ SciMLNLSolve │ WARNING: Method definition islinear(Any) in module SciMLOperators at /home/pkgeval/.julia/packages/SciMLOperators/2UPBq/src/interface.jl:311 overwritten in module SciMLBase at /home/pkgeval/.julia/packages/SciMLBase/szsYq/src/operators/operators.jl:7. │ ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. └ ┌ Optimization → OptimizationForwardDiffExt │ WARNING: Method definition islinear(Any) in module SciMLOperators at /home/pkgeval/.julia/packages/SciMLOperators/2UPBq/src/interface.jl:311 overwritten in module SciMLBase at /home/pkgeval/.julia/packages/SciMLBase/szsYq/src/operators/operators.jl:7. │ 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. └ ┌ DiffEqBase │ WARNING: Method definition islinear(Any) in module SciMLOperators at /home/pkgeval/.julia/packages/SciMLOperators/2UPBq/src/interface.jl:311 overwritten in module SciMLBase at /home/pkgeval/.julia/packages/SciMLBase/szsYq/src/operators/operators.jl:7. │ ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. └ ┌ LinearSolve → LinearSolveRecursiveArrayToolsExt │ WARNING: Method definition islinear(Any) in module SciMLOperators at /home/pkgeval/.julia/packages/SciMLOperators/2UPBq/src/interface.jl:311 overwritten in module SciMLBase at /home/pkgeval/.julia/packages/SciMLBase/szsYq/src/operators/operators.jl:7. │ ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. └ ┌ Optimization → OptimizationFiniteDiffExt │ WARNING: Method definition islinear(Any) in module SciMLOperators at /home/pkgeval/.julia/packages/SciMLOperators/2UPBq/src/interface.jl:311 overwritten in module SciMLBase at /home/pkgeval/.julia/packages/SciMLBase/szsYq/src/operators/operators.jl:7. │ 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. └ ┌ DiffEqBase → DiffEqBaseDistributionsExt │ WARNING: Method definition islinear(Any) in module SciMLOperators at /home/pkgeval/.julia/packages/SciMLOperators/2UPBq/src/interface.jl:311 overwritten in module SciMLBase at /home/pkgeval/.julia/packages/SciMLBase/szsYq/src/operators/operators.jl:7. │ ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. └ WARNING: Method definition islinear(Any) in module SciMLOperators at /home/pkgeval/.julia/packages/SciMLOperators/2UPBq/src/interface.jl:311 overwritten in module SciMLBase at /home/pkgeval/.julia/packages/SciMLBase/szsYq/src/operators/operators.jl:7. ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. Precompiling packages... 6590.3 ms ? SciMLBase Info Given DiffEqBase was explicitly requested, output will be shown live  WARNING: Method definition islinear(Any) in module SciMLOperators at /home/pkgeval/.julia/packages/SciMLOperators/2UPBq/src/interface.jl:311 overwritten in module SciMLBase at /home/pkgeval/.julia/packages/SciMLBase/szsYq/src/operators/operators.jl:7. ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. 12694.2 ms ? DiffEqBase WARNING: Method definition islinear(Any) in module SciMLOperators at /home/pkgeval/.julia/packages/SciMLOperators/2UPBq/src/interface.jl:311 overwritten in module SciMLBase at /home/pkgeval/.julia/packages/SciMLBase/szsYq/src/operators/operators.jl:7. ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. Precompiling packages... 2617.9 ms ✓ StaticArrayInterface → StaticArrayInterfaceStaticArraysExt 1 dependency successfully precompiled in 3 seconds. 23 already precompiled. Precompiling packages... Info Given SciMLBase was explicitly requested, output will be shown live  WARNING: Method definition islinear(Any) in module SciMLOperators at /home/pkgeval/.julia/packages/SciMLOperators/2UPBq/src/interface.jl:311 overwritten in module SciMLBase at /home/pkgeval/.julia/packages/SciMLBase/szsYq/src/operators/operators.jl:7. ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. 6055.2 ms ? SciMLBase WARNING: Method definition islinear(Any) in module SciMLOperators at /home/pkgeval/.julia/packages/SciMLOperators/2UPBq/src/interface.jl:311 overwritten in module SciMLBase at /home/pkgeval/.julia/packages/SciMLBase/szsYq/src/operators/operators.jl:7. ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. Precompiling packages... 6269.5 ms ? SciMLBase 4275.0 ms ? DiffEqBase Info Given DiffEqBaseDistributionsExt was explicitly requested, output will be shown live  ┌ Warning: Module DiffEqBase with build ID ffffffff-ffff-ffff-002d-a13dc2729e20 is missing from the cache. │ This may mean DiffEqBase [2b5f629d-d688-5b77-993f-72d75c75574e] does not support precompilation but is imported by a module that does. └ @ Base loading.jl:2614 4190.9 ms ? DiffEqBase → DiffEqBaseDistributionsExt ┌ Warning: Module DiffEqBase with build ID ffffffff-ffff-ffff-002d-a13dc2729e20 is missing from the cache. │ This may mean DiffEqBase [2b5f629d-d688-5b77-993f-72d75c75574e] does not support precompilation but is imported by a module that does. └ @ Base loading.jl:2614 Precompiling packages... 6239.5 ms ? SciMLBase Info Given Optimization was explicitly requested, output will be shown live  ┌ Warning: Module SciMLBase with build ID ffffffff-ffff-ffff-002d-a141c39b7202 is missing from the cache. │ This may mean SciMLBase [0bca4576-84f4-4d90-8ffe-ffa030f20462] does not support precompilation but is imported by a module that does. └ @ Base loading.jl:2614 917.6 ms ? Optimization ┌ Warning: Module SciMLBase with build ID ffffffff-ffff-ffff-002d-a141c39b7202 is missing from the cache. │ This may mean SciMLBase [0bca4576-84f4-4d90-8ffe-ffa030f20462] does not support precompilation but is imported by a module that does. └ @ Base loading.jl:2614 Precompiling packages... 9443.6 ms ? SciMLBase 931.5 ms ? Optimization Info Given OptimizationForwardDiffExt was explicitly requested, output will be shown live  ┌ Warning: Module Optimization with build ID ffffffff-ffff-ffff-002d-a1519fc285c1 is missing from the cache. │ This may mean Optimization [7f7a1694-90dd-40f0-9382-eb1efda571ba] does not support precompilation but is imported by a module that does. └ @ Base loading.jl:2614 554.9 ms ? Optimization → OptimizationForwardDiffExt ┌ Warning: Module Optimization with build ID ffffffff-ffff-ffff-002d-a1519fc285c1 is missing from the cache. │ This may mean Optimization [7f7a1694-90dd-40f0-9382-eb1efda571ba] does not support precompilation but is imported by a module that does. └ @ Base loading.jl:2614 Precompiling packages... 6028.7 ms ? SciMLBase 5041.2 ms ✓ NLSolversBase 958.6 ms ? Optimization 6978.8 ms ✓ LineSearches 736.2 ms ? Optimization → OptimizationFiniteDiffExt 574.2 ms ? Optimization → OptimizationForwardDiffExt ✗ Optim Info Given OptimizationOptimJL was explicitly requested, output will be shown live  ERROR: LoadError: syntax: misplaced "global" declaration Stacktrace:  [1] top-level scope  @ ~/.julia/packages/Optim/HvjCd/src/Optim.jl:223  [2] include(mod::Module, _path::String)  @ Base ./Base.jl:303  [3] include_package_for_output(pkg::Base.PkgId, input::String, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt128}}, source::String)  @ Base ./loading.jl:2979  [4] top-level scope  @ stdin:5  [5] eval(m::Module, e::Any)  @ Core ./boot.jl:489  [6] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)  @ Base ./loading.jl:2825  [7] include_string  @ ./loading.jl:2835 [inlined]  [8] exec_options(opts::Base.JLOptions)  @ Base ./client.jl:329  [9] _start()  @ Base ./client.jl:563 in expression starting at /home/pkgeval/.julia/packages/Optim/HvjCd/src/Optim.jl:1 in expression starting at stdin:5 ERROR: LoadError: Failed to precompile Optim [429524aa-4258-5aef-a3af-852621145aeb] to "/home/pkgeval/.julia/compiled/v1.13/Optim/jl_fpU96g" (ProcessExited(1)). Stacktrace:  [1] error(s::String)  @ Base ./error.jl:44  [2] compilecache(pkg::Base.PkgId, path::String, internal_stderr::IO, internal_stdout::IO, keep_loaded_modules::Bool; flags::Cmd, cacheflags::Base.CacheFlags, reasons::Dict{String, Int64}, loadable_exts::Nothing)  @ Base ./loading.jl:3266  [3] (::Base.var"#__require_prelocked##0#__require_prelocked##1"{Base.PkgId})()  @ Base ./loading.jl:2652  [4] mkpidlock(f::Base.var"#__require_prelocked##0#__require_prelocked##1"{Base.PkgId}, at::String, pid::Int32; kwopts::@Kwargs{stale_age::Int64, wait::Bool})  @ FileWatching.Pidfile /opt/julia/share/julia/stdlib/v1.13/FileWatching/src/pidfile.jl:93  [5] #mkpidlock#7  @ /opt/julia/share/julia/stdlib/v1.13/FileWatching/src/pidfile.jl:88 [inlined]  [6] trymkpidlock(::Function, ::Vararg{Any}; kwargs::@Kwargs{stale_age::Int64})  @ FileWatching.Pidfile /opt/julia/share/julia/stdlib/v1.13/FileWatching/src/pidfile.jl:114  [7] apply_gr_kw(::NamedTuple, ::GlobalRef, ::Any, ::Vararg{Any})  @ Base ./reflection.jl:1279  [8] #invokelatest_gr#234  @ ./reflection.jl:1287 [inlined]  [9] invokelatest_gr  @ ./reflection.jl:1281 [inlined]  [10] maybe_cachefile_lock(f::Base.var"#__require_prelocked##0#__require_prelocked##1"{Base.PkgId}, pkg::Base.PkgId, srcpath::String; stale_age::Int64)  @ Base ./loading.jl:3837  [11] maybe_cachefile_lock  @ ./loading.jl:3834 [inlined]  [12] __require_prelocked(pkg::Base.PkgId, env::String)  @ Base ./loading.jl:2638  [13] _require_prelocked(uuidkey::Base.PkgId, env::String)  @ Base ./loading.jl:2466  [14] macro expansion  @ ./loading.jl:2394 [inlined]  [15] macro expansion  @ ./lock.jl:376 [inlined]  [16] __require(into::Module, mod::Symbol)  @ Base ./loading.jl:2359  [17] require(into::Module, mod::Symbol)  @ Base ./loading.jl:2335  [18] include(mod::Module, _path::String)  @ Base ./Base.jl:303  [19] include_package_for_output(pkg::Base.PkgId, input::String, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt128}}, source::Nothing)  @ Base ./loading.jl:2979  [20] top-level scope  @ stdin:5  [21] eval(m::Module, e::Any)  @ Core ./boot.jl:489  [22] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)  @ Base ./loading.jl:2825  [23] include_string  @ ./loading.jl:2835 [inlined]  [24] exec_options(opts::Base.JLOptions)  @ Base ./client.jl:329  [25] _start()  @ Base ./client.jl:563 in expression starting at /home/pkgeval/.julia/packages/OptimizationOptimJL/r5j6D/src/OptimizationOptimJL.jl:1 in expression starting at stdin:5 ✗ OptimizationOptimJL 2 dependencies successfully precompiled in 55 seconds. 114 already precompiled. 3 dependencies precompiled but different versions are currently loaded. Restart julia to access the new versions. Otherwise, loading dependents of these packages may trigger further precompilation to work with the unexpected versions. 4 dependencies failed but may be precompilable after restarting julia 4 dependencies had output during precompilation: ┌ Optimization → OptimizationFiniteDiffExt │ ┌ Warning: Module Optimization with build ID ffffffff-ffff-ffff-002d-a1519fc285c1 is missing from the cache. │ │ This may mean Optimization [7f7a1694-90dd-40f0-9382-eb1efda571ba] does not support precompilation but is imported by a module that does. │ └ @ Base loading.jl:2614 └ ┌ Optimization │ ┌ Warning: Module SciMLBase with build ID ffffffff-ffff-ffff-002d-a141c39b7202 is missing from the cache. │ │ This may mean SciMLBase [0bca4576-84f4-4d90-8ffe-ffa030f20462] does not support precompilation but is imported by a module that does. │ └ @ Base loading.jl:2614 └ ┌ Optimization → OptimizationForwardDiffExt │ ┌ Warning: Module Optimization with build ID ffffffff-ffff-ffff-002d-a1519fc285c1 is missing from the cache. │ │ This may mean Optimization [7f7a1694-90dd-40f0-9382-eb1efda571ba] does not support precompilation but is imported by a module that does. │ └ @ Base loading.jl:2614 └ ┌ SciMLBase │ WARNING: Method definition islinear(Any) in module SciMLOperators at /home/pkgeval/.julia/packages/SciMLOperators/2UPBq/src/interface.jl:311 overwritten in module SciMLBase at /home/pkgeval/.julia/packages/SciMLBase/szsYq/src/operators/operators.jl:7. │ ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation. └ ERROR: LoadError: syntax: misplaced "global" declaration Stacktrace: [1] top-level scope @ ~/.julia/packages/Optim/HvjCd/src/Optim.jl:223 [2] include(mod::Module, _path::String) @ Base ./Base.jl:303 [3] include_package_for_output(pkg::Base.PkgId, input::String, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt128}}, source::String) @ Base ./loading.jl:2979 [4] top-level scope @ stdin:5 [5] eval(m::Module, e::Any) @ Core ./boot.jl:489 [6] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String) @ Base ./loading.jl:2825 [7] include_string @ ./loading.jl:2835 [inlined] [8] exec_options(opts::Base.JLOptions) @ Base ./client.jl:329 [9] _start() @ Base ./client.jl:563 in expression starting at /home/pkgeval/.julia/packages/Optim/HvjCd/src/Optim.jl:1 in expression starting at stdin:5 ERROR: LoadError: Failed to precompile Optim [429524aa-4258-5aef-a3af-852621145aeb] to "/home/pkgeval/.julia/compiled/v1.13/Optim/jl_111NGd" (ProcessExited(1)). Stacktrace: [1] error(s::String) @ Base ./error.jl:44 [2] compilecache(pkg::Base.PkgId, path::String, internal_stderr::IO, internal_stdout::IO, keep_loaded_modules::Bool; flags::Cmd, cacheflags::Base.CacheFlags, reasons::Dict{String, Int64}, loadable_exts::Nothing) @ Base ./loading.jl:3266 [3] (::Base.var"#__require_prelocked##0#__require_prelocked##1"{Base.PkgId})() @ Base ./loading.jl:2652 [4] mkpidlock(f::Base.var"#__require_prelocked##0#__require_prelocked##1"{Base.PkgId}, at::String, pid::Int32; kwopts::@Kwargs{stale_age::Int64, wait::Bool}) @ FileWatching.Pidfile /opt/julia/share/julia/stdlib/v1.13/FileWatching/src/pidfile.jl:93 [5] #mkpidlock#7 @ /opt/julia/share/julia/stdlib/v1.13/FileWatching/src/pidfile.jl:88 [inlined] [6] trymkpidlock(::Function, ::Vararg{Any}; kwargs::@Kwargs{stale_age::Int64}) @ FileWatching.Pidfile /opt/julia/share/julia/stdlib/v1.13/FileWatching/src/pidfile.jl:114 [7] apply_gr_kw(::NamedTuple, ::GlobalRef, ::Any, ::Vararg{Any}) @ Base ./reflection.jl:1279 [8] #invokelatest_gr#234 @ ./reflection.jl:1287 [inlined] [9] invokelatest_gr @ ./reflection.jl:1281 [inlined] [10] maybe_cachefile_lock(f::Base.var"#__require_prelocked##0#__require_prelocked##1"{Base.PkgId}, pkg::Base.PkgId, srcpath::String; stale_age::Int64) @ Base ./loading.jl:3837 [11] maybe_cachefile_lock @ ./loading.jl:3834 [inlined] [12] __require_prelocked(pkg::Base.PkgId, env::String) @ Base ./loading.jl:2638 [13] _require_prelocked(uuidkey::Base.PkgId, env::String) @ Base ./loading.jl:2466 [14] macro expansion @ ./loading.jl:2394 [inlined] [15] macro expansion @ ./lock.jl:376 [inlined] [16] __require(into::Module, mod::Symbol) @ Base ./loading.jl:2359 [17] require(into::Module, mod::Symbol) @ Base ./loading.jl:2335 [18] include(mod::Module, _path::String) @ Base ./Base.jl:303 [19] include_package_for_output(pkg::Base.PkgId, input::String, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt128}}, source::String) @ Base ./loading.jl:2979 [20] top-level scope @ stdin:5 [21] eval(m::Module, e::Any) @ Core ./boot.jl:489 [22] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String) @ Base ./loading.jl:2825 [23] include_string @ ./loading.jl:2835 [inlined] [24] exec_options(opts::Base.JLOptions) @ Base ./client.jl:329 [25] _start() @ Base ./client.jl:563 in expression starting at /home/pkgeval/.julia/packages/OptimizationOptimJL/r5j6D/src/OptimizationOptimJL.jl:1 in expression starting at stdin:5 ERROR: LoadError: Failed to precompile OptimizationOptimJL [36348300-93cb-4f02-beb5-3c3902f8871e] to "/home/pkgeval/.julia/compiled/v1.13/OptimizationOptimJL/jl_pieVKV" (ProcessExited(1)). Stacktrace: [1] error(s::String) @ Base ./error.jl:44 [2] compilecache(pkg::Base.PkgId, path::String, internal_stderr::IO, internal_stdout::IO, keep_loaded_modules::Bool; flags::Cmd, cacheflags::Base.CacheFlags, reasons::Dict{String, Int64}, loadable_exts::Nothing) @ Base ./loading.jl:3266 [3] (::Base.var"#__require_prelocked##0#__require_prelocked##1"{Base.PkgId})() @ Base ./loading.jl:2652 [4] mkpidlock(f::Base.var"#__require_prelocked##0#__require_prelocked##1"{Base.PkgId}, at::String, pid::Int32; kwopts::@Kwargs{stale_age::Int64, wait::Bool}) @ FileWatching.Pidfile /opt/julia/share/julia/stdlib/v1.13/FileWatching/src/pidfile.jl:93 [5] #mkpidlock#7 @ /opt/julia/share/julia/stdlib/v1.13/FileWatching/src/pidfile.jl:88 [inlined] [6] trymkpidlock(::Function, ::Vararg{Any}; kwargs::@Kwargs{stale_age::Int64}) @ FileWatching.Pidfile /opt/julia/share/julia/stdlib/v1.13/FileWatching/src/pidfile.jl:114 [7] apply_gr_kw(::NamedTuple, ::GlobalRef, ::Any, ::Vararg{Any}) @ Base ./reflection.jl:1279 [8] #invokelatest_gr#234 @ ./reflection.jl:1287 [inlined] [9] invokelatest_gr @ ./reflection.jl:1281 [inlined] [10] maybe_cachefile_lock(f::Base.var"#__require_prelocked##0#__require_prelocked##1"{Base.PkgId}, pkg::Base.PkgId, srcpath::String; stale_age::Int64) @ Base ./loading.jl:3837 [11] maybe_cachefile_lock @ ./loading.jl:3834 [inlined] [12] __require_prelocked(pkg::Base.PkgId, env::String) @ Base ./loading.jl:2638 [13] _require_prelocked(uuidkey::Base.PkgId, env::String) @ Base ./loading.jl:2466 [14] macro expansion @ ./loading.jl:2394 [inlined] [15] macro expansion @ ./lock.jl:376 [inlined] [16] __require(into::Module, mod::Symbol) @ Base ./loading.jl:2359 [17] require(into::Module, mod::Symbol) @ Base ./loading.jl:2335 [18] top-level scope @ ~/.julia/packages/GPDiffEq/6dnZq/src/GPDiffEq.jl:12 [19] include(mod::Module, _path::String) @ Base ./Base.jl:303 [20] __require_prelocked(pkg::Base.PkgId, env::String) @ Base ./loading.jl:2691 [21] _require_prelocked(uuidkey::Base.PkgId, env::String) @ Base ./loading.jl:2466 [22] macro expansion @ ./loading.jl:2394 [inlined] [23] macro expansion @ ./lock.jl:376 [inlined] [24] __require(into::Module, mod::Symbol) @ Base ./loading.jl:2359 [25] require(into::Module, mod::Symbol) @ Base ./loading.jl:2335 [26] eval(m::Module, e::Any) @ Core ./boot.jl:489 [27] exec_options(opts::Base.JLOptions) @ Base ./client.jl:297 [28] _start() @ Base ./client.jl:563 in expression starting at /home/pkgeval/.julia/packages/GPDiffEq/6dnZq/src/GPDiffEq.jl:1 Loading failed after 711.07s 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 GPDiffEq'`, 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 1390.12s: illegal method overwrites during precompilation