First of all: I apologize for my bad english.
In the last few weeks I searched for a way to allocate nicely
temporary buffer of unknown lengths. Since D has no VLA's like C
(and alloca works only partial for some strange reason:
https://d.puremagic.com/issues/show_bug.cgi?id=3753), malloc /
free was obiously the solution, but you have only two choices:
1. Allocate them (and maybe slice them) and free the ptr at the
end of the scope (or use scope(exit)). But: Make sure that your
array has not been taken over by the GC, because you made a
mistake [1].
Example:
----
int* ptr = .malloc(N * int.sizeof); /// N is a runtime lengths
int[] arr = ptr[0 .. N]; /// optional slice
scope(exit) .free(ptr); // or more dangerous: free(arr.ptr);
----
Fail example:
----
int[] arr = (cast(T*) .malloc(N * int.sizeof))[0 .. N];
arr ~= 42; /// <-- [1]
scope(exit) .free(arr.ptr);
/*
* Because you don't thought about that 'arr' is a full filled
array and nothing you can append to,
* the GC takes over the memory and you don't have a chance to
get the right C pointer to free your C memory: memory leak [A
-nogc flag would maybe help here]
*/
----
2. Use a struct.
----
struct Temp(T) {
T* ptr;
alias ptr this;
this(size_t N) {
this.arr = cast(T*) .malloc(N * T.sizeof);
}
~this() {
.free(this.ptr);
}
}
Temp!int arr = Temp!int(512); /// arr is destroyed at the end of
the scope
----
But that does not look very nice (especially because Temp!int
does not indicate that it holds an array).
Something like:
----
int[] arr = new int[512];
----
Looks nicer and more intuitive. But: it is controlled by the GC.
If you want to destroy it, you have to call GC.free manually. So
we have the same problems/options to destroy it as with
malloc/free.
During the std.allocator thread I had made the suggestion to
use this allocators for such temporary arrays (See also Andrej
Mitrovic post:
http://forum.dlang.org/thread/l4btsk$5u8$1...@digitalmars.com?page=2#post-mailman.2478.1382651916.1719.digitalmars-d:40puremagic.com)
For example:
----
Mallocator m;
with (m) {
int[] arr;
arr ~= 42; /// use Mallocator m for memory allocation [Question
is: when it is freed? At the end of the scope? Maybe we need a
(Temp|Scope)Alloc]
}
----
Or, even better.
----
with (Mallocator) {
int[] arr;
arr ~= 42; /// use Mallocator for memory allocation [Same
question]
}
----
Yet another idea of mine was:
----
int[] arr;
arr.use(Mallocator);
----
Or something better: "use" blocks:
----
use (Mallocator) {
int[] arr;
}
arr ~= 42; /// use Mallocator for memory allocation [Same
question]
----
But both would bring the introduction of a new keywords with them.
Over the last few days I had a few other ideas, besides the nice
stuff from std.allocator.
One of them was to use scope:
----
scope int[] arr = new int[42]; /// arr is freed at the end of the
scope
----
The compiler could rewrite this e.g. with:
----
struct scoped(A : T[], T) {
T[] arr;
~this() {
GC.free(arr.ptr);
}
}
scoped!(int[]) arr = new int[42]; /// arr is freed as far as
scoped's DTor is called.
----
In this case we have no need to introduce a new keyword: scope is
already there.
Or, to use UDA's (but they must be improved):
----
struct temp {
void* ptr;
~this() {
GC.free(this.ptr);
}
}
@temp int[] arr = new int[42]; /// arr is freed as far as temp's
DTor is called ( -> if temp leaves the scope)
----
The code above would be simply rewritten to:
----
int[] arr = new int[42];
temp __udatmp = temp(arr.ptr); /// temp's DTor free the whole
array [Need compiler magic]
----
Another suggestion would be DIP 46 (http://wiki.dlang.org/DIP46)
with a few improvements:
----
gc_push(Mallocator);
int[] arr;
arr ~= 42;
gc_pop(); /// arr is freed (maybe it would make sense if gc_pop
would be automatically inserted at the end of the scope).
----
That's it so far. Any thoughts/further suggestions?
