504038d · Idris-dev · git.iko.soy

git.iko.soy/Idris-dev

on master help sign in

Merge pull request #1300 from stepcut/master

504038dEdwin Brady12 years ago

config.mk+1−2

compare with master

unifiedsplit

@@ -1,6 +1,6 @@

1CC ?=cc

2CABAL :=cabal

3−CFLAGS :=-O2 -Wall $(CFLAGS)

3+CFLAGS :=-O2 -Wall -DHAS_PTHREAD $(CFLAGS)

4#CABALFLAGS :=

5## Disable building of Effects

6#CABALFLAGS :=-f NoEffects

@@ -35,4 +35,3 @@ else

35 SHLIB_SUFFIX :=.so

36endif

37endif

38−

rts/idris_gc.c+11−2

@@ -103,7 +103,14 @@ void idris_gc(VM* vm) {

103 free(vm->heap.old);

104

105 vm->heap.heap = newheap;

106+#ifdef FORCE_ALIGNMENT

107+ if (((i_int)(vm->heap.heap)&1) == 1) {

106− vm->heap.next = newheap;

108+ vm->heap.next = newheap + 1;

109+ } else

110+#endif

111+ {

112+ vm->heap.next = newheap;

113+ }

107 vm->heap.end = newheap + vm->heap.size;

114 vm->heap.end = newheap + vm->heap.size;

108

115

109 VAL* root;

116 VAL* root;

@@ -111,10 +118,12 @@ void idris_gc(VM* vm) {

111 for(root = vm->valstack; root < vm->valstack_top; ++root) {

118 for(root = vm->valstack; root < vm->valstack_top; ++root) {

112 *root = copy(vm, *root);

119 *root = copy(vm, *root);

113 }

120 }

121+

122+#ifdef HAS_PTHREAD

114 for(root = vm->inbox_ptr; root < vm->inbox_write; ++root) {

123 for(root = vm->inbox_ptr; root < vm->inbox_write; ++root) {

115 *root = copy(vm, *root);

124 *root = copy(vm, *root);

116 }

125 }

117−

126+#endif

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

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

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

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

120

129

rts/idris_heap.c+8−1

@@ -16,7 +16,14 @@ void alloc_heap(Heap * h, size_t heap_size)

16 }

18 h->heap = mem;

19+#ifdef FORCE_ALIGNMENT

20+ if (((i_int)(h->heap)&1) == 1) {

19− h->next = h->heap;

21+ h->next = h->heap + 1;

22+ } else

23+#endif

24+ {

25+ h->next = h->heap;

26+ }

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

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

22 h->size = heap_size;

29 h->size = heap_size;

rts/idris_rts.c+23−11

@@ -1,10 +1,11 @@

1#include <stdlib.h>

2#include <stdio.h>

3#include <string.h>

4−#include <unistd.h>

5#include <stdarg.h>

4#include <stdarg.h>

6#include <assert.h>

5#include <assert.h>

6+#ifdef HAS_PTHREAD

7#include <pthread.h>

8+#endif

9#include "idris_rts.h"

10#include "idris_rts.h"

10#include "idris_gc.h"

11#include "idris_gc.h"

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

31 vm->ret = NULL;

32 vm->ret = NULL;

32 vm->reg1 = NULL;

33 vm->reg1 = NULL;

33−

34+#ifdef HAS_PTHREAD

34 vm->inbox = malloc(1024*sizeof(VAL));

35 vm->inbox = malloc(1024*sizeof(VAL));

35 memset(vm->inbox, 0, 1024*sizeof(VAL));

36 memset(vm->inbox, 0, 1024*sizeof(VAL));

36 vm->inbox_end = vm->inbox + 1024;

37 vm->inbox_end = vm->inbox + 1024;

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

54 vm->max_threads = max_threads;

55 vm->max_threads = max_threads;

55 vm->processes = 0;

56 vm->processes = 0;

56−

57+#endif

57 STATS_LEAVE_INIT(vm->stats)

58 STATS_LEAVE_INIT(vm->stats)

58 return vm;

59 return vm;

59}

