Does Debian's BenchmarkGames show representative performance?

Palli · April 27, 2022, 8:46pm

I believe PackageCompiler.jl is production-ready, I believe (1.0 came out in Feb 2020 and 2.0 in Nov 2021, now at 2.0.5), for applications, at least used in prod (likely by e.g. for PumasAI company, I guessed what Chris is referring to, but see he mentioned for other stuff).

I do not know of any official statements for any [Julia] package. I suppose it may be inferred when 1.0 version is released, but a lot of code has been used in production before that, including Julia; and e.g. JuMP.jl at 10 years old only recently hit 1.0, was state-of-the-art (and I suppose used) years ago.

I understand you need to be careful when building a sysimage, know the limitations (package manager will not update the packages in it); also in general, especially with experimental software, which I do not know it to be.

StaticCompiler.jl is pre-1.0, and I see “experimental”, but neither has stopped [all] people from using such code in production (e.g. Julia itself pre-1.0, or its Threads API marked “experimental”, back in 0.5 until 1.5 in 2020).

Despite all that, I see (and also Chris mentioning it used in production):

Anyone can make a code-generator in Julia, and that’s also one way, I noticed for (this) restrictive (seemingly?) scenario, possible to compile Julia to C, MATLAB and more:

github.com

JuliaSymbolics/Symbolics.jl/blob/b5dc11c82476249bcf5cdbda0434d2d1aed39258/src/build_function.jl#L58


      
          - `ex`: The `Num` to compile
          - `args`: The arguments of the function
          - `expression`: Whether to generate code or whether to generate the compiled form.
            By default, `expression = Val{true}`, which means that the code for the
            function is returned. If `Val{false}`, then the returned value is compiled.
          
          Keyword Arguments:
          
          - `target`: The output target of the compilation process. Possible options are:
              - `JuliaTarget`: Generates a Julia function
              - `CTarget`: Generates a C function
              - `StanTarget`: Generates a function for compiling with the Stan probabilistic
                programming language
              - `MATLABTarget`: Generates an anonymous function for use in MATLAB and Octave
                environments
          - `parallel`: The kind of parallelism to use in the generated function. Defaults
            to `SerialForm()`, i.e. no parallelism, if `ex` is a single expression or an
            array containing <= 1500 non-zero expressions. If `ex` is an array of > 1500
            non-zero expressions then `ShardedForm(80, 4)` is used. See below for more on
            `ShardedForm`.
            Note that the parallel forms are not exported and thus need to be chosen like