33d367d · Idris-dev · git.iko.soy

git.iko.soy/Idris-dev

Merge pull request #4429 from jacereda/master-unboxed-bits8-bits16

Unboxed Bits8/Bits16 using Int as the underlying representation

commit33d367de25645ae87357cd712d3be363477c0437 authorNiklas Larsson <metaniklas@gmail.com> dateSat 28 Apr 2018, 11:35 (8 years ago) parent48e5806 699090e

5 files changed+45−73

compare with master

unifiedsplit

rts/idris_bitstring.c+2−8 rts/idris_gc.c+15−9 rts/idris_gmp.c+10−10 rts/idris_rts.c+12−24 rts/idris_rts.h+6−22

rts/idris_bitstring.c+2−8

@@ -3,17 +3,11 @@

33#include "idris_rts.h"

55VAL idris_b8const(VM *vm, uint8_t a) {

6− Bits8 * cl = iallocate(vm, sizeof(*cl), 0);

7− SETTY(cl, CT_BITS8);

8− cl->bits8 = a;

9− return (VAL)cl;

6+ return MKINT(a);

107}

118

129VAL idris_b16const(VM *vm, uint16_t a) {

13− Bits16 * cl = iallocate(vm, sizeof(*cl), 0);

14− SETTY(cl, CT_BITS16);

15− cl->bits16 = a;

16− return (VAL)cl;

10+ return MKINT(a);

1711}

1812

