3be07b0 · Idris-dev · git.iko.soy

git.iko.soy/Idris-dev

on master help sign in

Avoid indirections for nullaries, refactorized locked/unlocked variants

3be07b0Jorge Acereda9 years ago

rts/idris_main.c+1−2

compare with master

unifiedsplit

@@ -33,7 +33,7 @@ int win32_get_argv_utf8(int *argc_ptr, char ***argv_ptr)

33#endif

35// The default options should give satisfactory results under many circumstances.

36−RTSOpts opts = {

36+RTSOpts opts = {

37 .init_heap_size = 16384000,

38 .max_stack_size = 4096000,

39 .show_summary = 0

@@ -74,6 +74,5 @@ int main(int argc, char **argv) {

74 print_stats(&stats);

75 }

77− free_nullaries();

78 return EXIT_SUCCESS;

77 return EXIT_SUCCESS;

79}

78}

rts/idris_rts.c+51−56

@@ -223,16 +223,15 @@ void* iallocate(VM * vm, size_t isize, int outerlock) {

223 STATS_ALLOC(vm->stats, size)

224 char* ptr = vm->heap.next;

225 vm->heap.next += size;

226−

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

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

228−

229 memset(ptr, 0, size);

227 memset(ptr, 0, size);

228+ ((Hdr*)ptr)->sz = isize;

229+

230#ifdef HAS_PTHREAD

231 if (lock) { // not message passing

232 pthread_mutex_unlock(&vm->alloc_lock);

233 }

234#endif

235− ((Hdr*)ptr)->sz = size;

236 return (void*)ptr;

235 return (void*)ptr;

237 } else {

236 } else {

238 // If we're trying to allocate something bigger than the heap,

237 // If we're trying to allocate something bigger than the heap,

@@ -258,22 +257,42 @@ static String * allocStr(VM * vm, size_t len, int outer) {

258 return cl;

257 return cl;

259}

258}

260

259

261−VAL MKFLOAT(VM* vm, double val) {

260+static VAL mkfloat(VM* vm, double val, int outer) {

262− Float * cl = iallocate(vm, sizeof(*cl), 0);

261+ Float * cl = iallocate(vm, sizeof(*cl), outer);

263 SETTY(cl, CT_FLOAT);

262 SETTY(cl, CT_FLOAT);

264 cl->f = val;

263 cl->f = val;

265 return (VAL)cl;

264 return (VAL)cl;

266}

265}

267

266

267+VAL MKFLOAT(VM* vm, double val) {

268+ return mkfloat(vm, val, 0);

269+}

270+

271+VAL MKFLOATc(VM* vm, double val) {

272+ return mkfloat(vm, val, 1);

273+}

274+

268−VAL MKSTRlen(VM* vm, const char * str, size_t len) {

275+static VAL mkstrlen(VM* vm, const char * str, size_t len, int outer) {

269− String * cl = allocStr(vm, len, 0);

276+ String * cl = allocStr(vm, len, outer);

270 memcpy(cl->str, str, len);

277 memcpy(cl->str, str, len);

271− cl->__null = str == NULL;

278+ cl->_null = str == NULL;

272 return (VAL)cl;

279 return (VAL)cl;

273}

280}

274

281

282+VAL MKSTRlen(VM* vm, const char * str, size_t len) {

283+ return mkstrlen(vm, str, len, 0);

284+}

285+

286+VAL MKSTRclen(VM* vm, char* str, size_t len) {

287+ return mkstrlen(vm, str, len, 1);

288+}

289+

275VAL MKSTR(VM* vm, const char* str) {

290VAL MKSTR(VM* vm, const char* str) {

276− return MKSTRlen(vm, str, str? strlen(str) : 0);

291+ return mkstrlen(vm, str, str? strlen(str) : 0, 0);

292+}

293+

294+VAL MKSTRc(VM* vm, char* str) {

295+ return mkstrlen(vm, str, strlen(str), 1);

277}

296}

278

297

