195 lines
2.9 KiB
CoffeeScript
195 lines
2.9 KiB
CoffeeScript
|
|
|
|
###
|
|
// up to 100 blocks of 100,000 atoms
|
|
|
|
#define M 100
|
|
#define N 100000
|
|
|
|
U *mem[M]
|
|
int mcount
|
|
|
|
U *free_list
|
|
int free_count
|
|
|
|
U *
|
|
alloc(void)
|
|
{
|
|
U *p
|
|
if (free_count == 0) {
|
|
if (mcount == 0)
|
|
alloc_mem()
|
|
else {
|
|
gc()
|
|
if (free_count < N * mcount / 2)
|
|
alloc_mem()
|
|
}
|
|
if (free_count == 0)
|
|
stop("atom space exhausted")
|
|
}
|
|
p = free_list
|
|
free_list = free_list->u.cons.cdr
|
|
free_count--
|
|
return p
|
|
}
|
|
###
|
|
|
|
allocatedId = 0
|
|
alloc_tensor = (nelem) ->
|
|
i = 0
|
|
p = new U()
|
|
p.k = TENSOR
|
|
p.tensor = new tensor()
|
|
|
|
p.tensor.nelem = nelem
|
|
for i in [0...nelem]
|
|
p.tensor.elem[i] = zero
|
|
|
|
p.tensor.allocatedId = allocatedId
|
|
#if allocatedId == 9
|
|
# debugger
|
|
allocatedId++
|
|
|
|
check_tensor_dimensions p
|
|
|
|
return p
|
|
|
|
###
|
|
// garbage collector
|
|
|
|
void
|
|
gc(void)
|
|
{
|
|
int i, j
|
|
U *p
|
|
|
|
// tag everything
|
|
|
|
for (i = 0; i < mcount; i++) {
|
|
p = mem[i]
|
|
for (j = 0; j < N; j++)
|
|
p[j].tag = 1
|
|
}
|
|
|
|
// untag what's used
|
|
|
|
untag(p0)
|
|
untag(p1)
|
|
untag(p2)
|
|
untag(p3)
|
|
untag(p4)
|
|
untag(p5)
|
|
untag(p6)
|
|
untag(p7)
|
|
untag(p8)
|
|
untag(p9)
|
|
|
|
untag(one)
|
|
untag(zero)
|
|
untag(imaginaryunit)
|
|
|
|
for (i = 0; i < NSYM; i++) {
|
|
untag(binding[i])
|
|
untag(arglist[i])
|
|
}
|
|
|
|
for (i = 0; i < tos; i++)
|
|
untag(stack[i])
|
|
|
|
for (i = (int) (frame - stack); i < TOS; i++)
|
|
untag(stack[i])
|
|
|
|
// collect everything that's still tagged
|
|
|
|
free_count = 0
|
|
|
|
for (i = 0; i < mcount; i++) {
|
|
p = mem[i]
|
|
for (j = 0; j < N; j++) {
|
|
if (p[j].tag == 0)
|
|
continue
|
|
// still tagged so it's unused, put on free list
|
|
switch (p[j].k) {
|
|
case TENSOR:
|
|
free(p[j].u.tensor)
|
|
break
|
|
case STR:
|
|
free(p[j].u.str)
|
|
break
|
|
case NUM:
|
|
mfree(p[j].u.q.a)
|
|
mfree(p[j].u.q.b)
|
|
break
|
|
}
|
|
p[j].k = CONS; // so no double free occurs above
|
|
p[j].u.cons.cdr = free_list
|
|
free_list = p + j
|
|
free_count++
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
untag(U *p)
|
|
{
|
|
int i
|
|
|
|
if (iscons(p)) {
|
|
do {
|
|
if (p->tag == 0)
|
|
return
|
|
p->tag = 0
|
|
untag(p->u.cons.car)
|
|
p = p->u.cons.cdr
|
|
} while (iscons(p))
|
|
untag(p)
|
|
return
|
|
}
|
|
|
|
if (p->tag) {
|
|
p->tag = 0
|
|
if (istensor(p)) {
|
|
for (i = 0; i < p->u.tensor->nelem; i++)
|
|
untag(p->u.tensor->elem[i])
|
|
}
|
|
}
|
|
}
|
|
|
|
// get memory for 100,000 atoms
|
|
|
|
void
|
|
alloc_mem(void)
|
|
{
|
|
int i
|
|
U *p
|
|
if (mcount == M)
|
|
return
|
|
p = (U *) malloc(N * sizeof (struct U))
|
|
if (p == NULL)
|
|
return
|
|
mem[mcount++] = p
|
|
for (i = 0; i < N; i++) {
|
|
p[i].k = CONS; // so no free in gc
|
|
p[i].u.cons.cdr = p + i + 1
|
|
}
|
|
p[N - 1].u.cons.cdr = free_list
|
|
free_list = p
|
|
free_count += N
|
|
}
|
|
|
|
void
|
|
print_mem_info(void)
|
|
{
|
|
char buf[100]
|
|
|
|
sprintf(buf, "%d blocks (%d bytes/block)\n", N * mcount, (int) sizeof (U))
|
|
printstr(buf)
|
|
|
|
sprintf(buf, "%d free\n", free_count)
|
|
printstr(buf)
|
|
|
|
sprintf(buf, "%d used\n", N * mcount - free_count)
|
|
printstr(buf)
|
|
}
|
|
###
|