La version 1.12 du langage de programmation Julia est disponible

Anthony — Sat, 11 Oct 2025 10:34:27 GMT

La version 1.12 du langage de programmation Julia est disponible, avec la red�finition des constantes et des structures, de nouvelles fonctionnalit�s de multithreading et bien plus encore

Julia 1.12, la derni�re version du langage de programmation, est officiellement disponible, apportant des am�liorations significatives en termes de performances, de multithreading et de productivit� des d�veloppeurs. Cette version introduit notamment une nouvelle fonctionnalit� exp�rimentale --trim pour des binaires de plus petites tailles et des temps de compilation plus rapides, un multithreading am�lior� avec un thread interactif d�di�, la red�finition des structures, des builds optimis�s par l'outil BOLT et des capacit�s �tendues de gestion des packages.

Julia est un langage de programmation de haut niveau, performant et dynamique con�u pour le calcul scientifique et les applications de calcul num�rique. Sa syntaxe est famili�re aux utilisateurs d'autres environnements de d�veloppement tels que MATLAB, R, Scilab, et Python. Julia est connue pour sa vitesse et ses capacit�s avanc�es en termes de calcul parall�le et de gestion de donn�es volumineuses. Julia combine les avantages des langages compil�s (tels que C et Fortran) avec la flexibilit� des langages dynamiques.

Bien qu'�tant un langage g�n�raliste dans sa conception, Julia est majoritairement utilis� dans le monde scientifique. On le retrouve notamment dans des domaines tels que la science des donn�es, la mod�lisation num�rique, la statistique, l'apprentissage automatique ou encore la biologie et la climatologie. Les utilisateurs du langage sont en majorit� des ing�nieurs, des chercheurs ou des �tudiants, qui l'utilisent pour faire de la recherche scientifique ou comme un passe-temps. Certains utilisateurs trouvent dans Julia un langage avec une syntaxe simple comme Python tout en ayant des performances �lev�es.

Julia 1.12 vient de sortir. Cette version stable apporte des am�liorations du langage et des corrections de bogues, mais elle devrait �galement �tre enti�rement compatible avec le code �crit dans les versions pr�c�dentes de Julia. Certaines des fonctionnalit�s et am�liorations introduites dans cette derni�re version de Julia sont pr�sent�es ci-dessous. La liste compl�te des modifications est disponible ici.

Nouvelle fonctionnalit� --trim

Julia dispose d�sormais d'une nouvelle fonctionnalit� exp�rimentale --trim. Lorsque vous compilez une image syst�me avec ce mode, Julia supprime statiquement le code inaccessible, ce qui am�liore consid�rablement les temps de compilation et la taille des fichiers binaires. Pour l'utiliser, vous devez �galement passer le drapeau --experimental lors de la cr�ation de l'image syst�me.

Pour pouvoir l'utiliser, tout code accessible depuis les points d'entr�e ne doit comporter aucun dispatch dynamique, sinon le trimming ne sera pas s�r et une erreur se produira lors de la compilation.

La mani�re pr�vue pour l'utiliser est via le package JuliaC.jl, qui fournit une CLI et une API programmatique.

Voici par exemple un package simple avec une fonction @main :

Code:

1
2
3
4
5
6
7
8
module AppProject
 
function @main(ARGS)
    println(Core.stdout, "Hello World!")
    return 0
end
 
end

Code:

juliac --output-exe app_test_exe --bundle build --trim=safe --experimental ./AppProject

Code:

1
2
3
4
5
./build/bin/app_test_exe
Hello World!
 
ls -lh build/bin/app_test_exe
-rwxr-xr-x@ 1 gabrielbaraldi  staff   1.1M Oct  6 17:22 ./build/bin/app_test_exe*

Red�finition des constantes (structures)

Les liaisons participent d�sormais au m�canisme � world age � pr�c�demment utilis� pour les m�thodes. Cela permet de red�finir correctement les constantes et les structures. Par exemple :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
# Define a struct and a method on that struct:
julia> struct Foo
          a::Int
       end
 
julia> g(f::Foo) = f.a^2
g (generic function with 1 method)
 
julia> g(Foo(2))
4
 
# Redefine the struct (julia pre-1.12 would error here)
julia> struct Foo
          a::Int
          b::Int
       end
 
# Note that functions need to be redefined to work on the new `Foo`
julia> g(Foo(1,2))
ERROR: MethodError: no method matching g(::Foo)
The function `g` exists, but no method is defined for this combination of argument types.
 
Closest candidates are:
  g(::@world(Foo, 39296:39300)) # <- This is syntax for accessing the binding in an older "world"
   @ Main REPL[2]:1
 
julia> g(f::Foo) = f.a^2 + f.b^2
g (generic function with 2 methods)
 