279static char * getstroff(StrOffset * stroff) {

298static char * getstroff(StrOffset * stroff) {

@@ -295,65 +314,50 @@ size_t GETSTROFFLEN(VAL stroff) {

295 return getstrofflen((StrOffset*)stroff);

314 return getstrofflen((StrOffset*)stroff);

296}

315}

297

316

298−VAL MKCDATA(VM* vm, CHeapItem * item) {

317+static VAL mkcdata(VM * vm, CHeapItem * item, int outer) {

299 c_heap_insert_if_needed(vm, &vm->c_heap, item);

318 c_heap_insert_if_needed(vm, &vm->c_heap, item);

300− CDataC * cl = iallocate(vm, sizeof(*cl), 0);

319+ CDataC * cl = iallocate(vm, sizeof(*cl), outer);

301 SETTY(cl, CT_CDATA);

320 SETTY(cl, CT_CDATA);

302 cl->item = item;

321 cl->item = item;

303 return (VAL)cl;

322 return (VAL)cl;

304}

323}

305

324

325+VAL MKCDATA(VM* vm, CHeapItem * item) {

326+ return mkcdata(vm, item, 0);

327+}

328+

306VAL MKCDATAc(VM* vm, CHeapItem * item) {

329VAL MKCDATAc(VM* vm, CHeapItem * item) {

307− c_heap_insert_if_needed(vm, &vm->c_heap, item);

330+ return mkcdata(vm, item, 1);

308− CDataC * cl = iallocate(vm, sizeof(*cl), 1);

309− SETTY(cl, CT_CDATA);

310− cl->item = item;

311− return (VAL)cl;

312}

331}

313

332

314−VAL MKPTR(VM* vm, void* ptr) {

333+static VAL mkptr(VM* vm, void* ptr, int outer) {

315− Ptr * cl = iallocate(vm, sizeof(*cl), 0);

334+ Ptr * cl = iallocate(vm, sizeof(*cl), outer);

316 SETTY(cl, CT_PTR);

335 SETTY(cl, CT_PTR);

317 cl->ptr = ptr;

336 cl->ptr = ptr;

318 return (VAL)cl;

337 return (VAL)cl;

319}

338}

320

339

321−VAL MKMPTR(VM* vm, void* ptr, size_t size) {

340+VAL MKPTR(VM* vm, void* ptr) {

322− ManagedPtr * cl = iallocate(vm, sizeof(*cl) + size, 0);

341+ return mkptr(vm, ptr, 0);

323− SETTY(cl, CT_MANAGEDPTR);

324− memcpy(cl->mptr, ptr, size);

325− return (VAL)cl;

326}

342}

327

343

328−VAL MKFLOATc(VM* vm, double val) {

344+VAL MKPTRc(VM* vm, void* ptr) {

329− Float * cl = iallocate(vm, sizeof(*cl), 1);

345+ return mkptr(vm, ptr, 1);

330− SETTY(cl, CT_FLOAT);

331− cl->f = val;

332− return (VAL)cl;

333}

346}

334

347

335−VAL MKSTRclen(VM* vm, char* str, size_t len) {

348+VAL mkmptr(VM* vm, void* ptr, size_t size, int outer) {

336− String * cl = allocStr(vm, len, 1);

349+ ManagedPtr * cl = iallocate(vm, sizeof(*cl) + size, outer);

350+ SETTY(cl, CT_MANAGEDPTR);

337− memcpy(cl->str, str, len);

351+ memcpy(cl->mptr, ptr, size);

338 return (VAL)cl;

352 return (VAL)cl;

339}

353}

340

354

341−VAL MKSTRc(VM* vm, char* str) {

342− return MKSTRclen(vm, str, strlen(str));

343−}

344−

345−VAL MKPTRc(VM* vm, void* ptr) {

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

346− Ptr * cl = iallocate(vm, sizeof(*cl), 1);

356+ return mkmptr(vm, ptr, size, 0);

347− SETTY(cl, CT_PTR);

348− cl->ptr = ptr;

349− return (VAL)cl;

350}

357}

351

358

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

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

353− ManagedPtr * cl = iallocate(vm, sizeof(*cl) + size, 1);

360+ return mkmptr(vm, ptr, size, 1);

354− SETTY(cl, CT_MANAGEDPTR);

355− memcpy(cl->mptr, ptr, size);

356− return (VAL)cl;

357}

361}

358

362