60}

@@ -61,14 +62,16 @@ VM* init_vm(int stack_size, size_t heap_size,

61Stats terminate(VM* vm) {

62Stats terminate(VM* vm) {

62 Stats stats = vm->stats;

63 Stats stats = vm->stats;

63 STATS_ENTER_EXIT(stats)

64 STATS_ENTER_EXIT(stats)

64−

65+#ifdef HAS_PTHREAD

65 free(vm->inbox);

66 free(vm->inbox);

67+#endif

66 free(vm->valstack);

68 free(vm->valstack);

67 free_heap(&(vm->heap));

69 free_heap(&(vm->heap));

68−

70+#ifdef HAS_PTHREAD

69 pthread_mutex_destroy(&(vm -> inbox_lock));

71 pthread_mutex_destroy(&(vm -> inbox_lock));

70 pthread_mutex_destroy(&(vm -> inbox_block));

72 pthread_mutex_destroy(&(vm -> inbox_block));

71 pthread_cond_destroy(&(vm -> inbox_waiting));

73 pthread_cond_destroy(&(vm -> inbox_waiting));

74+#endif

72 free(vm);

75 free(vm);

74 STATS_LEAVE_EXIT(stats)

77 STATS_LEAVE_EXIT(stats)

@@ -79,18 +82,21 @@ void idris_requireAlloc(VM* vm, size_t size) {

79 if (!(vm->heap.next + size < vm->heap.end)) {

82 if (!(vm->heap.next + size < vm->heap.end)) {

80 idris_gc(vm);

83 idris_gc(vm);

81 }

84 }

82−

85+#ifdef HAS_PTHREAD

83 int lock = vm->processes > 0;

86 int lock = vm->processes > 0;

84 if (lock) { // We only need to lock if we're in concurrent mode

87 if (lock) { // We only need to lock if we're in concurrent mode

85 pthread_mutex_lock(&vm->alloc_lock);

88 pthread_mutex_lock(&vm->alloc_lock);

86 }

89 }

90+#endif

87}

91}

89void idris_doneAlloc(VM* vm) {

93void idris_doneAlloc(VM* vm) {

94+#ifdef HAS_PTHREAD

90 int lock = vm->processes > 0;

95 int lock = vm->processes > 0;

91 if (lock) { // We only need to lock if we're in concurrent mode

96 if (lock) { // We only need to lock if we're in concurrent mode

92 pthread_mutex_unlock(&vm->alloc_lock);

97 pthread_mutex_unlock(&vm->alloc_lock);

93 }

98 }

99+#endif

94}

100}

101

96int space(VM* vm, size_t size) {

102int space(VM* vm, size_t size) {

@@ -99,16 +105,18 @@ int space(VM* vm, size_t size) {

105

100void* allocate(VM* vm, size_t size, int outerlock) {

106void* allocate(VM* vm, size_t size, int outerlock) {

101// return malloc(size);

107// return malloc(size);

108+#ifdef HAS_PTHREAD

102 int lock = vm->processes > 0 && !outerlock;

109 int lock = vm->processes > 0 && !outerlock;

103

110

104 if (lock) { // not message passing

111 if (lock) { // not message passing

105 pthread_mutex_lock(&vm->alloc_lock);

112 pthread_mutex_lock(&vm->alloc_lock);

106 }

113 }

114+#endif

107

115

108 if ((size & 7)!=0) {

116 if ((size & 7)!=0) {

109 size = 8 + ((size >> 3) << 3);

117 size = 8 + ((size >> 3) << 3);

110 }

118 }

111−

119+

112 size_t chunk_size = size + sizeof(size_t);

120 size_t chunk_size = size + sizeof(size_t);

113

121

114 if (vm->heap.next + chunk_size < vm->heap.end) {

122 if (vm->heap.next + chunk_size < vm->heap.end) {

@@ -120,16 +128,19 @@ void* allocate(VM* vm, size_t size, int outerlock) {

120 assert(vm->heap.next <= vm->heap.end);

128 assert(vm->heap.next <= vm->heap.end);

121

129

122 memset(ptr, 0, size);

130 memset(ptr, 0, size);

123−

131+#ifdef HAS_PTHREAD

124 if (lock) { // not message passing

132 if (lock) { // not message passing

125 pthread_mutex_unlock(&vm->alloc_lock);

133 pthread_mutex_unlock(&vm->alloc_lock);

126 }

134 }

135+#endif

127 return ptr;

136 return ptr;

128 } else {

137 } else {

129 idris_gc(vm);

138 idris_gc(vm);

139+#ifdef HAS_PTHREAD

130 if (lock) { // not message passing

140 if (lock) { // not message passing

131 pthread_mutex_unlock(&vm->alloc_lock);

141 pthread_mutex_unlock(&vm->alloc_lock);

132 }

142 }

143+#endif

133 return allocate(vm, size, 0);

144 return allocate(vm, size, 0);

134 }

145 }

135

146

@@ -187,7 +198,7 @@ VAL MKPTR(VM* vm, void* ptr) {

187 return cl;

198 return cl;

188}

199}

189

200

190−VAL MKMPTR(VM* vm, void* ptr, int size) {

201+VAL MKMPTR(VM* vm, void* ptr, size_t size) {

191 Closure* cl = allocate(vm, sizeof(Closure) +

202 Closure* cl = allocate(vm, sizeof(Closure) +

192 sizeof(ManagedPtr) + size, 0);

203 sizeof(ManagedPtr) + size, 0);

193 SETTY(cl, MANAGEDPTR);

204 SETTY(cl, MANAGEDPTR);

@@ -222,7 +233,7 @@ VAL MKPTRc(VM* vm, void* ptr) {

222 return cl;

233 return cl;

223}

234}

224

235

225−VAL MKMPTRc(VM* vm, void* ptr, int size) {

236+VAL MKMPTRc(VM* vm, void* ptr, size_t size) {

226 Closure* cl = allocate(vm, sizeof(Closure) +

237 Closure* cl = allocate(vm, sizeof(Closure) +

227 sizeof(ManagedPtr) + size, 1);

238 sizeof(ManagedPtr) + size, 1);

228 SETTY(cl, MANAGEDPTR);

239 SETTY(cl, MANAGEDPTR);

@@ -760,6 +771,7 @@ typedef struct {

760 VAL arg;

771 VAL arg;

761} ThreadData;

772} ThreadData;

762

773

774+#ifdef HAS_PTHREAD

763void* runThread(void* arg) {

775void* runThread(void* arg) {

764 ThreadData* td = (ThreadData*)arg;

776 ThreadData* td = (ThreadData*)arg;

765 VM* vm = td->vm;

777 VM* vm = td->vm;

@@ -949,7 +961,7 @@ VAL idris_recvMessage(VM* vm) {

949

961

950 return msg;

962 return msg;

951}

963}

952−

964+#endif

953int __idris_argc;

965int __idris_argc;

954char **__idris_argv;

966char **__idris_argv;

955

967

rts/idris_rts.h+13−9

@@ -4,9 +4,10 @@

4#include <stdlib.h>

5#include <stdio.h>

6#include <string.h>

7−#include <unistd.h>

8#include <stdarg.h>

7#include <stdarg.h>

8+#ifdef HAS_PTHREAD

9#include <pthread.h>

10+#endif

10#include <stdint.h>

11#include <stdint.h>

12#include "idris_heap.h"

13#include "idris_heap.h"

@@ -23,13 +24,13 @@ typedef enum {

23typedef struct Closure *VAL;

24typedef struct Closure *VAL;

25typedef struct {

26typedef struct {

26− int tag_arity;

27+ uint32_t tag_arity;

27 VAL args[];

28 VAL args[];

28} con;

29} con;

30typedef struct {

31typedef struct {

31 VAL str;

32 VAL str;

32− int offset;

33+ size_t offset;

33} StrOffset;

34} StrOffset;

35typedef struct {

36typedef struct {

@@ -49,7 +50,10 @@ typedef struct {

49typedef struct Closure {

50typedef struct Closure {

50// Use top 16 bits of ty for saying which heap value is in

51// Use top 16 bits of ty for saying which heap value is in

51// Bottom 16 bits for closure type

52// Bottom 16 bits for closure type

52− ClosureType ty;

53+//

54+// NOTE: ty can not have type ClosureType because ty must be a

55+// uint32_t but enum is platform dependent

56+ uint32_t ty;

53 union {

57 union {

54 con c;

58 con c;

55 int i;

59 int i;

@@ -73,7 +77,7 @@ typedef struct {

73 VAL* stack_max;

77 VAL* stack_max;

75 Heap heap;

79 Heap heap;

76−

80+#ifdef HAS_PTHREAD

77 pthread_mutex_t inbox_lock;

81 pthread_mutex_t inbox_lock;

78 pthread_mutex_t inbox_block;

82 pthread_mutex_t inbox_block;

79 pthread_mutex_t alloc_lock;

83 pthread_mutex_t alloc_lock;

@@ -87,7 +91,7 @@ typedef struct {

88 int processes; // Number of child processes

92 int processes; // Number of child processes

89 int max_threads; // maximum number of threads to run in parallel

93 int max_threads; // maximum number of threads to run in parallel

90−

94+#endif

91 Stats stats;

95 Stats stats;

93 VAL ret;

97 VAL ret;

@@ -170,7 +174,7 @@ typedef intptr_t i_int;

170VAL MKFLOAT(VM* vm, double val);

174VAL MKFLOAT(VM* vm, double val);

171VAL MKSTR(VM* vm, const char* str);

175VAL MKSTR(VM* vm, const char* str);

172VAL MKPTR(VM* vm, void* ptr);

176VAL MKPTR(VM* vm, void* ptr);

173−VAL MKMPTR(VM* vm, void* ptr, int size);

177+VAL MKMPTR(VM* vm, void* ptr, size_t size);

174VAL MKB8(VM* vm, uint8_t b);

178VAL MKB8(VM* vm, uint8_t b);

175VAL MKB16(VM* vm, uint16_t b);

179VAL MKB16(VM* vm, uint16_t b);

176VAL MKB32(VM* vm, uint32_t b);

180VAL MKB32(VM* vm, uint32_t b);

@@ -181,7 +185,7 @@ VAL MKFLOATc(VM* vm, double val);

181VAL MKSTROFFc(VM* vm, StrOffset* off);

185VAL MKSTROFFc(VM* vm, StrOffset* off);

182VAL MKSTRc(VM* vm, char* str);

186VAL MKSTRc(VM* vm, char* str);

183VAL MKPTRc(VM* vm, void* ptr);

187VAL MKPTRc(VM* vm, void* ptr);

184−VAL MKMPTRc(VM* vm, void* ptr, int size);

188+VAL MKMPTRc(VM* vm, void* ptr, size_t size);

185VAL MKBUFFERc(VM* vm, Buffer* buf);

189VAL MKBUFFERc(VM* vm, Buffer* buf);

186

190

187char* GETSTROFF(VAL stroff);

191char* GETSTROFF(VAL stroff);

@@ -208,7 +212,7 @@ void idris_doneAlloc(VM* vm);

208#define allocCon(cl, vm, t, a, o) \

212#define allocCon(cl, vm, t, a, o) \

209 cl = allocate(vm, sizeof(Closure) + sizeof(VAL)*a, o); \

213 cl = allocate(vm, sizeof(Closure) + sizeof(VAL)*a, o); \

210 SETTY(cl, CON); \

214 SETTY(cl, CON); \

211− cl->info.c.tag_arity = ((t) << 8) + (a);

215+ cl->info.c.tag_arity = ((t) << 8) | (a);

212

216

213void* vmThread(VM* callvm, func f, VAL arg);

217void* vmThread(VM* callvm, func f, VAL arg);

214

218