www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - Assuming structs are cheap to copy?

reply Peter Alexander <peter.alexander.au gmail.com> writes:
I remember there was a discussion a little while back about how Phobos 
would assume that structs are cheap to copy, and would simply pass them 
by value.

Is this assumption now "the D way"? Should we all just pass structs by 
value, assuming cheap copy construction?

If so, I think this needs to be documented somewhere (assuming it isn't 
already), because it's a radical departure from C++, and also from most 
other languages (where everything is a reference type). People need to 
be aware of this.
Jan 09 2011
next sibling parent reply Justin Johansson <noreply jj.com> writes:
On 10/01/11 03:06, Peter Alexander wrote:

 I remember there was a discussion a little while back about how Phobos
 would assume that structs are cheap to copy, and would simply pass them
 by value.

 Is this assumption now "the D way"? Should we all just pass structs by
 value, assuming cheap copy construction?

 If so, I think this needs to be documented somewhere (assuming it isn't
 already), because it's a radical departure from C++, and also from most
 other languages (where everything is a reference type). People need to
 be aware of this.


What if the byte size of some struct is say a KB or a MB would one still 
think that copy construction is cheap?

In this instance I would not blame poor performance on Phobos but rather 
than your own design.

Cheers
Justin
Jan 10 2011
parent reply Eric Poggel <dnewsgroup2 yage3d.net> writes:
On 1/10/2011 9:08 AM, Justin Johansson wrote:

 On 10/01/11 03:06, Peter Alexander wrote:

 I remember there was a discussion a little while back about how Phobos
 would assume that structs are cheap to copy, and would simply pass them
 by value.

 Is this assumption now "the D way"? Should we all just pass structs by
 value, assuming cheap copy construction?

 If so, I think this needs to be documented somewhere (assuming it isn't
 already), because it's a radical departure from C++, and also from most
 other languages (where everything is a reference type). People need to
 be aware of this.


 What if the byte size of some struct is say a KB or a MB would one still
 think that copy construction is cheap?

 In this instance I would not blame poor performance on Phobos but rather
 than your own design.

 Cheers
 Justin


I assume it varies by architecture, but at what size threshold is it 
faster to copy structs by reference instead of value?  If I pass a large 
struct by value, will dmd optimize it away as a reference?
Jan 10 2011
parent Jonathan M Davis <jmdavisProg gmx.com> writes:
On Monday, January 10, 2011 10:52:40 Eric Poggel wrote:

 On 1/10/2011 9:08 AM, Justin Johansson wrote:

 On 10/01/11 03:06, Peter Alexander wrote:

 I remember there was a discussion a little while back about how Phobos
 would assume that structs are cheap to copy, and would simply pass them
 by value.
 
 Is this assumption now "the D way"? Should we all just pass structs by
 value, assuming cheap copy construction?
 
 If so, I think this needs to be documented somewhere (assuming it isn't
 already), because it's a radical departure from C++, and also from most
 other languages (where everything is a reference type). People need to
 be aware of this.


 
 What if the byte size of some struct is say a KB or a MB would one still
 think that copy construction is cheap?
 
 In this instance I would not blame poor performance on Phobos but rather
 than your own design.
 
 Cheers
 Justin


 
 I assume it varies by architecture, but at what size threshold is it
 faster to copy structs by reference instead of value?  If I pass a large
 struct by value, will dmd optimize it away as a reference?


No. dmd never turns things into ref unless you tell it to.

- Jonathan M Davis
Jan 10 2011
prev sibling next sibling parent Justin Johansson <noreply jj.com> writes:
On 10/01/11 03:06, Peter Alexander wrote:

 I remember there was a discussion a little while back about how Phobos
 would assume that structs are cheap to copy, and would simply pass them
 by value.

 Is this assumption now "the D way"? Should we all just pass structs by
 value, assuming cheap copy construction?

 If so, I think this needs to be documented somewhere (assuming it isn't
 already), because it's a radical departure from C++, and also from most
 other languages (where everything is a reference type). People need to
 be aware of this.


OTOH maybe I missed your point.

Cheers
Justin
Jan 10 2011
prev sibling parent "Steven Schveighoffer" <schveiguy yahoo.com> writes:
On Sun, 09 Jan 2011 11:06:22 -0500, Peter Alexander  
<peter.alexander.au gmail.com> wrote:


 I remember there was a discussion a little while back about how Phobos  
 would assume that structs are cheap to copy, and would simply pass them  
 by value.

 Is this assumption now "the D way"? Should we all just pass structs by  
 value, assuming cheap copy construction?


The discussion was about assumptions that ranges will make on their  
elements.  Essentially, ranges will expect their element types to be  
cheaply copied.

This does not mean that all structs need be cheaply copyable, nor that  
ranges cannot be used with expensive-to-copy element types.  It just means  
that for the algorithms defined on ranges, the complexity stated depends  
on the elements being cheaply copyable.


 If so, I think this needs to be documented somewhere (assuming it isn't  
 already), because it's a radical departure from C++, and also from most  
 other languages (where everything is a reference type). People need to  
 be aware of this.


AFAIK, there has not been a conclusion to this.  Once there is, if cheap  
copy assumption is the result, then I expect documentation to reflect that  
(probably at top of std.range and std.algorithm).

-Steve
Jan 10 2011