pass a struct by value/ref and size of the struct

[ZombineDev via Digitalmars-d-learn]

On Monday, 21 March 2016 at 23:31:06 UTC, ref2401 wrote:
> I have got a plenty of structs in my project. Their size varies 
> from 12 bytes to 128 bytes.
> Is there a rule of thumb that states which structs I pass by 
> value and which I should pass by reference due to their size?
>
> Thanks.

If the object is larger than the size of a register on the target 
machine, it is implicitly passed by ref (i.e. struct fields are 
accessed by offset from the stack pointer). So the question is: 
does the compiler need to create temporaries and is this an 
expensive operation? In C++ the problem is that there are lots of 
non-POD types which have expensive copy constructors (like 
std::vector) and that's why taking objects by const& is good 
guideline. In D structs are implicitly movable (can be memcpy-ed 
around without their postblit this(this) function called) and 
that's why I think that passing by value shouldn't be as large 
problem as in C++, especially if you are using a good optimizing 
compiler such as LDC or GDC.

Anyway, modern hardware in combination with compiler 
optimizations can often suprise you, so I recommend profiling 
your code and doing microbenchmarks to figure out where you may 
have performance problems. In my experience, large amounts of 
small memory allocations is orders of magnitude larger problem 
than the copying of large value types. The next thing to look for 
is inefficient memory layout with lots of indirections.