P.S: Recently I’m planning to implement a zero-latency scripting language in Julia, hence I need this feature. The package can be regarded as a generalization to ValSplit.jl , supporting fast runtime polymorphisms for multiple arguments. This package (Virtual.jl) provides two macros @virtual and @ov…

This may be a bit tangential to the package (and congrats on releasing it!) but it makes me think: why does this not happen by default in regular Julia, i.e. without the need for these macros? If dispatch on abstract containers can be made faster what are the reasons not to? Disclaimer I am still le…

Thank you for putting this package together. I think it could be very useful. I was wondering why the example no longer works when I change the type annotation from Int to Integer. Do the types need to be concrete?

I tried changing all Int to Integer, it works. Maybe you are defining overloaded methods whose signature is more general than the default method? See limitations : @virtual f(x::Number, y::Number) = 0 # wrong: Tuple{Float64, Any} <: Tuple{Number, Number} === false @override f(x::Float64, y) = x * …

I think one of the reason for not making Virtual.jl and ValSplit.jl a language builtin is, it causes too much recompilation. The dispatch method needs to be recompiled once a new method is defined. This leads to a longer precompilation time. Dynamic calls are considered slow, but in practice they …

Interesting. Maybe I am misunderstanding something. I was under the impression that I could change Int to Integer in your example. Here is the code I used on Julia 1.7.3: ▶ Summary Here are the results: [ Info: fast_func via Virtual.jl BenchmarkTools.Trial: 10000 samples with 8 evaluations. Range…

Why is it faster than manual splitting? The output of code_typed looks very similar to the manual version.

Could you say something about how the package was made? I’ve never seen Julia code like that before! Is the deserialization bit for latency reasons? That technique kind of scares me because I’m not sure how to review the code being loaded.

This is because we will always the signature from @virtual to box values (to assure the generared dispatch funxction is statically called), while manual split can do specialization in the callsite. If you provide the second argument of score_func using an element from Vector{Number}, the three funcs…

Use Int instead of Integer for @override methods will produce fast code, while keeping @virtual f’s parameters abstract is okay. Besides, if + is implemented with Virtual.jl, our fast_func can be still fast.

Just check reflection.jl, it is the source code. For serialization stuffs, I’m recently experimenting with “dev-only dependencies” in Julia, because a library made by me, MLStyle, is runtime-free (usually not used at all after precompilation).

[ANN] Virtual.jl: optimizing dynamic calls away through "virtual" multiple dispatch

Package Announcements

iamed2 July 19, 2022, 8:23pm 14

Some more discussion on this happened here: Union splitting vs C++ - #14 by lmiq

1 Like

Topic		Replies	Views
Allocation and slow down when # of types involved increase (slower than C++ virtual methods) Performance question , hep	57	3251	November 9, 2022
Claim (false): Julia isn't multiple dispatch but overloading General Usage multidispatch	135	14654	May 20, 2024
Update on single dispatch benchmark comparison to C++ Performance cxx , benchmark	19	3202	February 13, 2021
Union splitting vs C++ Performance	22	4414	July 9, 2021
Speed of multiple dispatch Performance	14	1302	November 27, 2023

[ANN] Virtual.jl: optimizing dynamic calls away through "virtual" multiple dispatch

Related topics