git.iko.soy/Idris-dev
on master help sign in
Clean up C heap RTS code.
557fbe3Matus Tejiscak
rts/idris_gc.c+3−3
compare with master
unifiedsplit
@@ -137,11 +137,11 @@ void idris_gc(VM* vm) {
137 vm->heap.size += vm->heap.growth;
137 vm->heap.size += vm->heap.growth;
138 }
138 }
139
139
140− STATS_LEAVE_GC(vm->stats, vm->heap.size, vm->heap.next - vm->heap.heap)
141− HEAP_CHECK(vm)
142−
143 // finally, sweep the C heap
140 // finally, sweep the C heap
144 c_heap_sweep(&vm->c_heap);
141 c_heap_sweep(&vm->c_heap);
142+
143+ STATS_LEAVE_GC(vm->stats, vm->heap.size, vm->heap.next - vm->heap.heap)
144+ HEAP_CHECK(vm)
145}
145}
146
146
147void idris_gcInfo(VM* vm, int doGC) {
147void idris_gcInfo(VM* vm, int doGC) {
rts/idris_heap.c+5−11
@@ -5,7 +5,7 @@
5#include <stddef.h>
5#include <stddef.h>
6#include <stdio.h>
6#include <stdio.h>
7
7
8−void c_heap_free(CHeapItem * item)
8+static void c_heap_free_item(CHeapItem * item)
9{
9{
10 // fix links
10 // fix links
11 if (item->next != NULL)
11 if (item->next != NULL)
@@ -21,13 +21,7 @@ void c_heap_free(CHeapItem * item)
21 free(item);
21 free(item);
22}
22}
23
23
24−CHeapItem * c_heap_allocate(size_t size, CDataFinalizer_t * finalizer)
24+CHeapItem * c_heap_create_item(void * data, CDataFinalizer * finalizer)
25−{
26− void * data = (void *) malloc(size);
27− return c_heap_create_item(data, finalizer);
28−}
29−
30−CHeapItem * c_heap_create_item(void * data, CDataFinalizer_t * finalizer)
31{
25{
32 CHeapItem * item = (CHeapItem *) malloc(sizeof(CHeapItem));
26 CHeapItem * item = (CHeapItem *) malloc(sizeof(CHeapItem));
33
27
@@ -75,7 +69,7 @@ void c_heap_sweep(CHeap * heap)
75 CHeapItem * unused_item = p;
69 CHeapItem * unused_item = p;
76 p = p->next;
70 p = p->next;
77
71
78− c_heap_free(unused_item);
72+ c_heap_free_item(unused_item);
79 }
73 }
80 }
74 }
81}
75}
@@ -89,11 +83,11 @@ void c_heap_destroy(CHeap * heap)
89{
83{
90 while (heap->first != NULL)
84 while (heap->first != NULL)
91 {
85 {
92− c_heap_free(heap->first); // will update heap->first via the backward link
86+ c_heap_free_item(heap->first); // will update heap->first via the backward link
93 }
87 }
94}
88}
95
89
96−/* Used for initializing the heap. */
90+/* Used for initializing the FP heap. */
97void alloc_heap(Heap * h, size_t heap_size, size_t growth, char * old)
91void alloc_heap(Heap * h, size_t heap_size, size_t growth, char * old)
98{
92{
99 char * mem = malloc(heap_size);
93 char * mem = malloc(heap_size);
rts/idris_heap.h+31−7
@@ -6,32 +6,56 @@
6
6
7/* *** C heap ***
7/* *** C heap ***
8 * Objects with finalizers. Mark&sweep-collected.
8 * Objects with finalizers. Mark&sweep-collected.
9+ *
10+ * The C heap is implemented as a doubly linked list
11+ * of pointers coupled with their finalizers.
9 */
12 */
10
13
11−typedef void CDataFinalizer_t(void *);
14+typedef void CDataFinalizer(void *);
12
15
13typedef struct CHeapItem {
16typedef struct CHeapItem {
17+ /// Payload.
14 void * data;
18 void * data;
15− CDataFinalizer_t * finalizer; // should free() the passed data pointer, too
19+
20+ /// Finalizer that will be called on the payload pointer.
21+ /// Its job is to deallocate all associated resources,
22+ /// including the memory pointed to by `data` (if any).
23+ CDataFinalizer * finalizer;
24+
25+ /// The mark bit set by the FP heap traversal,
26+ /// cleared by C heap sweep.
16 bool is_used;
27 bool is_used;
28+
29+ /// Next item in the C heap.
17 struct CHeapItem * next;
30 struct CHeapItem * next;
31+
32+ /// Pointer to the previous next-pointer.
18 struct CHeapItem ** prev_next;
33 struct CHeapItem ** prev_next;
19} CHeapItem;
34} CHeapItem;
20
35
21typedef struct CHeap {
36typedef struct CHeap {
37+ /// The first item in the heap. NULL if the heap is empty.
22 CHeapItem * first;
38 CHeapItem * first;
23} CHeap;
39} CHeap;
24
40
41+/// Create a C heap.
25void c_heap_init(CHeap * c_heap);
42void c_heap_init(CHeap * c_heap);
43+
44+/// Destroy the given C heap. Will not deallocate the given pointer.
45+/// Will call finalizers & deallocate all blocks in the heap.
26−void c_heap_destroy(CHeap * c_heap); // will call finalizers on everything
46+void c_heap_destroy(CHeap * c_heap);
47+
48+/// Insert the given item into the heap if it's not there yet.
27void c_heap_insert_if_needed(CHeap * c_heap, CHeapItem * item);
49void c_heap_insert_if_needed(CHeap * c_heap, CHeapItem * item);
50+
51+/// Mark the given item as used.
28void c_heap_mark_item(CHeapItem * item);
52void c_heap_mark_item(CHeapItem * item);
53+
54+/// Sweep the C heap, finalizing and freeing unused blocks.
29void c_heap_sweep(CHeap * c_heap);
55void c_heap_sweep(CHeap * c_heap);
30−CHeapItem * c_heap_create_item(void * data, CDataFinalizer_t * finalizer);
31
56
32−// this is the function to use in C binding code
57+/// Create a C heap item from its payload and finalizer.
33−CHeapItem * c_heap_allocate(size_t size, CDataFinalizer_t * finalizer);
58+CHeapItem * c_heap_create_item(void * data, CDataFinalizer * finalizer);
34−void c_heap_free(CHeapItem * item);
35
59
36/* *** Idris heap **
60/* *** Idris heap **
37 * Objects without finalizers. Cheney-collected.
61 * Objects without finalizers. Cheney-collected.
rts/idris_rts.c+4−8
@@ -127,21 +127,17 @@ Stats terminate(VM* vm) {
127 return stats;
127 return stats;
128}
128}
129
129
130−CData cdata_allocate(size_t size, CDataFinalizer_t finalizer)
130+CData cdata_allocate(size_t size, CDataFinalizer finalizer)
131{
131{
132− return c_heap_allocate(size, finalizer);
132+ void * data = (void *) malloc(size);
133+ return cdata_manage(data, finalizer);
133}
134}
134
135
135−CData cdata_manage(void * data, CDataFinalizer_t finalizer)
136+CData cdata_manage(void * data, CDataFinalizer finalizer)
136{
137{
137 return c_heap_create_item(data, finalizer);
138 return c_heap_create_item(data, finalizer);
138}
139}
139
140
140−void cdata_free(CData cd)
141−{
142− c_heap_free(cd);
143−}
144−
145void idris_requireAlloc(size_t size) {
141void idris_requireAlloc(size_t size) {
146#ifdef HAS_PTHREAD
142#ifdef HAS_PTHREAD
147 VM* vm = pthread_getspecific(vm_key);
143 VM* vm = pthread_getspecific(vm_key);
rts/idris_rts.h+17−11
@@ -119,21 +119,27 @@ typedef struct VM_t VM;
119 *
119 *
120 * Although not enforced in code, CData is meant to be opaque
120 * Although not enforced in code, CData is meant to be opaque
121 * and non-RTS code (such as libraries or C bindings) should
121 * and non-RTS code (such as libraries or C bindings) should
122− * access it only in the following three ways:
122+ * access only its (void *) field called "data".
123 *
123 *
124− * CData cd = cdata_allocate(...);
124+ * Feel free to mutate cd->data; the heap does not care
125− * or
125+ * about its particular value. However, keep in mind
126− * void * ptr = malloc(...);
126+ * that it must not break Idris's referential transparency.
127− * CData cd = cdata_manage(ptr, ...);
128− *
129− * use(cd->data);
130− * cdata_free(cd); // optionally
131 *
127 *
128+ * If you call cdata_allocate or cdata_manage, the resulting
129+ * CData object *must* be returned from your FFI function so
130+ * that it is inserted in the C heap. Otherwise the memory
131+ * will be leaked.
132 */
132 */
133+
134+/// C data block. Contains (void * data).
133typedef CHeapItem * CData;
135typedef CHeapItem * CData;
134−CData cdata_manage(void * data, CDataFinalizer_t * finalizer);
136+
137+/// Allocate memory, returning the corresponding C data block.
135−CData cdata_allocate(size_t size, CDataFinalizer_t * finalizer);
138+CData cdata_allocate(size_t size, CDataFinalizer * finalizer);
136−void cdata_free(CData cd); // explicit freeing not required but available
139+
140+/// Wrap a pointer as a C data block.
141+CData cdata_manage(void * data, CDataFinalizer * finalizer);
142+
137
143
138// Create a new VM
144// Create a new VM
139VM* init_vm(int stack_size, size_t heap_size,
145VM* init_vm(int stack_size, size_t heap_size,