julia> g(Foo(2,3))
13

Des travaux sont �galement en cours dans Revise.jl pour red�finir automatiquement les fonctions sur les liaisons remplac�es. Cela devrait r�duire consid�rablement le nombre de red�marrages de Julia n�cessaires lors de l'it�ration sur certains morceaux de code.

Nouveaux indicateurs de suivi et macros pour inspecter ce que Julia compile

--trace-compile-timing est un nouvel indicateur de ligne de commande qui compl�te --trace-compile en affichant la dur�e (en millisecondes) de chaque m�thode compil�e avant la ligne precompile(...) correspondante. Cela permet de rep�rer plus facilement les compilations co�teuses.

De plus, deux macros permettant un suivi ad hoc sans red�marrer Julia ont �t� ajout�es :

@trace_compile expr ex�cute expr avec --trace-compile=stderr --trace-compile-timing activ�, en �mettant des entr�es precompile(...) chronom�tr�es uniquement pour cet appel.
@trace_dispatch expr ex�cute expr avec --trace-dispatch=stderr activ�, en signalant les m�thodes qui sont dispatch�es dynamiquement.

Voici un exemple :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
julia> @trace_compile @eval rand(2,2) * rand(2,2)
#=   79.9 ms =# precompile(Tuple{typeof(Base.rand), Int64, Int64})
#=    4.4 ms =# precompile(Tuple{typeof(Base.:(*)), Array{Float64, 2}, Array{Float64, 2}})
2×2 Matrix{Float64}:
 0.302276  0.14341
 0.738941  0.396414
 
julia> f(x) = x
 
julia> @trace_dispatch map(f, Any[1,2,3])
precompile(Tuple{Type{Array{Int64, 1}}, UndefInitializer, Tuple{Int64}})
precompile(Tuple{typeof(Base.collect_to_with_first!), Array{Int64, 1}, Int64, Base.Generator{Array{Any, 1}, typeof(Main.f)}, Int64})
3-element Vector{Int64}:
 1
 2
 3

Nouvelles fonctionnalit�s multithreading

Un thread interactif par d�faut

Julia d�marre d�sormais avec un thread interactif par d�faut (en plus du default thread). Cela signifie que, par d�faut, Julia s'ex�cute avec une configuration multithreading comprenant 1 thread par d�faut et 1 thread interactif.

Le pool de threads interactifs est l'endroit o� s'ex�cutent le REPL et les autres op�rations interactives. En les s�parant du pool de threads par d�faut (o� @spawn et @threads planifient le travail lorsqu'aucun pool de threads n'est sp�cifi�), le REPL peut effectuer des op�rations telles que les requ�tes d'autocompl�tion en parall�le avec l'ex�cution du code utilisateur, ce qui se traduit par une exp�rience interactive plus r�active.

Comportements cl�s :

Par d�faut : Julia d�marre avec -t1,1 (1 thread par d�faut + 1 thread interactif)
-t1 explicite : si vous demandez explicitement 1 thread avec -t1, Julia vous donnera exactement cela � aucun thread interactif suppl�mentaire ne sera ajout� (ce qui donne -t1,0)
Threads multiples : -t2 ou -tauto vous donnera les threads par d�faut demand�s plus 1 thread interactif
Contr�le manuel : vous pouvez toujours sp�cifier explicitement les deux pools, par exemple -t4,2 pour 4 threads par d�faut et 2 threads interactifs

Cette modification am�liore l'exp�rience pr�te � l'emploi tout en conservant la r�trocompatibilit� pour les utilisateurs qui demandent explicitement une ex�cution � thread unique.

Les param�tres des threads respectent l'affinit� CPU

Julia respecte d�sormais les param�tres d'affinit� du CPU, tels que ceux d�finis via cpuset/taskset/cgroups, etc. Il en va de m�me pour le nombre par d�faut de threads BLAS, qui suit d�sormais la m�me logique. Cela peut �galement �tre observ� lors de l'ex�cution de Julia dans Docker. Actuellement, vous disposez de :

Code:

1
2
3
$ docker run --cpus=4 --rm -ti julia:1.11 julia --threads=auto -e '@show Threads.nthreads(); using LinearAlgebra; @show BLAS.get_num_threads()'
Threads.nthreads() = 22
BLAS.get_num_threads() = 11

Lorsque vous d�marrez Julia avec --threads=auto, Threads.nthreads() est �gal au nombre total de processeurs du syst�me au lieu des 4 processeurs r�serv�s par Docker. De m�me, le nombre de threads BLAS, qui peut �tre obtenu avec BLAS.get_num_threads() et qui, sur les syst�mes x86-64, correspond par d�faut � la moiti� du nombre de c�urs disponibles, est de 11 au lieu de 2. Avec Julia v1.12, ce probl�me est r�solu, et le nombre de threads Julia et BLAS respectera le nombre de processeurs r�serv�s par Docker :