359VAL MKB8(VM* vm, uint8_t bits8) {

363VAL MKB8(VM* vm, uint8_t bits8) {

@@ -1105,25 +1109,16 @@ char* idris_showerror(int err) {

1105 return strerror(err);

1109 return strerror(err);

1106}

1110}

1107

1111

1108−VAL* nullary_cons;

1112+Con nullary_cons[256];

1109

1113

1110void init_nullaries(void) {

1114void init_nullaries(void) {

1111 int i;

1115 int i;

1112− nullary_cons = malloc(256 * sizeof(VAL));

1113 for(i = 0; i < 256; ++i) {

1116 for(i = 0; i < 256; ++i) {

1117+ Con * cl = nullary_cons + i;

1114− Con * cl = calloc(1, sizeof(*cl));

1118+ cl->hdr.sz = sizeof(*cl);

1115 SETTY(cl, CT_CON);

1119 SETTY(cl, CT_CON);

1116 cl->tag = i;

1120 cl->tag = i;

1117− nullary_cons[i] = (VAL)cl;

1118− }

1119−}

1120−

1121−void free_nullaries(void) {

1122− int i;

1123− for(i = 0; i < 256; ++i) {

1124− free(nullary_cons[i]);

1125 }

1121 }

1126− free(nullary_cons);

1127}

1122}

1128

1123

1129int __idris_argc;

1124int __idris_argc;

rts/idris_rts.h+14−15

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

1#ifndef _IDRISRTS_H

2#define _IDRISRTS_H

4+#include <assert.h>

4#include <stdlib.h>

5#include <stdlib.h>

5#include <stdio.h>

6#include <stdio.h>

6#ifdef HAS_PTHREAD

7#ifdef HAS_PTHREAD

@@ -22,12 +23,13 @@

23// Closures

24// Closures

24typedef enum {

25typedef enum {

25− CT_CON, CT_ARRAY, CT_INT, CT_BIGINT, CT_FLOAT, CT_STRING, CT_STROFFSET,

26+ CT_CON, CT_ARRAY, CT_INT, CT_BIGINT,

27+ CT_FLOAT, CT_STRING, CT_STROFFSET, CT_BITS8,

26− CT_BITS8, CT_BITS16, CT_BITS32, CT_BITS64, CT_PTR, CT_REF,

28+ CT_BITS16, CT_BITS32, CT_BITS64, CT_PTR,

27− CT_FWD, CT_MANAGEDPTR, CT_RAWDATA, CT_CDATA

29+ CT_REF, CT_FWD, CT_MANAGEDPTR, CT_RAWDATA,

30+ CT_CDATA

28} ClosureType;

31} ClosureType;

30−

31typedef struct Hdr {

33typedef struct Hdr {

32 uint8_t ty;

34 uint8_t ty;

33 uint8_t u8;

35 uint8_t u8;

@@ -35,7 +37,6 @@ typedef struct Hdr {

35 uint32_t sz;

37 uint32_t sz;

36} Hdr;

38} Hdr;

38−

39typedef struct Val {

40typedef struct Val {

40 Hdr hdr;

41 Hdr hdr;

41} Val;

42} Val;

@@ -72,7 +73,7 @@ typedef struct Float {

72typedef struct String {

73typedef struct String {

73 Hdr hdr;

74 Hdr hdr;

74 size_t slen;

75 size_t slen;

75−#define __null hdr.u8

76+#define _null hdr.u8

76 char str[0];

77 char str[0];

77} String;

78} String;

@@ -240,7 +241,7 @@ typedef void(*func)(VM*, VAL*);

240

241

241// Retrieving values

242// Retrieving values

242static inline char * getstr(String * x) {

243static inline char * getstr(String * x) {

243− return x->__null? NULL : x->str;

244+ return x->_null? NULL : x->str;

244}

245}

245

246

246static inline size_t getstrlen(String * x) {

247static inline size_t getstrlen(String * x) {

@@ -369,12 +370,12 @@ static inline void updateConF(Con * cl, unsigned tag, unsigned arity) {

369 SETTY(cl, CT_CON);

370 SETTY(cl, CT_CON);

370 cl->tag = tag;

371 cl->tag = tag;

371 cl->arity = arity;

372 cl->arity = arity;

373+ assert(cl->hdr.sz == sizeof(*cl) + sizeof(VAL) * arity);

372− cl->hdr.sz = sizeof(*cl) + sizeof(VAL) * arity;

374+ // cl->hdr.sz = sizeof(*cl) + sizeof(VAL) * arity;

373}

375}

374

376

375static inline Con * allocConF(VM * vm, unsigned tag, unsigned arity, int outer) {

377static inline Con * allocConF(VM * vm, unsigned tag, unsigned arity, int outer) {

376− size_t sz = sizeof(VAL) * arity;

377− Con * cl = iallocate(vm, sizeof(*cl) + sz, outer);

378+ Con * cl = iallocate(vm, sizeof(*cl) + sizeof(VAL) * arity, outer);

378 SETTY(cl, CT_CON);

379 SETTY(cl, CT_CON);

379 cl->tag = tag;

380 cl->tag = tag;

380 cl->arity = arity;

381 cl->arity = arity;

@@ -382,8 +383,7 @@ static inline Con * allocConF(VM * vm, unsigned tag, unsigned arity, int outer)

382}

383}

383

384

384static inline Array * allocArrayF(VM * vm, size_t len, int outer) {

385static inline Array * allocArrayF(VM * vm, size_t len, int outer) {

385− size_t sz = sizeof(VAL) * len;

386− Array * cl = iallocate(vm, sizeof(*cl) + sz, outer);

386+ Array * cl = iallocate(vm, sizeof(*cl) + sizeof(VAL) * len, outer);

387 SETTY(cl, CT_ARRAY);

388 return cl;

389}

@@ -393,16 +393,15 @@ static inline Array * allocArrayF(VM * vm, size_t len, int outer) {

393

394#define updateCon(cl, old, tag, arity) (cl) = (old); updateConF(cl, tag, arity)

395

396−#define NULL_CON(x) nullary_cons[x]

396+#define NULL_CON(x) ((VAL)(nullary_cons + x))

397

398#define allocArray(cl, vm, len, o) (cl) = (VAL)allocArrayF(vm, len, o)

399

400int idris_errno(void);

401char* idris_showerror(int err);

402

403−extern VAL* nullary_cons;

403+extern Con nullary_cons[];

404void init_nullaries(void);

405−void free_nullaries(void);

406

405

407void init_signals(void);

406void init_signals(void);

408

407