So beseitigen Sie den JIT-Overhead in einer ausführbaren Julia-Datei (mit MWE)

9

Ich verwende PackageCompiler in der Hoffnung, eine ausführbare Datei zu erstellen, die den Just-in-Time-Kompilierungsaufwand eliminiert.

In der Dokumentation wird erklärt, dass ich eine Funktion definieren muss, um julia_maindie Logik meines Programms aufzurufen, und eine "Snoop-Datei" schreiben muss, ein Skript, das Funktionen aufruft, die ich vorkompilieren möchte. Ich julia_mainnehme ein einziges Argument, den Speicherort einer Datei, die die zu analysierenden Eingabedaten enthält. Um die Dinge einfach zu halten, ruft meine Snoop-Datei einfach einen Aufruf julia_mainmit einer bestimmten Eingabedatei auf. Ich würde also hoffen, dass die generierte ausführbare Datei gut und schnell ausgeführt wird (kein Kompilierungsaufwand), wenn sie für dieselbe Eingabedatei ausgeführt wird.

Aber leider sehe ich das nicht. In einer neuen Julia-Instanz julia_maindauert die erste Ausführung ca. 74 Sekunden und die nachfolgende Ausführung ca. 4,5 Sekunden. Die ausführbare Datei dauert bei jedem Aufruf ca. 50 Sekunden.

Meine Verwendung der build_executableFunktion sieht folgendermaßen aus:

julia> using PackageCompiler

julia> build_executable("d:/philip/source/script/julia/jsource/SCRiPTMain.jl",
                        "testexecutable",
                        builddir = "d:/temp/builddir4",
                        snoopfile = "d:/philip/source/script/julia/jsource/snoop.jl",
                        compile = "all",
                        verbose = true)

Fragen:

  1. Sind die obigen Argumente richtig, um mein Ziel einer ausführbaren Datei ohne JIT-Overhead zu erreichen?
  2. Irgendwelche anderen Ratschläge für mich?

Folgendes passiert als Antwort auf diesen Anruf an build_executable. Die Zeilen von Start of snoop file execution!bis End of snoop file execution!werden von meinem Code ausgegeben.

Julia program file:
  "d:\philip\source\script\julia\jsource\SCRiPTMain.jl"
C program file:
  "C:\Users\Philip\.julia\packages\PackageCompiler\CJQcs\examples\program.c"
Build directory:
  "d:\temp\builddir4"