Code:

1
2
3
% docker run --cpus=4 --rm -ti julia:1.12 julia --threads=auto -e '@show Threads.nthreads(); using LinearAlgebra; @show BLAS.get_num_threads()'
Threads.nthreads() = 4
BLAS.get_num_threads() = 2

Ce nouveau comportement est �galement important pour �viter la sursouscription d�s le d�part lors de l'ex�cution de Julia sur des syst�mes HPC o� les planificateurs d�finissent l'affinit� du CPU lors de l'utilisation de ressources partag�es.

OncePerX

Certains mod�les d'initialisation ne doivent s'ex�cuter qu'une seule fois, en fonction de leur port�e : par processus, par thread ou par t�che. Pour faciliter et s�curiser cette op�ration, Julia propose d�sormais trois types int�gr�s :

OncePerProcess{T}: runs an initializer exactly once per process, returning the same value for all future calls.
OncePerThread{T}: runs an initializer once for each thread ID. Subsequent calls on the same thread return the same value.
OncePerTask{T}: runs an initializer once per task, reusing the same value within that task.

Ils remplacent les solutions courantes d�velopp�es manuellement, telles que l'utilisation directe de __init__, nthreads() ou task_local_storage().

Exemple simple d'utilisation de OncePerProcess :

Code:

1
2
3
4
5
6
7
8
9
10
julia> const global_state = Base.OncePerProcess{Vector{UInt32}}() do
           println("Making lazy global value...done.")
           return [Libc.rand()]
       end;
 
julia> a = global_state();
Making lazy global value...done.
 
julia> a === global_state()
true

Cas d'utilisation :

OncePerProcess : caches, constantes globales ou initialisation qui doivent avoir lieu une seule fois par processus Julia (m�me lors de la pr�compilation).
OncePerThread : �tat par thread n�cessaire � l'interop�rabilit� avec les biblioth�ques C ou les mod�les de threading sp�cialis�s.
OncePerTask : �tat l�ger de la t�che locale sans gestion manuelle de task_local_storage.

Ces types offrent un moyen plus s�r et modulable d'exprimer la s�mantique � initialiser une seule fois � dans le code Julia concurrent.

Compilation de Julia et LLVM � l'aide de l'outil Binary Optimization and Layout (BOLT)

BOLT est un optimiseur post-liaison de LLVM qui am�liore les performances d'ex�cution en r�organisant les fonctions et les blocs de base, en s�parant le code chaud et le code froid, et en regroupant les fonctions identiques. Julia prend d�sormais en charge la compilation de versions optimis�es par BOLT de libLLVM, libjulia-internal et libjulia-codegen.

Ces optimisations r�duisent le temps de compilation et d'ex�cution dans les charges de travail courantes. Par exemple, les benchmarks d'inf�rence globale s'am�liorent d'environ 10 %, une charge de travail LLVM intensive affiche un gain similaire d'environ 10 %, et la compilation de corecompiler.ji s'am�liore de 13 � 16 % avec BOLT. En combinaison avec PGO et LTO, des am�liorations totales pouvant atteindre environ 23 % ont �t� observ�es.

Pour cr�er une version optimis�e de Julia pour BOLT, ex�cutez les commandes suivantes � partir de contrib/bolt/ :

Code:

1
2
3
4
5
6
make stage1
make copy_originals
make bolt_instrument
make finish_stage1
make merge_data
make bolt

Les binaires optimis�s seront disponibles dans le r�pertoire optimized.build. Un workflow analogue existe dans contrib/pgo-lto-bolt/ pour combiner BOLT avec PGO+LTO.

BOLT ne fonctionne actuellement que sur Linux x86_64 et aarch64, et les fichiers .so r�sultants ne doivent pas �tre d�pouill�s. Certains avertissements readelf peuvent appara�tre pendant les tests, mais ils sont consid�r�s comme inoffensifs.

La famille de macros @atomic prend d�sormais en charge la syntaxe d'affectation de r�f�rence

La famille de macros @atomic prend d�sormais en charge l'indexation (par exemple m[i], m[i,j]) en plus de l'acc�s aux champs. Cela permet d'effectuer des op�rations atomiques de r�cup�ration, de d�finition, de modification, d'�change, de comparaison et d'�change, et de d�finition unique directement sur des r�f�rences de type tableau. Les macros se d�veloppent en nouvelles API : getindex_atomic, setindex_atomic!, modifyindex_atomic!, swapindex_atomic!, replaceindex_atomic! et setindexonce_atomic!. L'indexation Vararg et CartesianIndex est prise en charge.

Par exemple :

Code:

