Long compile time with register_symbolic for many arguments with only 2 untyped arguments

[mx-p9a]

This is related to SciML/ModelingToolkit.jl#2251. Per this comment I would have expected that the compile time only grows with the number of untyped arguments, but that's not necessarily what I am seeing.

For this MWE:

# MWE for @register_symbolic compile time with many arguments
# Related issue: https://github.com/SciML/ModelingToolkit.jl/issues/2251

using ModelingToolkit
using ModelingToolkit: t_nounits as t

# 4 arguments
f4(a::Float64, b::Float64, c, d) = a * b * c * d
println("4 args...")
@time @register_symbolic f4(a::Float64, b::Float64, c, d)::Float64
println("Done!")

# 5 arguments
f5(a::Float64, b::Float64, c::Float64, d, e) = a * b * c * d * e
println("\n5 args...")
@time @register_symbolic f5(a::Float64, b::Float64, c::Float64, d, e)::Float64
println("Done!")

# 6 arguments
f6(a::Float64, b::Float64, c::Float64, d::Float64, e, f) = a * b * c * d * e * f
println("\n6 args...")
@time @register_symbolic f6(a::Float64, b::Float64, c::Float64, d::Float64, e, f)::Float64
println("Done!")

# 7 arguments
f7(a::Float64, b::Float64, c::Float64, d::Float64, e::Float64, f, g) = a * b * c * d * e * f * g
println("\n7 args...")
@time @register_symbolic f7(a::Float64, b::Float64, c::Float64, d::Float64, e::Float64, f, g)::Float64
println("Done!")

# 8 arguments
f8(a::Float64, b::Float64, c::Float64, d::Float64, e::Float64, f::Float64, g, h) = a * b * c * d * e * f * g * h
println("\n8 args...")
@time @register_symbolic f8(a::Float64, b::Float64, c::Float64, d::Float64, e::Float64, f::Float64, g, h)::Float64
println("Done!")

println("\n=== Complete ===")

I get

4 args...
  0.003894 seconds (1.43 k allocations: 113.828 KiB)
Done!

5 args...
  0.010812 seconds (4.26 k allocations: 355.781 KiB)
Done!

6 args...
  0.031935 seconds (12.87 k allocations: 1.095 MiB)
Done!

7 args...
  0.088620 seconds (38.96 k allocations: 3.423 MiB)
Done!

8 args...
  0.270817 seconds (117.89 k allocations: 10.779 MiB)
Done!

=== Complete ===
125.014434 seconds (4.62 M allocations: 193.999 MiB, 0.26% gc time, 96.22% compilation time)

If I don't include the 8 argument case, the total runtime is ~11 seconds.

So there still seems to be some exponential scaling going on with the total number of arguments.

Is this a bug or is this expected?

This is with Symbolics v7.2.0.

Note that on Symbolics v6.57.0 without including the 8 argument case, it took ~192 seconds to run. So at least it got considerably better.

[mx-p9a]

What leads me to think this is a bug is that the type annotations do not seem to matter for timing.

So this

# MWE for @register_symbolic compile time with many arguments
# Related issue: https://github.com/SciML/ModelingToolkit.jl/issues/2251

using ModelingToolkit
using ModelingToolkit: t_nounits as t

# 4 arguments
f4(a, b, c, d) = a * b * c * d
println("4 args...")
@time @register_symbolic f4(a, b, c, d)
println("Done!")

# 5 arguments
f5(a, b, c, d, e) = a * b * c * d * e
println("\n5 args...")
@time @register_symbolic f5(a, b, c, d, e)
println("Done!")

# 6 arguments
f6(a, b, c, d, e, f) = a * b * c * d * e * f
println("\n6 args...")
@time @register_symbolic f6(a, b, c, d, e, f)
println("Done!")

# 7 arguments
function f7(a, b, c, d, e, f, g)
    a * b * c * d * e * f * g
end
println("\n7 args...")
@time @register_symbolic f7(
    a, b, c, d, e, f, g)
println("Done!")

# 8 arguments
f8(a, b, c, d, e, f, g, h) = a * b * c * d * e * f * g * h
println("\n8 args...")
@time @register_symbolic f8(a, b, c, d, e, f, g, h)
println("Done!")

println("\n=== Complete ===")

Returns

4 args...
  0.003831 seconds (2.36 k allocations: 229.656 KiB)
Done!

5 args...
  0.012518 seconds (9.97 k allocations: 1.053 MiB)
Done!

6 args...
  0.045380 seconds (47.32 k allocations: 5.626 MiB)
Done!

7 args...
  0.204286 seconds (242.55 k allocations: 30.391 MiB)
Done!

8 args...
  0.258862 seconds (399.08 k allocations: 43.779 MiB)
Done!

=== Complete ===
130.648907 seconds (6.16 M allocations: 308.630 MiB, 0.04% gc time, 96.48% compilation time)

And the same timing when commenting out the 8 arguments: ~11 seconds.

These results are for Symbolics v7.2.0

[AayushSabharwal]

Per SciML/ModelingToolkit.jl#2251 (comment) I would have expected that the compile time only grows with the number of untyped arguments, but that's not necessarily what I am seeing.

That's not strictly true. Symbolics considers type annotations as possible symtypes for the function. So a type-annotation of ::Float64 means the symtype should be Float64. Since Num wraps <:Real symtypes, it means that for every ::Float64 argument there are two possible types that the function can accept. Which means the number of compiled methods grows exponentially with the number of arguments. These edge cases grow dramatically with symbolic arrays.

[mx-p9a]

Ok thanks, that makes sense.

The reason I went down this path, is that I was trying to find a workaround for both SciML/ModelingToolkit.jl#3973 and SciML/ModelingToolkit.jl#4066.

So I was trying to add the fields from the user-defined struct explicitly to a user-defined function using @register_symbolic. However, then I run into these long compile times, hence trying to find a solution for them.

Any other workaround that would avoid these long compile times?

[AayushSabharwal]

SciML/ModelingToolkit.jl#3973 is closer with the newly merged symbolic struct support. The multiple dispatch case is something I'll take a closer look at. For the compile times, I think the approach in your PR #1726 is in the correct direction. It just needs some tweaks that I highlighted.

[mx-p9a]

Ok thanks, appreciate that quick roadmap, very helpful. I'll rework that PR!