1913VAL idris_b32const(VM *vm, uint32_t a) {

rts/idris_gc.c+15−9

@@ -4,17 +4,27 @@

44#include "idris_bitstring.h"

55#include <assert.h>

7+static inline VAL copy_plain(VM* vm, VAL x, size_t sz) {

8+ VAL cl = iallocate(vm, sz, 1);

9+ memcpy(cl, x, sz);

10+ return cl;

11+}

12+

713VAL copy(VM* vm, VAL x) {

814 int ar;

915 VAL cl;

10− if (x==NULL || ISINT(x)) {

16+ if (x==NULL) {

1117 return x;

1218 }

1319 switch(GETTY(x)) {

20+ case CT_INT: return x;

21+ case CT_BITS32: return copy_plain(vm, x, sizeof(Bits32));

22+ case CT_BITS64: return copy_plain(vm, x, sizeof(Bits64));

23+ case CT_FLOAT: return copy_plain(vm, x, sizeof(Float));

1424 case CT_FWD:

1525 return GETPTR(x);

1626 case CT_CDATA:

17− cl = MKCDATAc(vm, GETCDATA(x));

27+ cl = copy_plain(vm, x, sizeof(CDataC));

1828 c_heap_mark_item(GETCDATA(x));

1929 break;

2030 case CT_BIGINT:

@@ -29,22 +39,18 @@ VAL copy(VM* vm, VAL x) {

2939 case CT_ARRAY:

3040 case CT_STRING:

3141 case CT_REF:

32− case CT_FLOAT:

3342 case CT_STROFFSET:

3443 case CT_PTR:

3544 case CT_MANAGEDPTR:

36− case CT_BITS8:

37− case CT_BITS16:

38− case CT_BITS32:

39− case CT_BITS64:

4045 case CT_RAWDATA:

41− cl = iallocate(vm, x->hdr.sz, 1);

42− memcpy(cl, x, x->hdr.sz);

46+ cl = copy_plain(vm, x, x->hdr.sz);

4347 break;

4448 default:

4549 cl = NULL;

50+ assert(0);

4651 break;

4752 }

53+ assert(x->hdr.sz >= sizeof(Fwd));

4854 SETTY(x, CT_FWD);

4955 ((Fwd*)x)->fwd = cl;

5056 return cl;

rts/idris_gmp.c+10−10

@@ -67,17 +67,17 @@ VAL MKBIGSI(VM* vm, signed long val) {

6767}

6868

6969static BigInt * getbig(VM * vm, VAL x) {

70− if (ISINT(x)) {

71− BigInt * cl = allocBig(vm);

72− mpz_set_si(*getmpz(cl), GETINT(x));

73− return cl;

74− } else {

75− switch(GETTY(x)) {

76− case CT_FWD:

77− return getbig(vm, ((Fwd*)x)->fwd);

78− default:

79− return (BigInt*)x;

70+ switch(GETTY(x)) {

71+ case CT_INT:

72+ {

73+ BigInt * cl = allocBig(vm);

74+ mpz_set_si(*getmpz(cl), GETINT(x));

75+ return cl;

8076 }

77+ case CT_FWD:

78+ return getbig(vm, ((Fwd*)x)->fwd);

79+ default:

80+ return (BigInt*)x;

8181 }

8282}

8383

rts/idris_rts.c+12−24

@@ -209,7 +209,7 @@ void * allocate(size_t sz, int lock) {

209209}

210210

211211void* iallocate(VM * vm, size_t isize, int outerlock) {

212−// return malloc(size);

212+// return malloc(isize);

213213 size_t size = aligned(isize);

214214

215215#ifdef HAS_PTHREAD

@@ -364,17 +364,11 @@ VAL MKMPTRc(VM* vm, void* ptr, size_t size) {

364364}

365365

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

367− Bits8 * cl = iallocate(vm, sizeof(*cl), 1);

368− SETTY(cl, CT_BITS8);

369− cl->bits8 = bits8;

370− return (VAL)cl;

367+ return MKINT(bits8);

371368}

372369

373370VAL MKB16(VM* vm, uint16_t bits16) {

374− Bits16 * cl = iallocate(vm, sizeof(*cl), 1);

375− SETTY(cl, CT_BITS16);

376− cl->bits16 = bits16;

377− return (VAL)cl;

371+ return MKINT(bits16);

378372}

379373

380374VAL MKB32(VM* vm, uint32_t bits32) {

@@ -417,11 +411,10 @@ void dumpStack(VM* vm) {

417411void dumpVal(VAL v) {

418412 if (v==NULL) return;

419413 int i;

420− if (ISINT(v)) {

421− printf("%d ", (int)(GETINT(v)));

422− return;

423− }

424414 switch(GETTY(v)) {

415+ case CT_INT:

416+ printf("%" PRIdPTR " ", GETINT(v));

417+ break;

425418 case CT_CON:

426419 {

427420 Con * cl = (Con*)v;

@@ -517,15 +510,10 @@ VAL idris_castBitsStr(VM* vm, VAL i) {

517510 ClosureType ty = GETTY(i);

518511

519512 switch (ty) {

520− case CT_BITS8:

521− // max length 8 bit unsigned int str 3 chars (256)

522− cl = allocStr(vm, 4, 0);

523− cl->slen = sprintf(cl->str, "%" PRIu8, GETBITS8(i));

524− break;

525− case CT_BITS16:

513+ case CT_INT: // 8/16 bits

526514 // max length 16 bit unsigned int str 5 chars (65,535)

527515 cl = allocStr(vm, 6, 0);

528− cl->slen = sprintf(cl->str, "%" PRIu16, GETBITS16(i));

516+ cl->slen = sprintf(cl->str, "%" PRIu16, (uint16_t)GETBITS16(i));

529517 break;

530518 case CT_BITS32:

531519 // max length 32 bit unsigned int str 10 chars (4,294,967,295)

@@ -859,10 +847,12 @@ static void copyArray(VM* vm, VAL * dst, VAL * src, size_t len) {

859847static VAL doCopyTo(VM* vm, VAL x) {

860848 int ar;

861849 VAL cl;

862− if (x==NULL || ISINT(x)) {

850+ if (x==NULL) {

863851 return x;

864852 }

865853 switch(GETTY(x)) {

854+ case CT_INT:

855+ return x;

866856 case CT_CDATA:

867857 cl = MKCDATAc(vm, GETCDATA(x));

868858 break;

@@ -889,8 +879,6 @@ static VAL doCopyTo(VM* vm, VAL x) {

889879 case CT_FLOAT:

890880 case CT_PTR:

891881 case CT_MANAGEDPTR:

892− case CT_BITS8:

893− case CT_BITS16:

894882 case CT_BITS32:

895883 case CT_BITS64:

896884 case CT_RAWDATA:

@@ -901,6 +889,7 @@ static VAL doCopyTo(VM* vm, VAL x) {

901889 break;

902890 default:

903891 assert(0); // We're in trouble if this happens...

892+ cl = NULL;

904893 }

905894 return cl;

906895}

@@ -1091,7 +1080,6 @@ Msg* idris_recvMessageFrom(VM* vm, int channel_id, VM* sender) {

10911080 fprintf(stderr, "No messages waiting");

10921081 exit(-1);

10931082 }

1094−

10951083 return ret;

10961084}

10971085#endif

rts/idris_rts.h+6−22

@@ -24,10 +24,9 @@

2424// Closures

2525typedef enum {

2626 CT_CON, CT_ARRAY, CT_INT, CT_BIGINT,

27− CT_FLOAT, CT_STRING, CT_STROFFSET, CT_BITS8,

28− CT_BITS16, CT_BITS32, CT_BITS64, CT_PTR,

29− CT_REF, CT_FWD, CT_MANAGEDPTR, CT_RAWDATA,

30− CT_CDATA

27+ CT_FLOAT, CT_STRING, CT_STROFFSET, CT_BITS32,

28+ CT_BITS64, CT_PTR, CT_REF, CT_FWD,

29+ CT_MANAGEDPTR, CT_RAWDATA, CT_CDATA

3130} ClosureType;

3231

3332typedef struct Hdr {

@@ -54,11 +53,6 @@ typedef struct Array {

5453 VAL array[0];

5554} Array;

5655

57−typedef struct Int {

58− Hdr hdr;

59− int i;

60−} Int;

61−

6256typedef struct BigInt {

6357 Hdr hdr;

6458 char big[0];

@@ -81,16 +75,6 @@ typedef struct StrOffset {

8175 size_t offset;

8276} StrOffset;

8377

84−typedef struct Bits8 {

85− Hdr hdr;

86− uint8_t bits8;

87−} Bits8;

88−

89−typedef struct Bits16 {

90− Hdr hdr;

91− uint16_t bits16;

92−} Bits16;

93−

9478typedef struct Bits32 {

9579 Hdr hdr;

9680 uint32_t bits32;

@@ -254,8 +238,8 @@ static inline size_t getstrlen(String * x) {

254238#define GETFLOAT(x) (((Float*)(x))->f)

255239#define GETCDATA(x) (((CDataC*)(x))->item)

256240

257−#define GETBITS8(x) (((Bits8*)(x))->bits8)

258−#define GETBITS16(x) (((Bits16*)(x))->bits16)

241+#define GETBITS8(x) (GETINT(x))

242+#define GETBITS16(x) (GETINT(x))

259243#define GETBITS32(x) (((Bits32*)(x))->bits32)

260244#define GETBITS64(x) (((Bits64*)(x))->bits64)

261245

@@ -268,7 +252,7 @@ static inline size_t getstrlen(String * x) {

268252

269253#define CELEM(x) (((x)->hdr.sz - sizeof(Array)) / sizeof(VAL))

270254

271−#define GETTY(x) ((ClosureType)((x)->hdr.ty))

255+#define GETTY(x) (ISINT(x)? CT_INT : (ClosureType)((x)->hdr.ty))

272256#define SETTY(x,t) ((x)->hdr.ty = t)

273257

274258// Integers, floats and operators