1.9 slower than 1.8

[mhechthz]

I'm just a beginner in Julia comin from Python. so I really am unhappy with TTFX.

I tried 1.9 alpha to check if there is any percaptable speed improvement according to TTFX. So the libraries are loaded in my example code in about 5.3 sec while it takes in 1.8.2 about 6.6 sec and the compilation time fraction changes from close to 100% (1.8.2) in the two largest libs to about 10% (1.9 alpha). But for the code it takes now for the first execution 12.3 seconds with Julia 1.9 instead of 10.1 for Julia 1.8. and also after first loop through code Julia 1.9 is about 20% to 60% slower.

So in total I loose more than 1.5 seconds. So there is no visible improvement for TTFX, or am I wrong?

Code for those who are interested:

time0 = time()
@time using JuMP
@time using GLPK
@time using Cbc
@time using Clp
@time using Dates

function main()    
    N = 10
    T = Vector{Number}()
    for i in 1:N
        println("start program ...")

        start = now()

        println()
        println('='^96'')

        m = Model(Cbc.Optimizer) 

        @variable(m,0<=x1 <= 10)
        @variable(m,x2 >= 0, Int)
        @variable(m,x3 >= 0, Bin)

        @objective(m,Max,x1+2x2+5x3)

        @constraint(m,cnstr1,-x1+x2+3x3 <= -5)
        @constraint(m,cnstr2,x1+3x2-7x3 <= i)

        println(m)

        JuMP.optimize!(m)

        println("Optimal Solutions:")
        println("x1 = ",JuMP.value(x1))
        println("x2 = ",JuMP.value(x2))
        println("x3 = ",JuMP.value(x3))
        println()
        println("Constraints:")
        println("cnstr1 = ",JuMP.value(cnstr1))
        println("cnstr2 = ",JuMP.value(cnstr2))
        println()
        try
            println("Dual Variables:")
            println("dual1 = ",JuMP.shadow_price(cnstr1))
            println("dual2 = ",JuMP.shadow_price(cnstr2))
        catch e
            println("no dual solution available ...")
        end
        println()

        println('='^96'')
        push!(T,(now()-start).value/1000.0)
        println("optimization took ",T[i])
        println()
    end
    return T
end

res = main()
println(res)
println("took ",round(time()-time0,digits=2)," sec ...")

EDIT:
Using DaemonMode.jl (that currently not works for me with Julia 1.8), every following loop is much faster (x10) than without DaemonMode.jl. So this obviously means, that even after compiling there is some overhead because DaemonMode.jl is faster than native Julia..

[oscardssmith]

That's unfortunate, it's probably worth seeing how it does with #44527 (review) which is going to be in 1.9 before we release it. The other thing worth trying is seeing if adding appropriate SnoopPrecompile statements to JuMP can improve things. 1.9 does make it so code that wasn't precompilable in 1.8 is in 1.9, but that only helps packages that do a good job precompiling code.

[mhechthz]

What is nevertheless interesting is the fact, that on looping, i.e. after precompiling should have finished, DaemonMode.jl results in faster code than Julia itself. Is there any explanation?

[oscardssmith]

it's hard to say without looking at the DaemonMode code.