JET.jl

Jet.jl

JET emplea el sistema de inferencia de tipo de Julia para detectar posibles errores e inestabilidades de tipo.

Advertencia

Tenga en cuenta que debido a la estrecha integración de Jet con el compilador Julia, los resultados presentados por JET pueden variar significativamente dependiendo de la versión de Julia que esté utilizando. Además, la implementación del módulo Base y las bibliotecas estándar incluidas con Julia también puede afectar los resultados.

Además, el sistema de complementos del compilador de Julia sigue siendo inestable y su interfaz cambia con frecuencia, por lo que cada versión de JET es compatible con solo versiones limitadas de Julia. Julia Package Manager seleccionará e instalará automáticamente la última versión de Jet que es compatible con su versión de Julia. Sin embargo, si está utilizando la versión nocturna de Julia, tenga en cuenta que una versión compatible de JET puede no haber sido lanzada todavía, y Jet instalado a través del Julia Package Manager puede no funcionar correctamente.

Inicio rápido

Vea más comandos, opciones y explicaciones en la documentación.

Instalación

Jet es un paquete estándar de Julia. Por lo tanto, puede instalarlo a través del Administrador de paquetes incorporado de Julia y usarlo como cualquier otro paquete:

julia> using Pkg; Pkg . add ( " JET " )
[ some output elided ]

julia> using JET

Detectar la inestabilidad de tipo con @report_opt

Las inestabilidades de tipo se pueden detectar en las llamadas de funciones utilizando el macro @report_opt , que funciona de manera similar a la macro @code_warntype . Tenga en cuenta que, debido a que Jet se basa en la inferencia de tipo de Julia, si una cadena de inferencia se rompe debido al despacho dinámico, entonces todas las llamadas de función aguas abajo serán desconocidas para el compilador, por lo que Jet no puede analizarlas.

julia> @report_opt foldl ( + , Any[]; init = 0 )
═════ 2 possible errors found ═════
┌ kwcall(::@NamedTuple{init::Int64}, ::typeof(foldl), op::typeof(+), itr::Vector{Any}) @ Base ./reduce.jl:198
│┌ foldl(op::typeof(+), itr::Vector{Any}; kw::@Kwargs{init::Int64}) @ Base ./reduce.jl:198
││┌ kwcall(::@NamedTuple{init::Int64}, ::typeof(mapfoldl), f::typeof(identity), op::typeof(+), itr::Vector{Any}) @ Base ./reduce.jl:175
│││┌ mapfoldl(f::typeof(identity), op::typeof(+), itr::Vector{Any}; init::Int64) @ Base ./reduce.jl:175
││││┌ mapfoldl_impl(f::typeof(identity), op::typeof(+), nt::Int64, itr::Vector{Any}) @ Base ./reduce.jl:44
│││││┌ foldl_impl(op::Base.BottomRF{typeof(+)}, nt::Int64, itr::Vector{Any}) @ Base ./reduce.jl:48
││││││┌ _foldl_impl(op::Base.BottomRF{typeof(+)}, init::Int64, itr::Vector{Any}) @ Base ./reduce.jl:58
│││││││┌ (::Base.BottomRF{typeof(+)})(acc::Int64, x::Any) @ Base ./reduce.jl:86
││││││││ runtime dispatch detected: +(acc::Int64, x::Any)::Any
│││││││└────────────────────
││││││┌ _foldl_impl(op::Base.BottomRF{typeof(+)}, init::Int64, itr::Vector{Any}) @ Base ./reduce.jl:62
│││││││┌ (::Base.BottomRF{typeof(+)})(acc::Any, x::Any) @ Base ./reduce.jl:86
││││││││ runtime dispatch detected: +(acc::Any, x::Any)::Any
│││││││└────────────────────

Detectar errores de tipo con @report_call

Esto funciona mejor en el tipo de código estable, así que use @report_opt liberalmente antes de usar @report_call .

julia> @report_call foldl ( + , Char[])
═════ 2 possible errors found ═════
┌ foldl(op::typeof(+), itr::Vector{Char}) @ Base ./reduce.jl:198
│┌ foldl(op::typeof(+), itr::Vector{Char}; kw::@Kwargs{}) @ Base ./reduce.jl:198
││┌ mapfoldl(f::typeof(identity), op::typeof(+), itr::Vector{Char}) @ Base ./reduce.jl:175
│││┌ mapfoldl(f::typeof(identity), op::typeof(+), itr::Vector{Char}; init::Base._InitialValue) @ Base ./reduce.jl:175
││││┌ mapfoldl_impl(f::typeof(identity), op::typeof(+), nt::Base._InitialValue, itr::Vector{Char}) @ Base ./reduce.jl:44
│││││┌ foldl_impl(op::Base.BottomRF{typeof(+)}, nt::Base._InitialValue, itr::Vector{Char}) @ Base ./reduce.jl:48
││││││┌ _foldl_impl(op::Base.BottomRF{typeof(+)}, init::Base._InitialValue, itr::Vector{Char}) @ Base ./reduce.jl:62
│││││││┌ (::Base.BottomRF{typeof(+)})(acc::Char, x::Char) @ Base ./reduce.jl:86
││││││││ no matching method found `+(::Char, ::Char)`: (op::Base.BottomRF{typeof(+)}).rf::typeof(+)(acc::Char, x::Char)
│││││││└────────────────────
│││││┌ foldl_impl(op::Base.BottomRF{typeof(+)}, nt::Base._InitialValue, itr::Vector{Char}) @ Base ./reduce.jl:49
││││││┌ reduce_empty_iter(op::Base.BottomRF{typeof(+)}, itr::Vector{Char}) @ Base ./reduce.jl:383
│││││││┌ reduce_empty_iter(op::Base.BottomRF{typeof(+)}, itr::Vector{Char}, ::Base.HasEltype) @ Base ./reduce.jl:384
││││││││┌ reduce_empty(op::Base.BottomRF{typeof(+)}, ::Type{Char}) @ Base ./reduce.jl:360
│││││││││┌ reduce_empty(::typeof(+), ::Type{Char}) @ Base ./reduce.jl:343
││││││││││ no matching method found `zero(::Type{Char})`: zero(T::Type{Char})
│││││││││└────────────────────

