Package evaluation of ExtendableSparse on Julia 1.13.0-DEV.655 (3a5e1f15ec*) started at 2025-05-29T13:32:48.078 ################################################################################ # Set-up # Installing PkgEval dependencies (TestEnv)... Set-up completed after 8.0s ################################################################################ # Installation # Installing ExtendableSparse... Resolving package versions... Updating `~/.julia/environments/v1.13/Project.toml` [95c220a8] + ExtendableSparse v1.7.1 Updating `~/.julia/environments/v1.13/Manifest.toml` [ffbed154] + DocStringExtensions v0.9.4 [95c220a8] + ExtendableSparse v1.7.1 [88f59080] + ILUZero v0.2.0 [6fe1bfb0] + OffsetArrays v1.17.0 [aea7be01] + PrecompileTools v1.3.2 [21216c6a] + Preferences v1.4.3 [e56a9233] + Sparspak v0.3.11 [90137ffa] + StaticArrays v1.9.13 [1e83bf80] + StaticArraysCore v1.4.3 [56f22d72] + Artifacts v1.11.0 [2a0f44e3] + Base64 v1.11.0 [ade2ca70] + Dates v1.11.0 [b77e0a4c] + InteractiveUtils v1.11.0 [ac6e5ff7] + JuliaSyntaxHighlighting v1.12.0 [8f399da3] + Libdl v1.11.0 [37e2e46d] + LinearAlgebra v1.12.0 [56ddb016] + Logging v1.11.0 [d6f4376e] + Markdown v1.11.0 [de0858da] + Printf v1.11.0 [9a3f8284] + Random v1.11.0 [ea8e919c] + SHA v0.7.0 [9e88b42a] + Serialization v1.11.0 [2f01184e] + SparseArrays v1.12.0 [f489334b] + StyledStrings v1.11.0 [4607b0f0] + SuiteSparse [fa267f1f] + TOML v1.0.3 [8dfed614] + Test v1.11.0 [4ec0a83e] + Unicode v1.11.0 [e66e0078] + CompilerSupportLibraries_jll v1.3.0+1 [4536629a] + OpenBLAS_jll v0.3.29+0 [bea87d4a] + SuiteSparse_jll v7.10.1+0 [8e850b90] + libblastrampoline_jll v5.12.0+0 Installation completed after 3.46s ################################################################################ # Precompilation # Precompiling PkgEval dependencies... Precompiling package dependencies... Precompilation completed after 486.06s ################################################################################ # Testing # Testing ExtendableSparse Status `/tmp/jl_ESm4HV/Project.toml` [4f76b812] AMGCLWrap v2.1.0 [2169fc97] AlgebraicMultigrid v1.0.0 [4c88cf16] Aqua v0.8.13 [6e4b80f9] BenchmarkTools v1.6.0 [ae650224] ChunkSplitters v3.1.2 [ffbed154] DocStringExtensions v0.9.4 [7d51a73a] ExplicitImports v1.11.2 [cfc395e8] ExtendableGrids v1.13.1 [95c220a8] ExtendableSparse v1.7.1 [f6369f11] ForwardDiff v1.0.1 [88f59080] ILUZero v0.2.0 [40713840] IncompleteLU v0.2.1 [42fd0dbc] IterativeSolvers v0.9.4 [7ed4a6bd] LinearSolve v3.16.0 [2679e427] Metis v1.5.0 [bdf0d083] MultiFloats v2.3.0 [67456a42] OhMyThreads v0.8.3 [46dd5b70] Pardiso v1.0.1 [f2c3362d] RecursiveFactorization v0.2.23 [e56a9233] Sparspak v0.3.11 [90137ffa] StaticArrays v1.9.13 [37e2e46d] LinearAlgebra v1.12.0 [de0858da] Printf v1.11.0 [9a3f8284] Random v1.11.0 [2f01184e] SparseArrays v1.12.0 [4607b0f0] SuiteSparse [8dfed614] Test v1.11.0 Status `/tmp/jl_ESm4HV/Manifest.toml` [47edcb42] ADTypes v1.14.0 [4f76b812] AMGCLWrap v2.1.0 [1520ce14] AbstractTrees v0.4.5 [7d9f7c33] Accessors v0.1.42 [79e6a3ab] Adapt v4.3.0 [2169fc97] AlgebraicMultigrid v1.0.0 [66dad0bd] AliasTables v1.1.3 [4c88cf16] Aqua v0.8.13 [ec485272] ArnoldiMethod v0.4.0 [4fba245c] ArrayInterface v7.19.0 [4c555306] ArrayLayouts v1.11.1 [198e06fe] BangBang v0.4.4 [6e4b80f9] BenchmarkTools v1.6.0 ⌅ [e2ed5e7c] Bijections v0.1.10 [62783981] BitTwiddlingConvenienceFunctions v0.1.6 [fa961155] CEnum v0.5.0 [2a0fbf3d] CPUSummary v0.2.6 [d360d2e6] ChainRulesCore v1.25.1 [ae650224] ChunkSplitters v3.1.2 [fb6a15b2] CloseOpenIntervals v0.1.13 [944b1d66] CodecZlib v0.7.8 [38540f10] CommonSolve v0.2.4 [bbf7d656] CommonSubexpressions v0.3.1 [f70d9fcc] CommonWorldInvalidations v1.0.0 [34da2185] Compat v4.16.0 [534720e6] CompositeStructs v0.1.5 [a33af91c] CompositionsBase v0.1.2 [2569d6c7] ConcreteStructs v0.2.3 [187b0558] ConstructionBase v1.5.8 [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 [163ba53b] DiffResults v1.1.0 [b552c78f] DiffRules v1.15.1 [ffbed154] DocStringExtensions v0.9.4 [fdbdab4c] ElasticArrays v1.2.12 [4e289a0a] EnumX v1.0.5 [7d51a73a] ExplicitImports v1.11.2 [e2ba6199] ExprTools v0.1.10 [55351af7] ExproniconLite v0.10.14 [cfc395e8] ExtendableGrids v1.13.1 [95c220a8] ExtendableSparse v1.7.1 [1a297f60] FillArrays v1.13.0 [f6369f11] ForwardDiff v1.0.1 [069b7b12] FunctionWrappers v1.1.3 [77dc65aa] FunctionWrappersWrappers v0.1.3 [46192b85] GPUArraysCore v0.2.0 [86223c79] Graphs v1.12.1 [076d061b] HashArrayMappedTries v0.2.0 [3e5b6fbb] HostCPUFeatures v0.1.17 [88f59080] ILUZero v0.2.0 [615f187c] IfElse v0.1.1 [40713840] IncompleteLU v0.2.1 [d25df0c9] Inflate v0.1.5 [22cec73e] InitialValues v0.3.1 [3587e190] InverseFunctions v0.1.17 [92d709cd] IrrationalConstants v0.2.4 [42fd0dbc] IterativeSolvers v0.9.4 [82899510] IteratorInterfaceExtensions v1.0.0 [692b3bcd] JLLWrappers v1.7.0 [682c06a0] JSON v0.21.4 [0f8b85d8] JSON3 v1.14.3 [ae98c720] Jieko v0.2.1 ⌅ [70703baa] JuliaSyntax v0.4.10 [ba0b0d4f] Krylov v0.10.1 [b964fa9f] LaTeXStrings v1.4.0 [10f19ff3] LayoutPointers v0.1.17 [5078a376] LazyArrays v2.6.1 [9c8b4983] LightXML v0.9.1 [7ed4a6bd] LinearSolve v3.16.0 [2ab3a3ac] LogExpFunctions v0.3.29 [bdcacae8] LoopVectorization v0.12.172 [1914dd2f] MacroTools v0.5.16 [d125e4d3] ManualMemory v0.1.8 [2679e427] Metis v1.5.0 [e1d29d7a] Missings v1.2.0 [2e0e35c7] Moshi v0.3.5 [bdf0d083] MultiFloats v2.3.0 [77ba4419] NaNMath v1.1.3 [6fe1bfb0] OffsetArrays v1.17.0 [67456a42] OhMyThreads v0.8.3 [bac558e1] OrderedCollections v1.8.1 [46dd5b70] Pardiso v1.0.1 [69de0a69] Parsers v2.8.3 [f517fe37] Polyester v0.7.18 [1d0040c9] PolyesterWeave v0.2.2 [aea7be01] PrecompileTools v1.3.2 [21216c6a] Preferences v1.4.3 [08abe8d2] PrettyTables v2.4.0 [43287f4e] PtrArrays v1.3.0 [3cdcf5f2] RecipesBase v1.3.4 [731186ca] RecursiveArrayTools v3.33.0 [f2c3362d] RecursiveFactorization v0.2.23 [189a3867] Reexport v1.2.2 [ae029012] Requires v1.3.1 [7e49a35a] RuntimeGeneratedFunctions v0.5.15 [fdea26ae] SIMD v3.7.1 [94e857df] SIMDTypes v0.1.0 [476501e8] SLEEFPirates v0.6.43 [0bca4576] SciMLBase v2.96.0 [c0aeaf25] SciMLOperators v1.3.0 [53ae85a6] SciMLStructures v1.7.0 [7e506255] ScopedValues v1.3.0 [efcf1570] Setfield v1.1.2 [699a6c99] SimpleTraits v0.9.4 [a2af1166] SortingAlgorithms v1.2.1 [a0a7dd2c] SparseMatricesCSR v0.6.9 [e56a9233] Sparspak v0.3.11 [276daf66] SpecialFunctions v2.5.1 [91464d47] StableTasks v0.1.7 [aedffcd0] Static v1.2.0 [0d7ed370] StaticArrayInterface v1.8.0 [90137ffa] StaticArrays v1.9.13 [1e83bf80] StaticArraysCore v1.4.3 [10745b16] Statistics v1.11.1 [82ae8749] StatsAPI v1.7.1 [2913bbd2] StatsBase v0.34.5 [7792a7ef] StrideArraysCore v0.5.7 [892a3eda] StringManipulation v0.4.1 [856f2bd8] StructTypes v1.11.0 [2efcf032] SymbolicIndexingInterface v0.3.40 [3783bdb8] TableTraits v1.0.1 [bd369af6] Tables v1.12.0 [ed4db957] TaskLocalValues v0.1.2 [8290d209] ThreadingUtilities v0.5.4 [3bb67fe8] TranscodingStreams v0.11.3 [d5829a12] TriangularSolve v0.2.1 [3a884ed6] UnPack v1.0.2 [4004b06d] VTKBase v1.0.1 [3d5dd08c] VectorizationBase v0.21.71 [64499a7a] WriteVTK v1.21.2 [e3ba5bb7] AMGCL_C_jll v0.3.0+0 [1d5cc7b8] IntelOpenMP_jll v2025.0.4+0 [1d63c593] LLVMOpenMP_jll v18.1.8+0 [94ce4f54] Libiconv_jll v1.18.0+0 [d00139f3] METIS_jll v5.1.3+0 [856f044c] MKL_jll v2025.0.1+1 [efe28fd5] OpenSpecFun_jll v0.5.6+0 ⌅ [02c8fc9c] XML2_jll v2.13.6+1 ⌅ [28df3c45] boost_jll v1.79.0+3 [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.13.0 [de0858da] Printf v1.11.0 [9abbd945] Profile 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 v2025.5.20 [4536629a] OpenBLAS_jll v0.3.29+0 [05823500] OpenLibm_jll v0.8.5+0 [458c3c95] OpenSSL_jll v3.5.0+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 ⌅ have new versions available but compatibility constraints restrict them from upgrading. Testing Running tests... Precompiling packages... 16723.9 ms ✓ ForwardDiff 1 dependency successfully precompiled in 17 seconds. 18 already precompiled. Precompiling packages... 4211.8 ms ✓ ForwardDiff → ForwardDiffStaticArraysExt 1 dependency successfully precompiled in 4 seconds. 21 already precompiled. Precompiling packages... 43550.8 ms ✓ ExplicitImports 1 dependency successfully precompiled in 44 seconds. 31 already precompiled. Test Summary: | Pass Total Time ExplicitImports | 2 2 1m05.2s Precompiling packages... 5630.2 ms ✓ StatsBase 4206.6 ms ✓ ArnoldiMethod 1767.2 ms ✓ WriteVTK 10812.6 ms ✓ Graphs 11629.1 ms ✓ ExtendableGrids 5 dependencies successfully precompiled in 34 seconds. 57 already precompiled. Precompiling packages... 4957.3 ms ✓ Metis 1 dependency successfully precompiled in 5 seconds. 11 already precompiled. Precompiling packages... 3835.6 ms ✓ Metis → MetisGraphs 4643.9 ms ✓ ExtendableGrids → ExtendableGridsMetisExt 2 dependencies successfully precompiled in 9 seconds. 65 already precompiled. Precompiling packages... 869.7 ms ✓ LogExpFunctions → LogExpFunctionsInverseFunctionsExt 1 dependency successfully precompiled in 1 seconds. 4 already precompiled. Precompiling packages... 1294.1 ms ✓ StaticArrayInterface → StaticArrayInterfaceOffsetArraysExt 18274.2 ms ✓ VectorizationBase 6110.0 ms ✓ SLEEFPirates 44789.3 ms ✓ LoopVectorization 15659.8 ms ✓ TriangularSolve Info Given RecursiveFactorization was explicitly requested, output will be shown live  WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in initialize_task(Any) at /home/pkgeval/.julia/packages/ThreadingUtilities/AsFET/src/ThreadingUtilities.jl WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in _generic_lufact!(Any, Base.Val{Pivot}, Any, Any) where {Pivot} at /home/pkgeval/.julia/packages/RecursiveFactorization/zhyWn/src/lu.jl WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in _turbo_!(Base.Val{var"#UNROLL#"}, Base.Val{var"#OPS#"}, Base.Val{var"#ARF#"}, Base.Val{var"#AM#"}, Base.Val{var"#LPSYM#"}, Base.Val{Tuple{var"#LB#", var"#V#"}}, Vararg{Any, var"#num#vargs#"}) where {var"#UNROLL#", var"#OPS#", var"#ARF#", var"#AM#", var"#LPSYM#", var"#LB#", var"#V#", var"#num#vargs#"} at /home/pkgeval/.julia/packages/LoopVectorization/ImqiY/src/reconstruct_loopset.jl WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in _ldiv_L!(Any, Any, Base.Val{UNIT}, Type{Args}, Vararg{Any, K}) where {UNIT, Args, K} at /home/pkgeval/.julia/packages/TriangularSolve/rwyRY/src/TriangularSolve.jl WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in ldiv_remainder!(Any, Any, Any, Any, Any, Any, Any, Static.StaticInt{W}, Base.Val{UNIT}) where {W, UNIT} at /home/pkgeval/.julia/packages/TriangularSolve/rwyRY/src/TriangularSolve.jl WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in ldiv_solve_W!(Any, Any, Any, Any, Static.StaticInt{W}, Base.Val{UNIT}, Static.StaticInt{R}) where {W, UNIT, R} at /home/pkgeval/.julia/packages/TriangularSolve/rwyRY/src/TriangularSolve.jl WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in BdivU_small_kern!(LayoutPointers.AbstractStridedPointer{T, N, C, B, R, X, O} where O<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where X<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where R where B where C where N, Any, LayoutPointers.AbstractStridedPointer{T, N, C, B, R, X, O} where O<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where X<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where R where B where C where N, LayoutPointers.AbstractStridedPointer{T, N, C, B, R, X, O} where O<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where X<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where R where B where C where N, Int64, VectorizationBase.AbstractMask{W, U} where U<:Union{UInt128, UInt16, UInt32, UInt64, UInt8}, Base.Val{UNIT}) where {T, UNIT, W} at /home/pkgeval/.julia/packages/TriangularSolve/rwyRY/src/TriangularSolve.jl WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in ldiv_solve_W!(Any, Any, Any, Any, Static.StaticInt{W}, Base.Val{UNIT}) where {W, UNIT} at /home/pkgeval/.julia/packages/TriangularSolve/rwyRY/src/TriangularSolve.jl WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in ldiv_solve_W_u!(Any, Any, Any, Any, Static.StaticInt{W}, Static.StaticInt{U}, Base.Val{UNIT}) where {W, U, UNIT} at /home/pkgeval/.julia/packages/TriangularSolve/rwyRY/src/TriangularSolve.jl WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in BdivU_small_kern_u!(LayoutPointers.AbstractStridedPointer{T, N, C, B, R, X, O} where O<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where X<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where R where B where C where N, Any, LayoutPointers.AbstractStridedPointer{T, N, C, B, R, X, O} where O<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where X<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where R where B where C where N, LayoutPointers.AbstractStridedPointer{T, N, C, B, R, X, O} where O<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where X<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where R where B where C where N, Int64, Static.StaticInt{U}, Base.Val{UNIT}, Static.StaticInt{W}) where {T, U, UNIT, W} at /home/pkgeval/.julia/packages/TriangularSolve/rwyRY/src/TriangularSolve.jl WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in rdiv_block_MandN!(LayoutPointers.AbstractStridedPointer{T, var"#s41", XC, B, R, X, O} where O<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, var"#s41"}} where X<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, var"#s41"}} where R where B where var"#s41", LayoutPointers.AbstractStridedPointer{T, var"#s39", XA, B, R, X, O} where O<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, var"#s39"}} where X<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, var"#s39"}} where R where B where var"#s39", LayoutPointers.AbstractStridedPointer{T, var"#s6", XU, B, R, X, O} where O<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, var"#s6"}} where X<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, var"#s6"}} where R where B where var"#s6", Any, Any, Base.Val{UNIT}) where {T, UNIT, XC, XA, XU} at /home/pkgeval/.julia/packages/TriangularSolve/rwyRY/src/TriangularSolve.jl WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in rdiv_block_N!(LayoutPointers.AbstractStridedPointer{T, N, C, B, R, X, O} where O<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where X<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where R where B where C where N, Any, Any, Any, Any, Base.Val{UNIT}, Any) where {T, UNIT} at /home/pkgeval/.julia/packages/TriangularSolve/rwyRY/src/TriangularSolve.jl WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in reckernel!(AbstractArray{T, 2}, Base.Val{Pivot}, Any, Any, Any, Any, Any, Any) where {T, Pivot} at /home/pkgeval/.julia/packages/RecursiveFactorization/zhyWn/src/lu.jl 46093.4 ms ✓ RecursiveFactorization 6 dependencies successfully precompiled in 132 seconds. 36 already precompiled. 4 dependencies had output during precompilation: ┌ LoopVectorization │ WARNING: llvmcall with integer pointers is deprecated. │ Use actual pointers instead, replacing i32 or i64 with i8* or ptr │ in initialize_task(Any) at /home/pkgeval/.julia/packages/ThreadingUtilities/AsFET/src/ThreadingUtilities.jl │ WARNING: llvmcall with integer pointers is deprecated. │ Use actual pointers instead, replacing i32 or i64 with i8* or ptr │ in _vreduce(typeof(Base.:(+)), Any) at /home/pkgeval/.julia/packages/LoopVectorization/ImqiY/src/simdfunctionals/mapreduce.jl └ ┌ VectorizationBase │ 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`. └ ┌ RecursiveFactorization │ [Output was shown above] └ ┌ TriangularSolve │ WARNING: llvmcall with integer pointers is deprecated. │ Use actual pointers instead, replacing i32 or i64 with i8* or ptr │ in initialize_task(Any) at /home/pkgeval/.julia/packages/ThreadingUtilities/AsFET/src/ThreadingUtilities.jl └ WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in initialize_task(Any) at /home/pkgeval/.julia/packages/ThreadingUtilities/AsFET/src/ThreadingUtilities.jl Precompiling packages... 1924.3 ms ✓ StaticArrayInterface → StaticArrayInterfaceStaticArraysExt 1 dependency successfully precompiled in 2 seconds. 20 already precompiled. Precompiling packages... Info Given SpecialFunctionsExt was explicitly requested, output will be shown live  WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in initialize_task(Any) at /home/pkgeval/.julia/packages/ThreadingUtilities/AsFET/src/ThreadingUtilities.jl 6176.0 ms ✓ LoopVectorization → SpecialFunctionsExt 1 dependency successfully precompiled in 6 seconds. 44 already precompiled. 1 dependency had output during precompilation: ┌ LoopVectorization → SpecialFunctionsExt │ [Output was shown above] └ WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in _generic_lufact!(Any, Base.Val{Pivot}, Any, Any) where {Pivot} at /home/pkgeval/.julia/packages/RecursiveFactorization/zhyWn/src/lu.jl WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in _turbo_!(Base.Val{var"#UNROLL#"}, Base.Val{var"#OPS#"}, Base.Val{var"#ARF#"}, Base.Val{var"#AM#"}, Base.Val{var"#LPSYM#"}, Base.Val{Tuple{var"#LB#", var"#V#"}}, Vararg{Any, var"#num#vargs#"}) where {var"#UNROLL#", var"#OPS#", var"#ARF#", var"#AM#", var"#LPSYM#", var"#LB#", var"#V#", var"#num#vargs#"} at /home/pkgeval/.julia/packages/LoopVectorization/ImqiY/src/reconstruct_loopset.jl WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in _ldiv_L!(Any, Any, Base.Val{UNIT}, Type{Args}, Vararg{Any, K}) where {UNIT, Args, K} at /home/pkgeval/.julia/packages/TriangularSolve/rwyRY/src/TriangularSolve.jl WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in ldiv_remainder!(Any, Any, Any, Any, Any, Any, Any, Static.StaticInt{W}, Base.Val{UNIT}) where {W, UNIT} at /home/pkgeval/.julia/packages/TriangularSolve/rwyRY/src/TriangularSolve.jl WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in ldiv_solve_W!(Any, Any, Any, Any, Static.StaticInt{W}, Base.Val{UNIT}, Static.StaticInt{R}) where {W, UNIT, R} at /home/pkgeval/.julia/packages/TriangularSolve/rwyRY/src/TriangularSolve.jl WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in BdivU_small_kern!(LayoutPointers.AbstractStridedPointer{T, N, C, B, R, X, O} where O<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where X<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where R where B where C where N, Any, LayoutPointers.AbstractStridedPointer{T, N, C, B, R, X, O} where O<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where X<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where R where B where C where N, LayoutPointers.AbstractStridedPointer{T, N, C, B, R, X, O} where O<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where X<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where R where B where C where N, Int64, VectorizationBase.AbstractMask{W, U} where U<:Union{UInt128, UInt16, UInt32, UInt64, UInt8}, Base.Val{UNIT}) where {T, UNIT, W} at /home/pkgeval/.julia/packages/TriangularSolve/rwyRY/src/TriangularSolve.jl WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in ldiv_solve_W!(Any, Any, Any, Any, Static.StaticInt{W}, Base.Val{UNIT}) where {W, UNIT} at /home/pkgeval/.julia/packages/TriangularSolve/rwyRY/src/TriangularSolve.jl WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in ldiv_solve_W_u!(Any, Any, Any, Any, Static.StaticInt{W}, Static.StaticInt{U}, Base.Val{UNIT}) where {W, U, UNIT} at /home/pkgeval/.julia/packages/TriangularSolve/rwyRY/src/TriangularSolve.jl WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in BdivU_small_kern_u!(LayoutPointers.AbstractStridedPointer{T, N, C, B, R, X, O} where O<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where X<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where R where B where C where N, Any, LayoutPointers.AbstractStridedPointer{T, N, C, B, R, X, O} where O<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where X<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where R where B where C where N, LayoutPointers.AbstractStridedPointer{T, N, C, B, R, X, O} where O<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where X<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where R where B where C where N, Int64, Static.StaticInt{U}, Base.Val{UNIT}, Static.StaticInt{W}) where {T, U, UNIT, W} at /home/pkgeval/.julia/packages/TriangularSolve/rwyRY/src/TriangularSolve.jl WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in rdiv_block_MandN!(LayoutPointers.AbstractStridedPointer{T, var"#s41", XC, B, R, X, O} where O<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, var"#s41"}} where X<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, var"#s41"}} where R where B where var"#s41", LayoutPointers.AbstractStridedPointer{T, var"#s39", XA, B, R, X, O} where O<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, var"#s39"}} where X<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, var"#s39"}} where R where B where var"#s39", LayoutPointers.AbstractStridedPointer{T, var"#s6", XU, B, R, X, O} where O<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, var"#s6"}} where X<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, var"#s6"}} where R where B where var"#s6", Any, Any, Base.Val{UNIT}) where {T, UNIT, XC, XA, XU} at /home/pkgeval/.julia/packages/TriangularSolve/rwyRY/src/TriangularSolve.jl WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in rdiv_block_N!(LayoutPointers.AbstractStridedPointer{T, N, C, B, R, X, O} where O<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where X<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where R where B where C where N, Any, Any, Any, Any, Base.Val{UNIT}, Any) where {T, UNIT} at /home/pkgeval/.julia/packages/TriangularSolve/rwyRY/src/TriangularSolve.jl WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in reckernel!(AbstractArray{T, 2}, Base.Val{Pivot}, Any, Any, Any, Any, Any, Any) where {T, Pivot} at /home/pkgeval/.julia/packages/RecursiveFactorization/zhyWn/src/lu.jl num_partitions_per_color(pgrid) = [2, 4, 4] num_partitions_per_color(pgrid) = [4, 4, 4, 3] num_partitions_per_color(pgrid) = [6, 6, 6, 2] num_partitions_per_color(pgrid) = [2, 4, 4] [ Info: Check if every node belongs to one of the cell partitions... [ Info: Check if no node belongs to two cell partitions of the same color at once... [ Info: Check if no node belongs to two node partitions of the same color at once... [ Info: Check if no node is a neighbor of nodes from two node partitions of the same color... num_partitions_per_color(pgrid) = [4, 4, 4, 3] [ Info: Check if every node belongs to one of the cell partitions... [ Info: Check if no node belongs to two cell partitions of the same color at once... [ Info: Check if no node belongs to two node partitions of the same color at once... [ Info: Check if no node is a neighbor of nodes from two node partitions of the same color... num_partitions_per_color(pgrid) = [6, 6, 6, 2] [ Info: Check if every node belongs to one of the cell partitions... [ Info: Check if no node belongs to two cell partitions of the same color at once... [ Info: Check if no node belongs to two node partitions of the same color at once... [ Info: Check if no node is a neighbor of nodes from two node partitions of the same color... [ Info: Check if every node belongs to one of the cell partitions... [ Info: Check if no node belongs to two cell partitions of the same color at once... [ Info: Check if no node belongs to two node partitions of the same color at once... [ Info: Check if no node is a neighbor of nodes from two node partitions of the same color... diff = 1.3322676295501878e-15 [ Info: Check if every node belongs to one of the cell partitions... [ Info: Check if no node belongs to two cell partitions of the same color at once... [ Info: Check if no node belongs to two node partitions of the same color at once... [ Info: Check if no node is a neighbor of nodes from two node partitions of the same color... diff = 1.2212453270876722e-15 [ Info: Check if every node belongs to one of the cell partitions... [ Info: Check if no node belongs to two cell partitions of the same color at once... [ Info: Check if no node belongs to two node partitions of the same color at once... [ Info: Check if no node is a neighbor of nodes from two node partitions of the same color... diff = 1.7763568394002505e-15 num_partitions_per_color(pgrid) = [3, 3, 4] num_partitions_per_color(pgrid) = [4, 4, 6, 1] num_partitions_per_color(pgrid) = [7, 5, 5, 3] num_partitions_per_color(pgrid) = [3, 3, 4] [ Info: Check if every node belongs to one of the cell partitions... [ Info: Check if no node belongs to two cell partitions of the same color at once... [ Info: Check if no node belongs to two node partitions of the same color at once... [ Info: Check if no node is a neighbor of nodes from two node partitions of the same color... num_partitions_per_color(pgrid) = [4, 4, 6, 1] [ Info: Check if every node belongs to one of the cell partitions... [ Info: Check if no node belongs to two cell partitions of the same color at once... [ Info: Check if no node belongs to two node partitions of the same color at once... [ Info: Check if no node is a neighbor of nodes from two node partitions of the same color... num_partitions_per_color(pgrid) = [7, 5, 5, 3] [ Info: Check if every node belongs to one of the cell partitions... [ Info: Check if no node belongs to two cell partitions of the same color at once... [ Info: Check if no node belongs to two node partitions of the same color at once... [ Info: Check if no node is a neighbor of nodes from two node partitions of the same color... [ Info: Check if every node belongs to one of the cell partitions... [ Info: Check if no node belongs to two cell partitions of the same color at once... [ Info: Check if no node belongs to two node partitions of the same color at once... [ Info: Check if no node is a neighbor of nodes from two node partitions of the same color... diff = 1.3322676295501878e-15 [ Info: Check if every node belongs to one of the cell partitions... [ Info: Check if no node belongs to two cell partitions of the same color at once... [ Info: Check if no node belongs to two node partitions of the same color at once... [ Info: Check if no node is a neighbor of nodes from two node partitions of the same color... diff = 8.881784197001252e-16 [ Info: Check if every node belongs to one of the cell partitions... [ Info: Check if no node belongs to two cell partitions of the same color at once... [ Info: Check if no node belongs to two node partitions of the same color at once... [ Info: Check if no node is a neighbor of nodes from two node partitions of the same color... diff = 1.1102230246251565e-15 Test Summary: | Pass Total Time Parallel | 36 36 5m35.7s Test Summary: | Pass Total Time Constructors | 23 23 5.9s WARNING: Method definition rand(Random.AbstractRNG, Random.SamplerType{ForwardDiff.Dual{T, V, N}}) where {T, V, N} in module test_constructors at /home/pkgeval/.julia/packages/ExtendableSparse/pjofE/test/test_constructors.jl:11 overwritten in module test_copymethods at /home/pkgeval/.julia/packages/ExtendableSparse/pjofE/test/test_copymethods.jl:10. Test Summary: | Total Time Copy-Methods | 0 4.5s Test Summary: | Pass Total Time Updates | 18 18 6.7s Test Summary: | Pass Total Time Assembly | 19 19 3.9s Float64 (1000,1,1): CSC 5.0686 EXT 0.4443 LNK 0.1699 Float64 (100,100,1): CSC 596.3586 EXT 8.7802 LNK 3.6181 Float64 (20,20,20): CSC 675.4024 EXT 11.7413 LNK 4.8489 MultiFloat{Float64, 2} (1000,1,1): CSC 3.9525 EXT 0.5362 LNK 0.2268 MultiFloat{Float64, 2} (100,100,1): CSC 602.3632 EXT 10.8276 LNK 4.8859 MultiFloat{Float64, 2} (20,20,20): CSC 566.1203 EXT 13.3397 LNK 6.2694 ForwardDiff.Dual{Float64, Float64, 1} (1000,1,1): CSC 4.5023 EXT 0.5155 LNK 0.1868 ForwardDiff.Dual{Float64, Float64, 1} (100,100,1): CSC 635.4167 EXT 9.6261 LNK 3.7035 ForwardDiff.Dual{Float64, Float64, 1} (20,20,20): CSC 561.1430 EXT 11.6515 LNK 5.0097 Test Summary: | Pass Total Time Construction timings | 9 9 2m13.8s Test Summary: | Pass Total Time Operations | 25 25 18.0s Test Summary: | Pass Total Time fdrand | 36 36 1m05.4s [ Info: Float32: [ Info: Float64: [ Info: MultiFloat{Float64, 1}: [ Info: MultiFloat{Float64, 2}: [ Info: ForwardDiff.Dual{Float64, Float64, 1}: [ Info: ForwardDiff.Dual{Float64, Float64, 2}: Test Summary: | Pass Total Time Backslash | 18 18 2m03.3s Test Summary: | Pass Total Time Dirichlet | 6 6 1.7s Precompiling packages... 1149.7 ms ✓ SciMLOperators → SciMLOperatorsStaticArraysCoreExt 5190.3 ms ✓ SymbolicIndexingInterface 6219.7 ms ✓ RecursiveArrayTools 3629.0 ms ✓ RecursiveArrayTools → RecursiveArrayToolsSparseArraysExt 26554.7 ms ✓ SciMLBase 4586.1 ms ✓ SciMLBase → SciMLBaseChainRulesCoreExt Info Given LinearSolve was explicitly requested, output will be shown live  WARNING: Detected access to binding `LinearSolve.defaultalg_symbol` 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. To make this warning an error, and hence obtain a stack trace, use `julia --depwarn=error`. 20994.0 ms ✓ LinearSolve 10950.7 ms ✓ LinearSolve → LinearSolveSparseArraysExt 8 dependencies successfully precompiled in 80 seconds. 101 already precompiled. 1 dependency had output during precompilation: ┌ LinearSolve │ [Output was shown above] └ Precompiling packages... 3475.3 ms ✓ LazyArrays → LazyArraysStaticArraysExt 1 dependency successfully precompiled in 4 seconds. 17 already precompiled. Precompiling packages... 3719.6 ms ✓ RecursiveArrayTools → RecursiveArrayToolsForwardDiffExt 1 dependency successfully precompiled in 4 seconds. 58 already precompiled. Precompiling packages... 1697.5 ms ✓ StaticArrays → StaticArraysChainRulesCoreExt 1 dependency successfully precompiled in 2 seconds. 12 already precompiled. Precompiling packages... 3185.7 ms ✓ LogExpFunctions → LogExpFunctionsChainRulesCoreExt 1 dependency successfully precompiled in 3 seconds. 11 already precompiled. Precompiling packages... 4356.7 ms ✓ SpecialFunctions → SpecialFunctionsChainRulesCoreExt 1 dependency successfully precompiled in 4 seconds. 17 already precompiled. Precompiling packages... Info Given ForwardDiffExt was explicitly requested, output will be shown live  WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in initialize_task(Any) at /home/pkgeval/.julia/packages/ThreadingUtilities/AsFET/src/ThreadingUtilities.jl 6802.8 ms ✓ LoopVectorization → ForwardDiffExt 1 dependency successfully precompiled in 7 seconds. 57 already precompiled. 1 dependency had output during precompilation: ┌ LoopVectorization → ForwardDiffExt │ [Output was shown above] └ Precompiling packages... 22207.8 ms ✓ LinearSolve → LinearSolveSparspakExt 7339.5 ms ✓ ExtendableSparse → ExtendableSparseLinearSolveExt 2 dependencies successfully precompiled in 30 seconds. 125 already precompiled. Precompiling packages... Info Given LinearSolveRecursiveFactorizationExt was explicitly requested, output will be shown live  WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in initialize_task(Any) at /home/pkgeval/.julia/packages/ThreadingUtilities/AsFET/src/ThreadingUtilities.jl 9121.5 ms ✓ LinearSolve → LinearSolveRecursiveFactorizationExt 1 dependency successfully precompiled in 10 seconds. 133 already precompiled. 1 dependency had output during precompilation: ┌ LinearSolve → LinearSolveRecursiveFactorizationExt │ [Output was shown above] └ Precompiling packages... 2694.6 ms ✓ CompositeStructs 6024.7 ms ✓ AMGCLWrap 2 dependencies successfully precompiled in 9 seconds. 42 already precompiled. Precompiling packages... 3088.5 ms ✓ ExtendableSparse → ExtendableSparseAMGCLWrapExt 1 dependency successfully precompiled in 3 seconds. 52 already precompiled. Precompiling packages... 6650.0 ms ✓ AMGCLWrap → AMGCLWrapLinearSolveExt 1 dependency successfully precompiled in 7 seconds. 120 already precompiled. Precompiling packages... 2395.2 ms ✓ ExtendableSparse → ExtendableSparseIncompleteLUExt 1 dependency successfully precompiled in 3 seconds. 25 already precompiled. Precompiling packages... 7509.9 ms ✓ AlgebraicMultigrid 1 dependency successfully precompiled in 8 seconds. 109 already precompiled. Precompiling packages... 7451.5 ms ✓ ExtendableSparse → ExtendableSparseAlgebraicMultigridExt 1 dependency successfully precompiled in 8 seconds. 128 already precompiled. Precompiling packages... 6047.8 ms ✓ ExtendableSparse → ExtendableSparsePardisoExt 1 dependency successfully precompiled in 6 seconds. 46 already precompiled. Precompiling packages... 10427.4 ms ✓ LinearSolve → LinearSolvePardisoExt 1 dependency successfully precompiled in 11 seconds. 110 already precompiled. Factorizations: Error During Test at /home/pkgeval/.julia/packages/ExtendableSparse/pjofE/test/test_linearsolve.jl:78 Test threw exception Expression: test_ls2(Float64, 25, 40, 1, linsolver = factorization) ArgumentError: pattern of the matrix changed Stacktrace: [1] umferror(status::Int32) @ SparseArrays.UMFPACK /opt/julia/share/julia/stdlib/v1.13/SparseArrays/src/solvers/umfpack.jl:125 [2] macro expansion @ /opt/julia/share/julia/stdlib/v1.13/SparseArrays/src/solvers/umfpack.jl:639 [inlined] [3] macro expansion @ ./lock.jl:376 [inlined] [4] umfpack_numeric!(U::SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}; reuse_numeric::Bool, q::Nothing) @ SparseArrays.UMFPACK /opt/julia/share/julia/stdlib/v1.13/SparseArrays/src/solvers/umfpack.jl:630 [5] umfpack_numeric! @ /opt/julia/share/julia/stdlib/v1.13/SparseArrays/src/solvers/umfpack.jl:629 [inlined] [6] lu!(F::SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}; check::Bool, reuse_symbolic::Bool, q::Nothing) @ SparseArrays.UMFPACK /opt/julia/share/julia/stdlib/v1.13/SparseArrays/src/solvers/umfpack.jl:493 [7] lu! @ /opt/julia/share/julia/stdlib/v1.13/SparseArrays/src/solvers/umfpack.jl:489 [inlined] [8] lu!(F::SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}, S::SparseMatrixCSC{Float64, Int64}; check::Bool, reuse_symbolic::Bool, q::Nothing) @ SparseArrays.UMFPACK /opt/julia/share/julia/stdlib/v1.13/SparseArrays/src/solvers/umfpack.jl:486 [9] lu! @ /opt/julia/share/julia/stdlib/v1.13/SparseArrays/src/solvers/umfpack.jl:460 [inlined] [10] solve!(cache::LinearSolve.LinearCache{ExtendableSparseMatrixCSC{Float64, Int64}, Vector{Float64}, Vector{Float64}, SciMLBase.NullParameters, LinearSolve.UMFPACKFactorization, SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}, SciMLOperators.IdentityOperator, SciMLOperators.IdentityOperator, Float64, Bool, LinearSolve.LinearSolveAdjoint{Missing}}, alg::LinearSolve.UMFPACKFactorization; kwargs::@Kwargs{}) @ LinearSolveSparseArraysExt ~/.julia/packages/LinearSolve/r8pCv/ext/LinearSolveSparseArraysExt.jl:153 [11] solve! @ ~/.julia/packages/LinearSolve/r8pCv/ext/LinearSolveSparseArraysExt.jl:139 [inlined] [12] #solve!#11 @ ~/.julia/packages/LinearSolve/r8pCv/src/common.jl:299 [inlined] [13] solve! @ ~/.julia/packages/LinearSolve/r8pCv/src/common.jl:298 [inlined] [14] #solve#10 @ ~/.julia/packages/LinearSolve/r8pCv/src/common.jl:295 [inlined] [15] solve(::SciMLBase.LinearProblem{Nothing, true, ExtendableSparseMatrixCSC{Float64, Int64}, Vector{Float64}, SciMLBase.NullParameters, @Kwargs{}}, ::LinearSolve.UMFPACKFactorization) @ LinearSolve ~/.julia/packages/LinearSolve/r8pCv/src/common.jl:293 [16] test_ls2(T::Type, k::Int64, l::Int64, m::Int64; linsolver::LinearSolve.UMFPACKFactorization) @ Main.test_linearsolve ~/.julia/packages/ExtendableSparse/pjofE/test/test_linearsolve.jl:32 [17] eval_test_function(func::Any, args::Any, kwargs::Any, quoted_func::Union{Expr, Symbol}, source::LineNumberNode, negate::Bool) @ Test /opt/julia/share/julia/stdlib/v1.13/Test/src/Test.jl:373 [18] macro expansion @ /opt/julia/share/julia/stdlib/v1.13/Test/src/Test.jl:727 [inlined] [19] macro expansion @ ~/.julia/packages/ExtendableSparse/pjofE/test/test_linearsolve.jl:78 [inlined] [20] macro expansion @ /opt/julia/share/julia/stdlib/v1.13/Test/src/Test.jl:1833 [inlined] [21] top-level scope @ ~/.julia/packages/ExtendableSparse/pjofE/test/test_linearsolve.jl:71 Factorizations: Error During Test at /home/pkgeval/.julia/packages/ExtendableSparse/pjofE/test/test_linearsolve.jl:79 Test threw exception Expression: test_ls2(Float64, 100, 1, 1, linsolver = factorization) ArgumentError: pattern of the matrix changed Stacktrace: [1] umferror(status::Int32) @ SparseArrays.UMFPACK /opt/julia/share/julia/stdlib/v1.13/SparseArrays/src/solvers/umfpack.jl:125 [2] macro expansion @ /opt/julia/share/julia/stdlib/v1.13/SparseArrays/src/solvers/umfpack.jl:639 [inlined] [3] macro expansion @ ./lock.jl:376 [inlined] [4] umfpack_numeric!(U::SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}; reuse_numeric::Bool, q::Nothing) @ SparseArrays.UMFPACK /opt/julia/share/julia/stdlib/v1.13/SparseArrays/src/solvers/umfpack.jl:630 [5] umfpack_numeric! @ /opt/julia/share/julia/stdlib/v1.13/SparseArrays/src/solvers/umfpack.jl:629 [inlined] [6] lu!(F::SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}; check::Bool, reuse_symbolic::Bool, q::Nothing) @ SparseArrays.UMFPACK /opt/julia/share/julia/stdlib/v1.13/SparseArrays/src/solvers/umfpack.jl:493 [7] lu! @ /opt/julia/share/julia/stdlib/v1.13/SparseArrays/src/solvers/umfpack.jl:489 [inlined] [8] lu!(F::SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}, S::SparseMatrixCSC{Float64, Int64}; check::Bool, reuse_symbolic::Bool, q::Nothing) @ SparseArrays.UMFPACK /opt/julia/share/julia/stdlib/v1.13/SparseArrays/src/solvers/umfpack.jl:486 [9] lu! @ /opt/julia/share/julia/stdlib/v1.13/SparseArrays/src/solvers/umfpack.jl:460 [inlined] [10] solve!(cache::LinearSolve.LinearCache{ExtendableSparseMatrixCSC{Float64, Int64}, Vector{Float64}, Vector{Float64}, SciMLBase.NullParameters, LinearSolve.UMFPACKFactorization, SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}, SciMLOperators.IdentityOperator, SciMLOperators.IdentityOperator, Float64, Bool, LinearSolve.LinearSolveAdjoint{Missing}}, alg::LinearSolve.UMFPACKFactorization; kwargs::@Kwargs{}) @ LinearSolveSparseArraysExt ~/.julia/packages/LinearSolve/r8pCv/ext/LinearSolveSparseArraysExt.jl:153 [11] solve! @ ~/.julia/packages/LinearSolve/r8pCv/ext/LinearSolveSparseArraysExt.jl:139 [inlined] [12] #solve!#11 @ ~/.julia/packages/LinearSolve/r8pCv/src/common.jl:299 [inlined] [13] solve! @ ~/.julia/packages/LinearSolve/r8pCv/src/common.jl:298 [inlined] [14] #solve#10 @ ~/.julia/packages/LinearSolve/r8pCv/src/common.jl:295 [inlined] [15] solve(::SciMLBase.LinearProblem{Nothing, true, ExtendableSparseMatrixCSC{Float64, Int64}, Vector{Float64}, SciMLBase.NullParameters, @Kwargs{}}, ::LinearSolve.UMFPACKFactorization) @ LinearSolve ~/.julia/packages/LinearSolve/r8pCv/src/common.jl:293 [16] test_ls2(T::Type, k::Int64, l::Int64, m::Int64; linsolver::LinearSolve.UMFPACKFactorization) @ Main.test_linearsolve ~/.julia/packages/ExtendableSparse/pjofE/test/test_linearsolve.jl:32 [17] eval_test_function(func::Any, args::Any, kwargs::Any, quoted_func::Union{Expr, Symbol}, source::LineNumberNode, negate::Bool) @ Test /opt/julia/share/julia/stdlib/v1.13/Test/src/Test.jl:373 [18] macro expansion @ /opt/julia/share/julia/stdlib/v1.13/Test/src/Test.jl:727 [inlined] [19] macro expansion @ ~/.julia/packages/ExtendableSparse/pjofE/test/test_linearsolve.jl:79 [inlined] [20] macro expansion @ /opt/julia/share/julia/stdlib/v1.13/Test/src/Test.jl:1833 [inlined] [21] top-level scope @ ~/.julia/packages/ExtendableSparse/pjofE/test/test_linearsolve.jl:71 Test Summary: | Pass Error Total Time LinearSolve | 119 2 121 6m15.4s Sparspak | 30 30 48.0s Factorizations | 22 2 24 17.7s iterations | 54 54 33.5s block preconditioning | 13 13 1m02.6s RNG of the outermost testset: Random.Xoshiro(0x3aabc5482a42c673, 0x5a27babda62ae2a3, 0x82fb0f96a9320ea1, 0x8b8966f0d5235ffe, 0xa8cc14083eb55773) ERROR: LoadError: Some tests did not pass: 119 passed, 0 failed, 2 errored, 0 broken. in expression starting at /home/pkgeval/.julia/packages/ExtendableSparse/pjofE/test/alltests.jl:81 in expression starting at /home/pkgeval/.julia/packages/ExtendableSparse/pjofE/test/runtests.jl:2 Testing failed after 1230.02s ERROR: LoadError: Package ExtendableSparse errored during testing Stacktrace: [1] pkgerror(msg::String) @ Pkg.Types /opt/julia/share/julia/stdlib/v1.13/Pkg/src/Types.jl:68 [2] test(ctx::Pkg.Types.Context, pkgs::Vector{PackageSpec}; coverage::Bool, julia_args::Cmd, test_args::Cmd, test_fn::Nothing, force_latest_compatible_version::Bool, allow_earlier_backwards_compatible_versions::Bool, allow_reresolve::Bool) @ Pkg.Operations /opt/julia/share/julia/stdlib/v1.13/Pkg/src/Operations.jl:2421 [3] test @ /opt/julia/share/julia/stdlib/v1.13/Pkg/src/Operations.jl:2276 [inlined] [4] test(ctx::Pkg.Types.Context, pkgs::Vector{PackageSpec}; coverage::Bool, test_fn::Nothing, julia_args::Cmd, test_args::Cmd, force_latest_compatible_version::Bool, allow_earlier_backwards_compatible_versions::Bool, allow_reresolve::Bool, kwargs::@Kwargs{io::IOContext{IO}}) @ Pkg.API /opt/julia/share/julia/stdlib/v1.13/Pkg/src/API.jl:498 [5] test(pkgs::Vector{PackageSpec}; io::IOContext{IO}, kwargs::@Kwargs{julia_args::Cmd}) @ Pkg.API /opt/julia/share/julia/stdlib/v1.13/Pkg/src/API.jl:164 [6] test(pkgs::Vector{String}; kwargs::@Kwargs{julia_args::Cmd}) @ Pkg.API /opt/julia/share/julia/stdlib/v1.13/Pkg/src/API.jl:152 [7] test @ /opt/julia/share/julia/stdlib/v1.13/Pkg/src/API.jl:152 [inlined] [8] #test#81 @ /opt/julia/share/julia/stdlib/v1.13/Pkg/src/API.jl:151 [inlined] [9] top-level scope @ /PkgEval.jl/scripts/evaluate.jl:219 [10] include(mod::Module, _path::String) @ Base ./Base.jl:309 [11] exec_options(opts::Base.JLOptions) @ Base ./client.jl:331 [12] _start() @ Base ./client.jl:564 in expression starting at /PkgEval.jl/scripts/evaluate.jl:210 PkgEval failed after 1753.09s: package tests unexpectedly errored