e5b50de · Idris-dev · git.iko.soy

rts/idris_gc.c+3−14

compare with master

unifiedsplit

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

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

113 free(vm->heap.old);

114

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

115+ /* Allocate swap heap. */

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

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

117−

118− vm->heap.heap = newheap;

119−#ifdef FORCE_ALIGNMENT

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

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

122− } else

123−#endif

124− {

125− vm->heap.next = newheap;

126− }

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

128

117

129 VAL* root;

118 VAL* root;

130

119

@@ -139,6 +128,7 @@ void idris_gc(VM* vm) {

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

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

140 }

129 }

141#endif

130#endif

131+

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

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

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

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

144

134

@@ -150,7 +140,6 @@ void idris_gc(VM* vm) {

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

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

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

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

152 }

142 }

153− vm->heap.old = oldheap;

154

143

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

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

156 HEAP_CHECK(vm)

145 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;