On Saturday, 3 October 2020 at 23:00:46 UTC, Anonymouse wrote:
I'm passing structs around (collections of strings) whose
.sizeof returns 432.
The readme for 2.094.0 includes the following:
This release reworks the meaning of in to properly support all
those use cases. in parameters will now be passed by reference
when optimal, [...]
* Otherwise, if the type's size requires it, it will be passed
by reference.
Currently, types which are over twice the machine word size
will be passed by
reference, however this is controlled by the backend and can
be changed based
on the platform's ABI.
However, I asked in #d a while ago and was told to always pass
by value until it breaks, and only then resort to ref.
[18:32:16] <zorael> at what point should I start passing my
structs by ref rather than by value? some are nested in
others, so sizeofs range between 120 and 620UL
[18:33:43] <Herringway> when you start getting stack overflows
[18:39:09] <zorael> so if I don't need ref for the references,
there's no inherent merit to it unless I get in trouble
without it?
[18:39:20] <Herringway> pretty much
[18:40:16] <Herringway> in many cases the copying is merely
theoretical and doesn't actually happen when optimized
I've so far just been using const parameters. What should I be
using?
Firstly, the new in semantics are very new and possibly subtly
broken (take a look at the current thread in general).
Secondly, as to the more specific question of how to pass a big
struct around it may be helpful to look at this quick godbolt
example (https://d.godbolt.org/z/nPvTWz). Pay attention to the
instructions writing to stack memory (or not). A struct that big
will be passed around on the stack, whether it gets copied or not
depends on the semantics of the struct etc.
The guiding principle to your function parameters should be
correctness - if I am passing a big struct around, if I want to
take ownership of it I probably want to take it by value but if I
want to modify it I should take it by reference (or by pointer
but don't overcomplicate, notice in the previous example they
lower to the same thing). If I just want to look at it, it should
be taken by const ref if possible (D const isn't the same as C++
const, this may catch you out).
Const-correctness is a rule to live by especially with an big
unwieldy struct.
I would avoid the new in for now, but I would go with const ref
from what you've described so far.
