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)

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

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

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?

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

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?