[Issue 6911] New: Built-in trait to tell functions that allocate from the GC heap

d-bugmail at puremagic.com d-bugmail at puremagic.com
Tue Nov 8 16:02:31 PST 2011


http://d.puremagic.com/issues/show_bug.cgi?id=6911

           Summary: Built-in trait to tell functions that allocate from
                    the GC heap
           Product: D
           Version: D2
          Platform: Other
        OS/Version: Windows
            Status: NEW
          Severity: enhancement
          Priority: P2
         Component: DMD
        AssignedTo: nobody at puremagic.com
        ReportedBy: bearophile_hugs at eml.cc


--- Comment #0 from bearophile_hugs at eml.cc 2011-11-08 16:01:52 PST ---
Here Don presents the idea of a dedicated GC for pure functions:

http://www.digitalmars.com/d/archives/digitalmars/D/GC_for_pure_functions_--_implementation_ideas_134817.html

This is a part of the first post:

> (Note that the compiler can determine if a function makes any 
> memory allocations, simply by inspecting its body -- it isn't any more 
> difficult than checking if it is nothrow).

Once this idea is implemented, it's very easy to offer it to D programmers too.

So as step to implement Don's GC idea I think it will be useful a
__traits(gcallocates, someFunction) that returns true at compile-time if
someFunction performs allocations from the GC heap. This trait is transitive,
so to return true all the functions called by someFunction need to not perform
GC activity, even if they are in other modules (but the lack of GC allocations
is not a function attribute includes in function signatures as @noheap of bug
5219, so maybe in some situations this feature has to be conservative an err on
the side of safety).

- - - - - - - - - - - -

Knowing that a function is GC-free is quite useful in certain situations.

If you write:

int foo(in int x) {
    ...
}
static assert(__traits(gcallocates, foo));


It's likes writing:

@noheap int foo(in int x) {
    ...
}

The main differences are that @noheap is part of the signature of foo.

- - - - - - - - - - - -

Adding an annotation like this, where somehighLevelFunction is a function
that's the root of a big part of a program allows to be sure the big part
doesn't use the GC:

static assert(__traits(gcallocates, somehighLevelFunction));

The whole program is GC-free:

static assert(__traits(gcallocates, main));

To use this well, I think __traits(gcallocates,...) has to return good error
messages, like a stack trace, that shows that functions (or the first found
function) of the tree of functions called by someFunction are not GC-free.

- - - - - - - - - - - -

A comment by Gor Gyolchanyan:

http://www.digitalmars.com/webnews/newsgroups.php?art_group=digitalmars.D&article_id=148522

> , because it would allow to specialize
> functions based on the way, let's say, delegates behave and if they
> don't use GC, the specialized function would also restrain from using
> it making it follow the behavior pattern and making it much more
> usable in performance-critical environments, while keeping it usable
> in GC-aware environment too.

- - - - - - - - - - - -

See also:
bug 5219 (@noheap annotation)
bug 5070 (Heap-allocated closures listing)

-- 
Configure issuemail: http://d.puremagic.com/issues/userprefs.cgi?tab=email
------- You are receiving this mail because: -------


More information about the Digitalmars-d-bugs mailing list