On Friday, 2 May 2014 at 06:51:49 UTC, deadalnix wrote:
First the original post I made on this forum :
http://forum.dlang.org/thread/[email protected]#post-kluaojijixhwigoujeip:40forum.dlang.org
Now some sample code/explanation to get it better.
Isolated in a proposal adapted from an experiment made in C#
for D. It introduces a new qualifier. The qualifier is
necessary on function signatures (inference is possible to some
extent, like for pure functions), object/struct fields and
globals. It is inferred on local variables (but can be
explicited if one wish).
An isolated is in an 'island'. The 'island' is implicit and
tracked by the compiler. We have one immutable and one shared
island. We have one TL island per thread. And we can have an
infinity of isolated island.
An isolated is consumed when:
- it is returned
- it is passed as argument
- it is assigned to another island
When an isolated goes out of scope without being consumed, the
compiler can free the whole island:
void foo() {
A a = new A(); // a is isolated if A's ctor allows.
// a is not consumed. The compiler can insert memory freeing.
}
As we can see, it allows the compiler to do some freeing for us
to reduce GC pressure. Manu why aren't you already here
cheering ?
When an isolated is consumed, the island it is in is merged
into the island that consumes it. All reference to the island
become write only until next write.
void foo() {
A a = new A(); // a is isolated
immutable b = a; // a's island is merged into immutable
// a's island has been consumed. a is not readable at this
point.
// a.foo() // Error
a = new A(); // OK
a.foo(); // OK, we have written in a.
}
So far, we saw that isolated helps to construct
const/immutable/shared objects and can be used by the compiler
to insert free.
isolated also help to bridge the RC world and the GC world.
struct RC(T) is(isReferenceType!T) {
private T mystuff;
this(isolated T stuff) {
mystuff = stuff;
}
// All code to do ref counting goes here...
}
Here, the RC struct must be constructed with an isolated. To do
so, the isolated have to be passed as argument: it is consumed.
As a result, the RC struct can be sure that it has the only
usable reference to stuff that is around.
Now some concurrency goodies:
void foo() {
auto tid = spawn(&spawnedFunc, thisTid);
A a = new A();
send(tid, a); // OK, a is an isolated.
// a can't be used here anymore as it is consumed.
// You can simply pass isolated around across thread safely.
}
Now that is pretty sweet. First we don't have to do the crazy
and unsafe dance of "cast to shared and cast back to me" and
this is actually safe. Go's type system do is not safe across
channel, that puts us ahead in one of the things go does best.
std.parallelism can also benefit from this. There is also
several benefit when the optimizer knows about isolated
(different island do not alias each other).
I hope the idea get across better with some sample code and
will be considered. As sample code shows, isolated do not need
to be specified explicitly often. User not annotating can get a
lot of benefit out of the concept right away.
I've been thinking about something similar as being an 'obvious'
idea.
It to me seems rather a good idea.
