similar to: [LLVMdev] Garbage Collection Project

Hello, 2009/2/26 Talin <viridia at gmail.com> > The IR-level intrinsics themselves don't much help you *write* a GC, so > much as to integrate one with LLVM. What is provided is essentially a > mechanism for walking the stack, and a means to insert read/write > barriers into the generated code, which together form a tiny fraction of > what it would take to design a

On 2007-09-15, at 18:01, Talin wrote: > I'm still (slowly) working on the project of creating a concurrent > garbage collector that works with LLVM. I want to ask a little bit > more about object tags and write barriers and so on. > > Let's start with the assumption that a particular language does not > use per-object type tags. The code generator knows the types

On 2007-09-15, at 23:55, Talin wrote: > Gordon Henriksen wrote: > >> Can you be more specific the algorithm for which you need type >> metadata in a write barrier? No algorithms I am aware of perform >> any tracing from a write barrier. > > This one does: > > http://citeseer.ist.psu.edu/cache/papers/cs2/442/ >

LLVMers, Attached for your review: basic infrastructure for efficient garbage collectors. Only enough information is currently gathered to support the runtime I'm working with, and -print-gc is currently the only consumer of this information. All collector policies are presently controlled by constants. There are no regressions (on darwin-i686) if the feature is left disabled. If

Gordon Henriksen wrote: > Can you be more specific the algorithm for which you need type > metadata in a write barrier? No algorithms I am aware of perform any > tracing from a write barrier. > This one does: http://citeseer.ist.psu.edu/cache/papers/cs2/442/http:zSzzSzwww.cs.technion.ac.ilzSz~erezzSzPaperszSzms-sliding-views.pdf/an-on-the-fly.pdf > Write barriers are

One of the more interesting subjects of conversation at the 2008 developer day was related to garbage collection. With the increasing number of LLVM-based VMs and other projects, I suspect that the desire for more comprehensive garbage collection support in LLVM is only going to increase. (I am now involved in two different open-source projects both of which will eventually have a strong

On 2007-09-03, at 23:14, Talin wrote: > On Sep 2, 2007 5:31 AM, Gordon Henriksen <gordonhenriksen at mac.com> > wrote: > >> On Sep 2, 2007, at 04:54, Talin wrote: >> >>> I've been looking through the documentation (http://llvm.org/docs/ >>> GarbageCollection.html) on how to implement a garbage collector >>> for LLVM and there's a

On Fri, 2010-09-17 at 12:16 +0100, David Given wrote: > On 17/09/10 09:55, Pedro Ferreira wrote: > > As I understand it, LLVM simply gives you support for garbage collectors > > that you have to implement yourself and link into the final binary, > > similar to what C's malloc does (it's a library call). The issue with > > GC's is that they need to be provided

Gordon Henriksen wrote: > The intrinsics are entirely neutral to collector implementation, and > thus to threading. They could easily be used to implement reference > counting, for instance, which may or may not be implemented in a > threadsafe manner. However, as with your algorithm, reference counting > does not require code generator support, and so would not justify the

Ralf Schneider wrote: > A little bit off topic: Has anybody tried building a concurrent GC - > running in a different _process_, instead of a thread? > The idea: To perform a collection you do a fork(). The child process > collects all unreferenced memory regions and reports them back to the > parent process. I remember reading a paper in ACM Sigplan Notices (I think) many years

On 2009-02-26 18:22, Gabor Greif wrote: > On Feb 26, 2:18 pm, Ralf Schneider <li... at gestaltgeber.com> wrote: > >> Hello, >> >> 2009/2/26 Talin <viri... at gmail.com> >> >> >>> The IR-level intrinsics themselves don't much help you *write* a GC, so >>> much as to integrate one with LLVM. What is provided is essentially

As I understand it, LLVM simply gives you support for garbage collectors that you have to implement yourself and link into the final binary, similar to what C's malloc does (it's a library call). The issue with GC's is that they need to be provided info about the stack, thats where LLVM's support comes in. As far as I know, the garbage collector is linked into the final binary

Chris Lattner wrote: > On Feb 26, 2009, at 12:02 AM, Talin wrote: > >> With the increasing >> number of LLVM-based VMs and other projects, I suspect that the desire >> for more comprehensive garbage collection support in LLVM is only >> going >> to increase. >> > > Absolutely! > > >> Part of the reason why there isn't

On Feb 26, 2009, at 12:02 AM, Talin wrote: > With the increasing > number of LLVM-based VMs and other projects, I suspect that the desire > for more comprehensive garbage collection support in LLVM is only > going > to increase. Absolutely! > Part of the reason why there isn't more direct support for GC is the > theory that there is no such thing as a

On Feb 26, 2:18 pm, Ralf Schneider <li... at gestaltgeber.com> wrote: > Hello, > > 2009/2/26 Talin <viri... at gmail.com> > > > The IR-level intrinsics themselves don't much help you *write* a GC, so > > much as to integrate one with LLVM. What is provided is essentially a > > mechanism for walking the stack, and a means to insert read/write > >

On Tuesday 16 June 2009 07:37:32 Talin wrote: > A while back there was a discussion thread about whether an accurate, > concurrent garbage collector could be "generic" in the sense of being > able to support multiple different languages efficiently. After having > done some work on this, I now believe that this is the case - using C++ > policy-based design principles, you

Hello, I want to add garbage collection support to a compiler with a llvm backend, using the shadow-stack compiler plugin. I read the GC tutorial in the LLVM documentation, and the paper about shadow-stacks. Im currently adding intrinsics to my generated llvm code, and trying to write code to connected it to my (existing) garbage collector library. Im not sure yet how everything fits together.

Thanks for the example code. Its gives a good idea how the shadow stack works. But I have another question. Using the shadow stack is a nice and simple way to implement GC, but it might have a large runtime overhead per function call. Is there another way to preserve garbage specific information (gcroots) through the llvm optimizer and native code generator? This information could be used to

On Feb 27, 2009, at 12:56, Mark Shannon wrote: > Gordon Henriksen wrote: > >> The ultimate endgoal is to support schemes with still-lower >> execution overhead. The next step for LLVM GC would be elimination >> of the reload penalty for using GC intrinsics with a copying >> collector. This, again, requires that the code generator perform >> bookkeeping

A while back there was a discussion thread about whether an accurate, concurrent garbage collector could be "generic" in the sense of being able to support multiple different languages efficiently. After having done some work on this, I now believe that this is the case - using C++ policy-based design principles, you can create a set of modules that represent different aspects of