1/**
2 * Contains the internal GC interface.
3 *
4 * Copyright: Copyright Digital Mars 2016.
5 * License:   $(HTTP www.boost.org/LICENSE_1_0.txt, Boost License 1.0).
6 * Authors:   Walter Bright, Sean Kelly, Jeremy DeHaan
7 */
8
9 /*          Copyright Digital Mars 2016.
10 * Distributed under the Boost Software License, Version 1.0.
11 *    (See accompanying file LICENSE or copy at
12 *          http://www.boost.org/LICENSE_1_0.txt)
13 */
14module core.gc.gcinterface;
15
16static import core.memory;
17alias BlkAttr = core.memory.GC.BlkAttr;
18alias BlkInfo = core.memory.GC.BlkInfo;
19
20alias RootIterator = int delegate(scope int delegate(ref Root) nothrow dg);
21alias RangeIterator = int delegate(scope int delegate(ref Range) nothrow dg);
22
23
24struct Root
25{
26    void* proot;
27    alias proot this;
28}
29
30struct Range
31{
32    void* pbot;
33    void* ptop;
34    TypeInfo ti; // should be tail const, but doesn't exist for references
35    alias pbot this; // only consider pbot for relative ordering (opCmp)
36    bool opEquals(const scope Range rhs) nothrow const { return pbot == rhs.pbot; }
37}
38
39interface GC
40{
41    /**
42     *
43     */
44    void enable();
45
46    /**
47     *
48     */
49    void disable();
50
51    /**
52     *
53     */
54    void collect() nothrow;
55
56    /**
57     *
58     */
59    void collectNoStack() nothrow;
60
61    /**
62     * minimize free space usage
63     */
64    void minimize() nothrow;
65
66    /**
67     *
68     */
69    uint getAttr(void* p) nothrow;
70
71    /**
72     *
73     */
74    uint setAttr(void* p, uint mask) nothrow;
75
76    /**
77     *
78     */
79    uint clrAttr(void* p, uint mask) nothrow;
80
81    /**
82     *
83     */
84    void* malloc(size_t size, uint bits, const TypeInfo ti) nothrow;
85
86    /*
87     *
88     */
89    BlkInfo qalloc(size_t size, uint bits, const scope TypeInfo ti) nothrow;
90
91    /*
92     *
93     */
94    void* calloc(size_t size, uint bits, const TypeInfo ti) nothrow;
95
96    /*
97     *
98     */
99    void* realloc(void* p, size_t size, uint bits, const TypeInfo ti) nothrow;
100
101    /**
102     * Attempt to in-place enlarge the memory block pointed to by p by at least
103     * minsize bytes, up to a maximum of maxsize additional bytes.
104     * This does not attempt to move the memory block (like realloc() does).
105     *
106     * Returns:
107     *  0 if could not extend p,
108     *  total size of entire memory block if successful.
109     */
110    size_t extend(void* p, size_t minsize, size_t maxsize, const TypeInfo ti) nothrow;
111
112    /**
113     *
114     */
115    size_t reserve(size_t size) nothrow;
116
117    /**
118     *
119     */
120    void free(void* p) nothrow @nogc;
121
122    /**
123     * Determine the base address of the block containing p.  If p is not a gc
124     * allocated pointer, return null.
125     */
126    void* addrOf(void* p) nothrow @nogc;
127
128    /**
129     * Determine the allocated size of pointer p.  If p is an interior pointer
130     * or not a gc allocated pointer, return 0.
131     */
132    size_t sizeOf(void* p) nothrow @nogc;
133
134    /**
135     * Determine the base address of the block containing p.  If p is not a gc
136     * allocated pointer, return null.
137     */
138    BlkInfo query(void* p) nothrow;
139
140    /**
141     * Retrieve statistics about garbage collection.
142     * Useful for debugging and tuning.
143     */
144    core.memory.GC.Stats stats() @safe nothrow @nogc;
145
146    /**
147     * Retrieve profile statistics about garbage collection.
148     * Useful for debugging and tuning.
149     */
150    core.memory.GC.ProfileStats profileStats() @safe nothrow @nogc;
151
152    /**
153     * add p to list of roots
154     */
155    void addRoot(void* p) nothrow @nogc;
156
157    /**
158     * remove p from list of roots
159     */
160    void removeRoot(void* p) nothrow @nogc;
161
162    /**
163     *
164     */
165    @property RootIterator rootIter() @nogc;
166
167    /**
168     * add range to scan for roots
169     */
170    void addRange(void* p, size_t sz, const TypeInfo ti) nothrow @nogc;
171
172    /**
173     * remove range
174     */
175    void removeRange(void* p) nothrow @nogc;
176
177    /**
178     *
179     */
180    @property RangeIterator rangeIter() @nogc;
181
182    /**
183     * run finalizers
184     */
185    void runFinalizers(const scope void[] segment) nothrow;
186
187    /*
188     *
189     */
190    bool inFinalizer() nothrow @nogc @safe;
191
192    /**
193     * Returns the number of bytes allocated for the current thread
194     * since program start. It is the same as
195     * GC.stats().allocatedInCurrentThread, but faster.
196     */
197    ulong allocatedInCurrentThread() nothrow;
198}
199