Revamped concurrency API

[Jeremie Pelletier]

Robert Jacques wrote:
> On Mon, 12 Oct 2009 21:45:20 -0400, Michel Fortin 
> <michel.fortin at michelf.com> wrote:
> 
>> On 2009-10-12 11:45:55 -0400, Andrei Alexandrescu 
>> <SeeWebsiteForEmail at erdani.org> said:
>>
>>> Occasionally people here ask for ways in which they can help D. One 
>>> thing that would be extremely helpful at this point would be to help 
>>> defining and implementing D's new concurrency API. Unfortunately, 
>>> Bartosz has declined to contribute. That leaves Walter, Sean, Don, 
>>> and participants to this group to do it.
>>
>> So Bartosz quit? Not that much surprising given the all too many 
>> missing building blocks.
>>
>> I recently realized that you can easily implement unique in a library. 
>> It can work pretty much the same as auto_ptr in C++. But to guaranty 
>> uniqueness you need either to rely on convention (as in C++), or add 
>> support for lent to the compiler.
>>
>> I know we discussed at length how lent could be implemented, we called 
>> it 'scope' and 'escape analysis' at the time and the conclusion you 
>> (and Walter I guess) came with was that it was too much for D2.
>>
>> Well, without lent (and thus without unique), safe message passing 
>> systems across threads will be limited to immutable data, or copied 
>> data, which not at all useful in many situations.
>>
>> Now if you want a good concurrency API relying on convention, then 
>> that's great: there are plenty of examples to follow out there. But if 
>> you want it to be both safe (enforced) and useful at the same time, 
>> that's a mission impossible with the current set of tools available 
>> from the compiler.
>>
>> That's why I'm not surprised Bartosz declined to implement it.
>>
>> (And sorry if I sound pessimistic.)
>>
>>
> 
> I agree. Particularly about lent. Immutable and mutable weren't 
> considered complete without const, so I'm surprised that local and 
> shared are considered complete without lent. You can even implement it 
> without escape analysis. Strangely, from what I remember of Bartosz's 
> posts, it was unique that was the sticking point, though you can 
> implement both unique and owned as library types (though they do become 
> less efficient).

I may sound ignorant, but that does lent means? I mean the word itself, 
I couldn't find something relevant on google.

Anyways, I agree that we need a type qualifier between unshared (local) 
and shared, just like const sits between mutable and immutable. It would 
make shared handling just so much easier and convenient.

If shared/lent were properly implemented and as easy to use as 
immutable/const, we'd already begin to see concurrency APIs, I tried a 
few times to implement different concurrency models and always failed 
due to shared requiring either too much casts or forces too many 
structures and methods to be shared.

I vote for a 'lent' qualifier to be implemented in the compiler.

Jeremie