www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.announce - Visual Studio Community and .NET Open Source

reply "Michael" <pr m1xa.com> writes:
It's happening.

Studio Pro for free ;)
http://blogs.msdn.com/b/visualstudio/archive/2014/11/12/visual-studio-2015-preview-visual-studio-community-2013-visual-studio-2013-update-4-and-more.aspx

.NET Open Source
http://blogs.msdn.com/b/dotnet/archive/2014/11/12/net-core-is-open-source.aspx

.NET have a good and open sourced GC, so maybe it's possible to 
get something useful from it?
Nov 12 2014
parent reply "philippecp" <philly.dilly gmail.com> writes:
.Net does have a pretty damn good GC. It is both a moving garbage
collector (improves locality, reduces heap fragmentation and
allows for memory allocation to be a single pointer operation)
and a generational garbage collector (reduces garbage collection
cost by leveraging heuristic that most collected objects are
usually very young). I believe their server GC is even concurrent
to avoid long stop the world pauses.

The problem is I'm not sure how much of those principles can be
applied to D. I can see moving objects being problematic given
that D supports unions. Another thing to consider is that .Net's
GC is the results of many man years of full time work on a single
platform, while D is mostly done by volunteers in their spare
time for many platforms. It would probably require a lot of work
to port, unless you're volunteering yourself for that work;)

On a related note, I've wondered for a long time why D's GC isn't
generational and why there's all this discussion on making it
concurrent and none on making it generational. It seems to me
that making it generational is simpler than making it concurrent
and provides a net win in overall performance while concurrent
only provides a win for real time systems that can't afford long
GC cycles.
Nov 21 2014
next sibling parent "Marc =?UTF-8?B?U2Now7x0eiI=?= <schuetzm gmx.net> writes:
On Friday, 21 November 2014 at 08:02:07 UTC, philippecp wrote:

 The problem is I'm not sure how much of those principles can be
 applied to D. I can see moving objects being problematic given
 that D supports unions.


Unions make up only a small percentage of all objects; a mostly 
precise GC can be enough. It cannot be fully precise anyway, 
because of C code (addRoot), and the stack, which is hard to make 
precise.


 On a related note, I've wondered for a long time why D's GC 
 isn't
 generational and why there's all this discussion on making it
 concurrent and none on making it generational. It seems to me
 that making it generational is simpler than making it concurrent
 and provides a net win in overall performance while concurrent
 only provides a win for real time systems that can't afford long
 GC cycles.


There is some work. For example, Rainer Schuetze presented a 
precise GC at Dconf, which is a requirement for that. See also 
this post by deadalnix, who proposes separating the global 
heap(s) from the thread-local ones:
http://forum.dlang.org/thread/kpgilxyyrrluxpepepcg forum.dlang.org
Nov 21 2014
prev sibling parent reply "Paulo Pinto" <pjmlp progtools.org> writes:
On Friday, 21 November 2014 at 08:02:07 UTC, philippecp wrote:

 .Net does have a pretty damn good GC. It is both a moving 
 garbage
 collector (improves locality, reduces heap fragmentation and
 allows for memory allocation to be a single pointer operation)
 and a generational garbage collector (reduces garbage collection
 cost by leveraging heuristic that most collected objects are
 usually very young). I believe their server GC is even 
 concurrent
 to avoid long stop the world pauses.

 The problem is I'm not sure how much of those principles can be
 applied to D. I can see moving objects being problematic given
 that D supports unions. Another thing to consider is that .Net's
 GC is the results of many man years of full time work on a 
 single
 platform, while D is mostly done by volunteers in their spare
 time for many platforms. It would probably require a lot of work
 to port, unless you're volunteering yourself for that work;)

 ...



The official .NET runs on x86, x64, ARM (including cortex 
variants), MIPS.

It scales from embedded hardware running with 512KB of flash and 
128KB of RAM (http://www.netmf.com/get-started/), all the way up 
to Azure deployments.

http://www.microsoft.com/net/multiple-platform-support

--
Paulo
Nov 21 2014
parent "philippecp" <philly.dilly gmail.com> writes:
On Friday, 21 November 2014 at 12:54:05 UTC, Paulo  Pinto wrote:

 On Friday, 21 November 2014 at 08:02:07 UTC, philippecp wrote:

 .Net does have a pretty damn good GC. It is both a moving 
 garbage
 collector (improves locality, reduces heap fragmentation and
 allows for memory allocation to be a single pointer operation)
 and a generational garbage collector (reduces garbage 
 collection
 cost by leveraging heuristic that most collected objects are
 usually very young). I believe their server GC is even 
 concurrent
 to avoid long stop the world pauses.

 The problem is I'm not sure how much of those principles can be
 applied to D. I can see moving objects being problematic given
 that D supports unions. Another thing to consider is that 
 .Net's
 GC is the results of many man years of full time work on a 
 single
 platform, while D is mostly done by volunteers in their spare
 time for many platforms. It would probably require a lot of 
 work
 to port, unless you're volunteering yourself for that work;)

 ...



 The official .NET runs on x86, x64, ARM (including cortex 
 variants), MIPS.

 It scales from embedded hardware running with 512KB of flash 
 and 128KB of RAM (http://www.netmf.com/get-started/), all the 
 way up to Azure deployments.

 http://www.microsoft.com/net/multiple-platform-support

 --
 Paulo


I meant operating system, not architecture. At this point it 
still only runs on Windows based OS.
Nov 22 2014