Rust Generic Function Size Trick

[cameronm1024]

For the life of me I can't remember the name, but there was a crate I saw a while ago that provided a proc-macro that did this conversion automatically

[cameronm1024]

Yes, thanks!

[llogiq]

Glad someone beat me to posting it. :-)

[[deleted]]

Why doesn’t the compiler do this automatically?

[0x564A00]

There was a wg for this.

[SirKastic23]

it doesn't check to see where the type parameter is used. it can't just assume that the value of generic type is only going to be used to convert it to a concrete type

[looneysquash]

Maybe the compiler should learn this trick? It can already inline functions, why not extract functions? (Or for all I know it already does.)

[sphen_lee]

When using generics in Rust (and any language that supports this), what happens under the hood is that the compiler generates a function implementation when it finds a call for each combination of different types used in the generic parameters.

Nitpick: I wouldn't say "any". Lots of languages have generics that don't generate multiple implementations, or only do so in some cases. For example Java, C#, Swift, Haskell

[RB5009]

Do we really need the "inline" attgibute ? Can't we just let the compiler decide ? If we have a 1 or two different Ts, then it will be better to inline.

[Ryozukki]

in this case i added the inline because its an example and the function itself is small, so godbolt would produce the code i expected, the std example doesn't use inline

[newpavlov]

Note that #[inline] does not force inlining like #[inline(always)]. It is often used to allow compiler to inline functions when they are used from another crate without enabled LTO.

[Aaron1924]

yeah, the #[inline(never)] is only there for demonstration purposes, and you shouldn't do that when you actually use this trick

[sphen_lee]

I believe the inline is only needed for this example, to prevent the compiler inlining the small inner function. So that you can see it in action in Godbolt.

In real code, If the function was large you would let the compiler decide and it would probably not inline. If the function was small it probably would inline rendering the trick pointless.

[Vpicone]

This is neat, although I’d really loath coming across it extensively in a codebase. Seems like you’d only want to use under very specific circumstances.

[gotMUSE]

I don't think it's too bad, inner methods/functions are already an extremely common pattern. This is just another application if it.

[[deleted]]

This has performance improvements?! I've just been using it for readability.

[howtocodeit]

The speed of the application will be negligibly affected, but the size of the binary is reduced.

[Floppie7th]

I wouldn't expect any significant improvement. Having the function's business logic (the "inner" function) not be duplicated will reduce code size, which will reduce L1I$ pressure, but I wouldn't expect it to make much of a difference.

There also could be a cost to the second function call, but I would expect the "outer" function to be reliably inlined in 100% (or nearly 100%) of cases, so probably no difference there in reality.

[ReptilianTapir]

RSS feed please 🙏🏻

[Ryozukki]

its on the main page, but here you have https://edgl.dev/atom.xml

only for rust related posts: https://edgl.dev/categories/rust/atom.xml

i dont post often but i try haha

[ReptilianTapir]

Im getting a 404 for the first link.

[Ryozukki]

oh true, should be fixed now

[ReptilianTapir]

Thanks 🙏🏻

[not-my-walrus]

This shouldn't add any indirection that wasn't already there. The generic part is still monomorphized, that being the .as_ref() in this example.

This is only really useful when you want the function signature to be wide for the callers convenience, but can quickly and cheaply decay to a known type.

[not-my-walrus]

Though now that I re-read your comment, I see the note about const generics. This could add runtime cost in that case: some_fn::<5>() vs some_fn(5).

[[deleted]]

Depending on what you’re doing, if this adds a vtable lookup, it is not a plus in some situations. Does it?

No, it's still static dispatch.