Analizar paquetes con report_package

Esto busca todas las definiciones de métodos y analiza las llamadas de la función en función de sus firmas. Tenga en cuenta que esto es menos preciso que @report_call , porque los tipos de entrada reales no pueden ser conocidos por métodos genéricos.

julia> using Pkg; Pkg . activate (; temp = true , io = devnull ); Pkg . add ( " AbstractTrees " ; io = devnull );

julia> Pkg . status ()
Status `/private/var/folders/xh/6zzly9vx71v05_y67nm_s9_c0000gn/T/jl_h07K2m/Project.toml`
  [1520ce14] AbstractTrees v0.4.4

julia> report_package ( " AbstractTrees " )
[ some output elided ]
═════ 7 possible errors found ═════
┌ isroot(root::Any, x::Any) @ AbstractTrees ~/.julia/packages/AbstractTrees/EUx8s/src/base.jl:102
│ no matching method found `parent(::Any, ::Any)`: AbstractTrees.parent(root::Any, x::Any)
└────────────────────
┌ AbstractTrees.IndexNode(tree::Any) @ AbstractTrees ~/.julia/packages/AbstractTrees/EUx8s/src/indexing.jl:117
│ no matching method found `rootindex(::Any)`: rootindex(tree::Any)
└────────────────────
┌ parent(idx::AbstractTrees.IndexNode) @ AbstractTrees ~/.julia/packages/AbstractTrees/EUx8s/src/indexing.jl:127
│ no matching method found `parentindex(::Any, ::Any)`: pidx = parentindex((idx::AbstractTrees.IndexNode).tree::Any, (idx::AbstractTrees.IndexNode).index::Any)
└────────────────────
┌ nextsibling(idx::AbstractTrees.IndexNode) @ AbstractTrees ~/.julia/packages/AbstractTrees/EUx8s/src/indexing.jl:132
│ no matching method found `nextsiblingindex(::Any, ::Any)`: sidx = nextsiblingindex((idx::AbstractTrees.IndexNode).tree::Any, (idx::AbstractTrees.IndexNode).index::Any)
└────────────────────
┌ prevsibling(idx::AbstractTrees.IndexNode) @ AbstractTrees ~/.julia/packages/AbstractTrees/EUx8s/src/indexing.jl:137
│ no matching method found `prevsiblingindex(::Any, ::Any)`: sidx = prevsiblingindex((idx::AbstractTrees.IndexNode).tree::Any, (idx::AbstractTrees.IndexNode).index::Any)
└────────────────────
┌ prevsibling(csr::AbstractTrees.IndexedCursor) @ AbstractTrees ~/.julia/packages/AbstractTrees/EUx8s/src/cursors.jl:234
│ no matching method found `getindex(::Nothing, ::Int64)` (1/2 union split): (AbstractTrees.parent(csr::AbstractTrees.IndexedCursor)::Union{Nothing, AbstractTrees.IndexedCursor})[idx::Int64]
└────────────────────
┌ (::AbstractTrees.var"#17#18")(n::Any) @ AbstractTrees ~/.julia/packages/AbstractTrees/EUx8s/src/iteration.jl:323
│ no matching method found `parent(::Any, ::Any)`: AbstractTrees.parent(getfield(#self#::AbstractTrees.var"#17#18", :tree)::Any, n::Any)
└────────────────────

Limitaciones

Jet explora las funciones que llame directamente y sus calles inferibles . Sin embargo, si los tipos de argumentos para una llamada no se pueden inferir, Jet no analiza el Callee. En consecuencia, un informe de No errors detected no implica que toda su base de código esté libre de errores. Para aumentar la confianza en los resultados de JET, use @report_opt para asegurarse de que su código sea inferrible.

Jet se integra con SnoopCompile, y a veces puede usar SnoopCompile para recopilar los datos para realizar análisis más completos. La limitación de SnoopCompile es que solo recopila datos para llamadas que no se han inferido previamente, por lo que debe realizar este tipo de análisis en una nueva sesión.

Consulte la documentación de integración de jet de SnoopCompile para obtener más detalles.

Reconocimiento

Este proyecto comenzó como mi proyecto de tesis de pregrado en la Universidad de Kyoto, supervisado por el profesor Takashi Sakuragawa. Nos inspiró fuertemente a Ruby/Typefr, una herramienta de comprensión/verificación de tipo experimental para Ruby. La tesis gradual sobre este proyecto se publica en https://github.com/aviatask/grad-thesis, pero actualmente solo está disponible en japonés.