LLVM considers calls to known allocators to be “side-effect free”, but promoting them is still risky, since it means that more memory is allocated earlier, which can lead to memory exhaustion. If you look at the order of operations, it requires making the allocation happen before the arguments are allocated. The optimizer may be able to fix that, but it’s not trivial.
let box : * const T = allocate_memory () //. Then invoke `Box::new`, which allocates a Box. First evaluate the argument, creating the temporary: let temp : =. For example, if I write Box::new() today, I am technically allocating a buffer on the stack and then copying it into the box: box has historically been efficiency: they permit in-place initialization in cases where it is not possible today. The primary motivation for both unsized-return-values and. box operator, meanwhile, has been a part of “nightly Rust” since approximately forever, though its currently written in prefix form, i.e., box foo 2. They’ve been proposed in RFC 2884 by Olivier Faure, and I believe there were some earlier RFCs as well. This idea of returning dyn Future is sometimes called “unsized return values”, as functions can now return values of “unsized” type (i.e., types who size is not statically known). If we add postfix macros, then we might even support something like return_dyn.maybe_box!(&mut big_buf), though I’m not sure if the current proposal would support that or not.
Let mut big_buf = let result = maybe_box ( & mut big_buf, || return_dyn ()).
0 kommentar(er)