Executing snoopfile: "d:\philip\source\script\julia\jsource\snoop.jl"
Start of snoop file execution!
┌ Warning: The 'control file' contains the key 'InterpolateCovariance' with value 'true' but that is not supported. Pass a value of 'false' or omit the key altogether.
└ @ ValidateInputs d:\Philip\Source\script\Julia\JSource\ValidateInputs.jl:685
Time to build model 20.058000087738037
Saving c:/temp/SCRiPT/SCRiPTModel.jls
Results written to c:/temp/SCRiPT/SCRiPTResultsJulia.json
Time to write file: 3620 milliseconds
Time in method runscript: 76899 milliseconds
End of snoop file execution!
[ Info: used 1313 out of 1320 precompile statements
Build static library "testexecutable.a":
  atexit_hook_copy = copy(Base.atexit_hooks) # make backup
# clean state so that any package we use can carelessly call atexit
empty!(Base.atexit_hooks)
Base.__init__()
Sys.__init__() #fix https://github.com/JuliaLang/julia/issues/30479
using REPL
Base.REPL_MODULE_REF[] = REPL
Mod = @eval module $(gensym("anon_module")) end
# Include into anonymous module to not polute namespace
Mod.include("d:\\\\temp\\\\builddir4\\\\julia_main.jl")
Base._atexit() # run all exit hooks we registered during precompile
empty!(Base.atexit_hooks) # don't serialize the exit hooks we run + added
# atexit_hook_copy should be empty, but who knows what base will do in the future
append!(Base.atexit_hooks, atexit_hook_copy)

Build shared library "testexecutable.dll":
  `'C:\Users\Philip\.julia\packages\WinRPM\Y9QdZ\deps\usr\x86_64-w64-mingw32\sys-root\mingw\bin\gcc.exe' --sysroot 'C:\Users\Philip\.julia\packages\WinRPM\Y9QdZ\deps\usr\x86_64-w64-mingw32\sys-root' -shared '-DJULIAC_PROGRAM_LIBNAME="testexecutable.dll"' -o testexecutable.dll -Wl,--whole-archive testexecutable.a -Wl,--no-whole-archive -std=gnu99 '-IC:\Users\philip\AppData\Local\Julia-1.2.0\include\julia' -DJULIA_ENABLE_THREADING=1 '-LC:\Users\philip\AppData\Local\Julia-1.2.0\bin' -Wl,--stack,8388608 -ljulia -lopenlibm -m64 -Wl,--export-all-symbols`
Build executable "testexecutable.exe":
  `'C:\Users\Philip\.julia\packages\WinRPM\Y9QdZ\deps\usr\x86_64-w64-mingw32\sys-root\mingw\bin\gcc.exe' --sysroot 'C:\Users\Philip\.julia\packages\WinRPM\Y9QdZ\deps\usr\x86_64-w64-mingw32\sys-root' '-DJULIAC_PROGRAM_LIBNAME="testexecutable.dll"' -o testexecutable.exe 'C:\Users\Philip\.julia\packages\PackageCompiler\CJQcs\examples\program.c' testexecutable.dll -std=gnu99 '-IC:\Users\philip\AppData\Local\Julia-1.2.0\include\julia' -DJULIA_ENABLE_THREADING=1 '-LC:\Users\philip\AppData\Local\Julia-1.2.0\bin' -Wl,--stack,8388608 -ljulia -lopenlibm -m64`
Copy Julia libraries to build directory:
  7z.dll
  BugpointPasses.dll
  libamd.2.4.6.dll
  libamd.2.dll
  libamd.dll
  libatomic-1.dll
  libbtf.1.2.6.dll
  libbtf.1.dll
  libbtf.dll
  libcamd.2.4.6.dll
  libcamd.2.dll
  libcamd.dll
  libccalltest.dll
  libccolamd.2.9.6.dll
  libccolamd.2.dll
  libccolamd.dll
  libcholmod.3.0.13.dll
  libcholmod.3.dll
  libcholmod.dll
  libclang.dll
  libcolamd.2.9.6.dll
  libcolamd.2.dll
  libcolamd.dll
  libdSFMT.dll
  libexpat-1.dll
  libgcc_s_seh-1.dll
  libgfortran-4.dll
  libgit2.dll
  libgmp.dll
  libjulia.dll
  libklu.1.3.8.dll
  libklu.1.dll
  libklu.dll
  libldl.2.2.6.dll
  libldl.2.dll
  libldl.dll
  libllvmcalltest.dll
  libmbedcrypto.dll
  libmbedtls.dll
  libmbedx509.dll
  libmpfr.dll
  libopenblas64_.dll
  libopenlibm.dll
  libpcre2-8-0.dll
  libpcre2-8.dll
  libpcre2-posix-2.dll
  libquadmath-0.dll
  librbio.2.2.6.dll
  librbio.2.dll
  librbio.dll
  libspqr.2.0.9.dll
  libspqr.2.dll
  libspqr.dll
  libssh2.dll
  libssp-0.dll
  libstdc++-6.dll
  libsuitesparseconfig.5.4.0.dll
  libsuitesparseconfig.5.dll
  libsuitesparseconfig.dll
  libsuitesparse_wrapper.dll
  libumfpack.5.7.8.dll
  libumfpack.5.dll
  libumfpack.dll
  libuv-2.dll
  libwinpthread-1.dll
  LLVM.dll
  LLVMHello.dll
  zlib1.dll
All done

julia>

BEARBEITEN

Ich hatte Angst, dass es schwierig sein würde, ein minimales Arbeitsbeispiel zu erstellen, aber es war unkompliziert:

TestBuildExecutable.jl enthält:

module TestBuildExecutable

Base.@ccallable function julia_main(ARGS::Vector{String}=[""])::Cint
    @show sum(myarray())
    return 0
end

#Function which takes approx 8 seconds to compile. Returns a 500 x 20 array of 1s
function myarray()
    [1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1;
     1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1;

# PLEASE EDIT TO INSERT THE MISSING 496 LINES, EACH IDENTICAL TO THE LINE ABOVE!

     1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1;
     1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1]
end

end #module

SnoopFile.jl enthält:

module SnoopFile

currentpath = dirname(@__FILE__)
push!(LOAD_PATH, currentpath)
unique!(LOAD_PATH)

using TestBuildExecutable

println("Start of snoop file execution!")
TestBuildExecutable.julia_main()
println("End of snoop file execution!")

end # module

In einer neuen Julia-Instanz julia_maindauert die erste Ausführung 8,3 Sekunden und die zweite Ausführung eine halbe Millisekunde:

julia> @time TestBuildExecutable.julia_main()
sum(myarray()) = 10000
  8.355108 seconds (425.36 k allocations: 25.831 MiB, 0.06% gc time)
0

julia> @time TestBuildExecutable.julia_main()
sum(myarray()) = 10000
  0.000537 seconds (25 allocations: 82.906 KiB)
0

Als nächstes rufe ich an build_executable:

julia> using PackageCompiler

julia> build_executable("d:/philip/source/script/julia/jsource/TestBuildExecutable.jl",
                       "testexecutable",
                       builddir = "d:/temp/builddir15",
                       snoopfile = "d:/philip/source/script/julia/jsource/SnoopFile.jl",
                       verbose = false)
Julia program file:
  "d:\philip\source\script\julia\jsource\TestBuildExecutable.jl"
C program file:
  "C:\Users\Philip\.julia\packages\PackageCompiler\CJQcs\examples\program.c"
Build directory:
  "d:\temp\builddir15"
Start of snoop file execution!
sum(myarray()) = 10000
End of snoop file execution!
[ Info: used 79 out of 79 precompile statements
All done

Schließlich in einer Windows-Eingabeaufforderung:

D:\temp\builddir15>testexecutable
sum(myarray()) = 1000

D:\temp\builddir15>

Die Ausführung dauerte (bei meiner Stoppuhr) 8 Sekunden und die Ausführung jedes Mal 8 Sekunden, nicht nur beim ersten Mal. Dies steht im Einklang mit der ausführbaren Datei, die bei jeder Ausführung eine JIT-Kompilierung durchführt, aber die Snoop-Datei soll dies vermeiden!

Versionsinformation:

julia> versioninfo()
Julia Version 1.2.0
Commit c6da87ff4b (2019-08-20 00:03 UTC)
Platform Info:
  OS: Windows (x86_64-w64-mingw32)
  CPU: Intel(R) Core(TM) i7-6700 CPU @ 3.40GHz
  WORD_SIZE: 64
  LIBM: libopenlibm
  LLVM: libLLVM-6.0.1 (ORCJIT, skylake)
Environment:
  JULIA_NUM_THREADS = 8
  JULIA_EDITOR = "C:\Users\Philip\AppData\Local\Programs\Microsoft VS Code\Code.exe"
compilation julia packagecompiler.jl Philip Swannell
quelle

Antworten:

1

Sieht aus wie Sie Windows verwenden.

Irgendwann wird PackageCompiler.jl für Windows ausgereift sein, unter dem Sie es ausprobieren können.

Xiaodai
quelle
Vielen Dank für den Hinweis. Ich war mir PackageCompilerX bewusst und es ist ermutigend zu bemerken, dass es mit einer Veröffentlichung heute (11. Dezember 19) in der aktiven Entwicklung ist. Ich werde damit experimentieren, aber ich muss vielleicht geduldig sein!
Philip Swannell
1

Die Lösung bestand in der Tat darin, auf Fortschritte zu warten PackageCompilerX, wie von @xiaodai vorgeschlagen.

Am 10. Februar 2020 wurde das, was früher PackageCompilerXneu war (Version 1.0 von) PackageCompiler, mit einer erheblich geänderten API und einer gründlicheren Dokumentation.

Insbesondere das oben genannte MWE ( mutiert für die neue API PackageCompiler) funktioniert jetzt ordnungsgemäß ohne JIT-Overhead.

Philip Swannell
quelle