1
2
3
4
5
6
7
8
mem = AtomicMemory{Int}(undef, 2)
 
@atomic mem[1] = 2                 # atomic set
x = @atomic mem[1]                 # atomic fetch
@atomic :monotonic mem[1] += 1     # atomic modify with order
old = @atomicswap mem[1] = 4       # atomic swap (returns old)
res = @atomicreplace mem[1] 4 => 10  # (old=4, success=true)
ok  = @atomiconce mem[2] = 7         # set once (Bool)

Nouvelles fonctionnalit�s de paquets

Espace de travail

Un espace de travail est un ensemble de fichiers de projet qui partagent tous le m�me manifeste. Chaque projet d'un espace de travail peut inclure ses propres d�pendances, ses informations de compatibilit� et m�me fonctionner comme un package complet.

Lorsque le gestionnaire de packages r�sout les d�pendances, il prend en compte les exigences et la compatibilit� de tous les projets de l'espace de travail. Les versions compatibles identifi�es au cours de ce processus sont enregistr�es dans un seul fichier manifeste.

Un espace de travail est d�fini dans le projet de base en fournissant une liste des projets qu'il contient :

Code:

1
2
[workspace]
projects = ["test", "docs", "benchmarks", "PrivatePackage"]

Cette structure est particuli�rement avantageuse pour les d�veloppeurs qui utilisent une approche monorepo, o� un grand nombre de paquets non enregistr�s peuvent �tre impliqu�s. Elle est �galement utile pour ajouter de la documentation ou des benchmarks � un paquet en incluant des d�pendances suppl�mentaires au-del� de celles du paquet lui-m�me. Il est d�sormais recommand� de sp�cifier les d�pendances sp�cifiques aux tests � l'aide de l'approche par espace de travail (un fichier de projet dans le r�pertoire de test qui fait partie de l'espace de travail d�fini par le fichier de projet du paquet).

Les espaces de travail peuvent �galement �tre imbriqu�s : un projet qui d�finit lui-m�me un espace de travail peut �galement faire partie d'un autre espace de travail. Dans ce cas, les espaces de travail sont � fusionn�s �, un seul manifeste �tant stock� � c�t� du � projet racine � (le projet qui n'est pas inclus dans un autre espace de travail).

Applications

Une application est un paquet Julia qui peut �tre ex�cut� directement depuis le terminal, � l'instar d'un programme autonome. Chaque application fournit un point d'entr�e via @main et peut d�finir ses propres indicateurs Julia par d�faut et son nom d'ex�cutable.

Lorsqu'une application est install�e, elle est plac�e dans .julia/bin. En l'ajoutant � votre PATH, vous pouvez la lancer par son nom avec des arguments ou des options.

Une application Julia est d�finie dans le fichier Project.toml � l'aide d'une section [apps] :

Code:

1
2
[apps]
reverse = {} # empty dictionary is for additional metadata

avec un point d'entr�e correspondant dans le module du paquet :

Code:

1
2
3
4
5
6
7
8
9
10
# src/MyReverseApp.jl
module MyReverseApp
 
function (@main)(ARGS)
    for arg in ARGS
        print(stdout, reverse(arg), " ")
    end
end
 
end # module

Apr�s l'installation, l'application peut �tre ex�cut�e directement dans le terminal :

Code:

1
2
$ reverse some input string
emos tupni gnirts

Cela rend les applications utiles pour cr�er des outils CLI ou regrouper les fonctionnalit�s Julia sous forme d'ex�cutables destin�s aux utilisateurs. Plusieurs applications peuvent �tre d�finies par paquet � l'aide de sous-modules, et chaque application peut sp�cifier des indicateurs Julia par d�faut (par exemple --threads=4) pour am�liorer les performances ou faciliter le d�bogage.

Pour en apprendre davantage sur ce langage de programmation, vous pouvez consulter cette excellente pr�sentation de Julia.

Source : Julia

Et vous ?

:fleche: Quel est votre avis sur le sujet ?
:fleche: Trouvez-vous les am�liorations apport�es par cette version de Julia pertinentes et utiles ?

Voir aussi :

:fleche: La version 1.11 du langage de programmation Julia est disponible, apportant un nouveau type "Memory" et de nouvelles fonctionnalit�s � l'inf�rence

:fleche: Annonce de Julia v1.10, la nouvelle version du langage de programmation apporte des am�liorations en termes de rapidit� et de confort pour les d�veloppeurs

:fleche: La version 1.9 de Julia, un langage de programmation de haut niveau, est disponible, la nouvelle version est livr�e avec de nouvelles fonctionnalit�s qui vont am�liorer les performances du langage

Forum du club des d�veloppeurs et IT Pro - Julia

La version 1.12 du langage de programmation Julia est disponible