www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.learn - non-determinant object lifetime and memory management

reply "Frustrated" <c1514843 drdrb.com> writes:
I need to pass around some objects(specifically int[]) that may 
be used by several other objects at the same time. While I could 
clone these and free them when the parent object is done this 
wastes memory for no real reason except ease of use.

Since many objects may contain a ptr to the array, what would be 
the best way to deal with deallocating them? I could wrap the 
array in a collection an use ARC but is there a better way?

Is there something in std.allocators that can help?

(Should be obvious that I'm trying to avoid the GC)
Nov 30 2013
next sibling parent "bearophile" <bearophileHUGS lycos.com> writes:
Frustrated:

 I need to pass around some objects(specifically int[]) that may 
 be used by several other objects at the same time. While I 
 could clone these and free them when the parent object is done 
 this wastes memory for no real reason except ease of use.

 Since many objects may contain a ptr to the array, what would 
 be the best way to deal with deallocating them? I could wrap 
 the array in a collection an use ARC but is there a better way?

 Is there something in std.allocators that can help?

 (Should be obvious that I'm trying to avoid the GC)
Your use case seems fit for using the GC. Otherwise take a look at std.typecons.RefCounted, to be used in a wrapper that uses "alias this". Bye, bearophile
Nov 30 2013
prev sibling next sibling parent reply "Rene Zwanenburg" <renezwanenburg gmail.com> writes:
On Saturday, 30 November 2013 at 08:35:23 UTC, Frustrated wrote:
 I need to pass around some objects(specifically int[]) that may 
 be used by several other objects at the same time. While I 
 could clone these and free them when the parent object is done 
 this wastes memory for no real reason except ease of use.

 Since many objects may contain a ptr to the array, what would 
 be the best way to deal with deallocating them? I could wrap 
 the array in a collection an use ARC but is there a better way?

 Is there something in std.allocators that can help?

 (Should be obvious that I'm trying to avoid the GC)
You can use the Array type in std.container [1]. It uses ref counting and the C heap internally. [1] http://dlang.org/phobos/std_container.html#.Array
Nov 30 2013
parent "Frustrated" <c1514843 drdrb.com> writes:
On Saturday, 30 November 2013 at 12:51:46 UTC, Rene Zwanenburg 
wrote:
 On Saturday, 30 November 2013 at 08:35:23 UTC, Frustrated wrote:
 I need to pass around some objects(specifically int[]) that 
 may be used by several other objects at the same time. While I 
 could clone these and free them when the parent object is done 
 this wastes memory for no real reason except ease of use.

 Since many objects may contain a ptr to the array, what would 
 be the best way to deal with deallocating them? I could wrap 
 the array in a collection an use ARC but is there a better way?

 Is there something in std.allocators that can help?

 (Should be obvious that I'm trying to avoid the GC)
You can use the Array type in std.container [1]. It uses ref counting and the C heap internally. [1] http://dlang.org/phobos/std_container.html#.Array
How does it work? When you call clear it decrements the reference count and at 0 it free's the memory? That is the only self managed container in std.container?
Nov 30 2013
prev sibling parent reply "bioinfornatics" <bioinfornatics feforaproject.org> writes:
On Saturday, 30 November 2013 at 08:35:23 UTC, Frustrated wrote:
 I need to pass around some objects(specifically int[]) that may 
 be used by several other objects at the same time. While I 
 could clone these and free them when the parent object is done 
 this wastes memory for no real reason except ease of use.

 Since many objects may contain a ptr to the array, what would 
 be the best way to deal with deallocating them? I could wrap 
 the array in a collection an use ARC but is there a better way?

 Is there something in std.allocators that can help?

 (Should be obvious that I'm trying to avoid the GC)
Why you do not use one of this way: - const ref int[]… into function parameter - using shared/synchronized and ref to array
Nov 30 2013
parent "Frustrated" <c1514843 drdrb.com> writes:
On Sunday, 1 December 2013 at 02:29:42 UTC, bioinfornatics wrote:
 On Saturday, 30 November 2013 at 08:35:23 UTC, Frustrated wrote:
 I need to pass around some objects(specifically int[]) that 
 may be used by several other objects at the same time. While I 
 could clone these and free them when the parent object is done 
 this wastes memory for no real reason except ease of use.

 Since many objects may contain a ptr to the array, what would 
 be the best way to deal with deallocating them? I could wrap 
 the array in a collection an use ARC but is there a better way?

 Is there something in std.allocators that can help?

 (Should be obvious that I'm trying to avoid the GC)
Why you do not use one of this way: - const ref int[]… into function parameter - using shared/synchronized and ref to array
It would seem if I am going to use some way it needs to be consistent. The first case would require creating []'s outside of the function which then doesn't solve the original problem. I'm not sure how the second case solves anything?
Dec 01 2013