8f9ac37 · Idris-dev · git.iko.soy

rts/idris_gc.c+3−14

compare with master

unifiedsplit

@@ -116,19 +116,8 @@ void idris_gc(VM* vm) {

116 if (vm->heap.old != NULL)

117 free(vm->heap.old);

118

119− char* newheap = malloc(vm->heap.size);

119+ /* Allocate swap heap. */

120− char* oldheap = vm->heap.heap;

120+ alloc_heap(&vm->heap, vm->heap.size, vm->heap.growth, vm->heap.heap);

121−

122− vm->heap.heap = newheap;

123−#ifdef FORCE_ALIGNMENT

124− if (((i_int)(vm->heap.heap)&1) == 1) {

125− vm->heap.next = newheap + 1;

126− } else

127−#endif

128− {

129− vm->heap.next = newheap;

130− }

131− vm->heap.end = newheap + vm->heap.size;

132

121

133 VAL* root;

122 VAL* root;

134

123

@@ -143,6 +132,7 @@ void idris_gc(VM* vm) {

143 msg->msg = copy(vm, msg->msg);

132 msg->msg = copy(vm, msg->msg);

144 }

133 }

145#endif

134#endif

135+

146 vm->ret = copy(vm, vm->ret);

136 vm->ret = copy(vm, vm->ret);

147 vm->reg1 = copy(vm, vm->reg1);

137 vm->reg1 = copy(vm, vm->reg1);

148

138

@@ -154,7 +144,6 @@ void idris_gc(VM* vm) {

154 if ((vm->heap.next - vm->heap.heap) > vm->heap.size >> 1) {

144 if ((vm->heap.next - vm->heap.heap) > vm->heap.size >> 1) {

155 vm->heap.size += vm->heap.growth;

145 vm->heap.size += vm->heap.growth;

156 }

146 }

157− vm->heap.old = oldheap;

158

147

159 STATS_LEAVE_GC(vm->stats, vm->heap.size, vm->heap.next - vm->heap.heap)

148 STATS_LEAVE_GC(vm->stats, vm->heap.size, vm->heap.next - vm->heap.heap)

160 HEAP_CHECK(vm)

149 HEAP_CHECK(vm)

rts/idris_heap.c+6−3

@@ -5,7 +5,9 @@

5#include <stddef.h>

6#include <stdio.h>

7

8+

9+/* Used for initializing the heap. */

8−void alloc_heap(Heap * h, size_t heap_size)

10+void alloc_heap(Heap * h, size_t heap_size, size_t growth, char * old)

9{

11{

10 char * mem = malloc(heap_size);

12 char * mem = malloc(heap_size);

11 if (mem == NULL) {

13 if (mem == NULL) {

@@ -27,9 +29,9 @@ void alloc_heap(Heap * h, size_t heap_size)

27 h->end = h->heap + heap_size;

29 h->end = h->heap + heap_size;

28

30

29 h->size = heap_size;

31 h->size = heap_size;

30− h->growth = heap_size;

32+ h->growth = growth;

31

33

32− h->old = NULL;

34+ h->old = old;

33}

35}

34

36

35void free_heap(Heap * h) {

37void free_heap(Heap * h) {

@@ -40,6 +42,7 @@ void free_heap(Heap * h) {

40 }

42 }

41}

43}

42

44

45+

43// TODO: more testing

46// TODO: more testing

44/******************** Heap testing ********************************************/

47/******************** Heap testing ********************************************/

45void heap_check_underflow(Heap * heap) {

48void heap_check_underflow(Heap * heap) {

rts/idris_heap.h+1−1

@@ -14,7 +14,7 @@ typedef struct {

14} Heap;

15

16

17−void alloc_heap(Heap * heap, size_t heap_size);

17+void alloc_heap(Heap * heap, size_t heap_size, size_t growth, char * old);

18void free_heap(Heap * heap);

19

20

rts/idris_rts.c+1−1

@@ -29,7 +29,7 @@ VM* init_vm(int stack_size, size_t heap_size,

29 vm->valstack_base = valstack;

30 vm->stack_max = valstack + stack_size;

31

32− alloc_heap(&(vm->heap), heap_size);

32+ alloc_heap(&(vm->heap), heap_size, heap_size, NULL);

33

34 vm->ret = NULL;

35 vm->reg1 = NULL;