D on next-gen consoles and for game development

[Manu]

On 28 May 2013 23:33, Steven Schveighoffer <schveiguy at yahoo.com> wrote:

> On Sat, 25 May 2013 01:52:10 -0400, Manu <turkeyman at gmail.com> wrote:
>
>  What does ObjC do? It seems to work okay on embedded hardware (although
>> not
>> particularly memory-constrained hardware).
>> Didn't ObjC recently reject GC in favour of refcounting?
>>
>
> Having used ObjC for the last year or so working on iOS, it is a very nice
> memory management model.
>
> Essentially, all objects (and only objects) are ref-counted automatically
> by the compiler.  In code, whenever you assign or pass a pointer to an
> object, the compiler automatically inserts retains and releases extremely
> conservatively.
>
> Then, the optimizer comes along and factors out extra retains and
> releases, if it can prove they are necessary.
>
> What I really like about this is, unlike a library-based solution where
> every assignment to a 'smart pointer' incurs a release/retain, the compiler
> knows what this means and will factor them out, removing almost all of
> them.  It's as if you inserted the retains and releases in the most
> optimized way possible, and it's all for free.
>
> Also, I believe the compiler is then free to reorder retains and releases
> since it understands how they work.  Of course, a retain/release is an
> atomic operation, and requires memory barriers, so the CPU/cache cannot
> reorder, but the compiler still can.
>

Right. This is almost precisely how I imagined it would be working.
I wonder what it would take to have this as a GC strategy in D?
I'm more and more thinking this would be the best approach for realtime
software.
It's deterministic, and while being safe like a GC, the programmer retains
absolute control.
Also, things are destroyed when you expect (again, the deterministic thing).
I think this GC strategy will open D for use on much more embedded hardware.


I asked David Nadlinger at the conference whether we could leverage this
> power in LDC, since LLVM is the compiler back-end used by Apple, but he
> said all those optimization passes are in the Objective-C front-end.
>

Yeah, this would require D front-end work I'm sure.


It would be cool/useful to have compiler-native reference counting.  The
> only issue is, Objective-C is quite object-heavy, and it's statically
> checkable whether a pointer is an Object pointer or not.  In D, you would
> have to conservatively use retains/releases on every pointer, since any
> memory block could be ref-counted.  But just like Objective-C most of them
> could be factored out.  Add in that D has the shared-ness of the pointer
> built into the type system, and you may have something that is extremely
> effective.
>

Yep, I can imagine it would work really well, if the front-end implemented
the logic to factor out redundant inc/dec ref's.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.puremagic.com/pipermail/digitalmars-d/attachments/20130528/bf45efa8/attachment.html>