#include "lib9.h"#include "dat.h"#include "fns.h"#include "interp.h"#include "audit.h"#include "pool.h" enum{	MAXPOOL		= 4}; #define left	u.s.bhl#define right	u.s.bhr#define fwd	u.s.bhf#define prev	u.s.bhv#define parent	u.s.bhp struct Pool{	char*	name;	int	pnum;	ulong	maxsize;	int	quanta;	int	chunk;	ulong	cursize;	ulong	arenasize;	ulong	hw;	Lock	l;	Bhdr*	root;	Bhdr*	chain;	int	nalloc;	int	nfree;	int	nbrk;	int	lastfree;	void	(*move)(void*, void*);}; void*	initbrk(ulong); struct{	int	n;	Pool	pool[MAXPOOL];	/* Lock l; */} table = {	3,	{		{ "main",  0, 	32*1024*1024, 31,  512*1024 },		{ "heap",  1, 	32*1024*1024, 31,  512*1024 },		{ "image", 2,   32*1024*1024+256, 31, 4*1024*1024 },	}}; Pool*	mainmem = &table.pool[0];Pool*	heapmem = &table.pool[1];Pool*	imagmem = &table.pool[2]; static void _auditmemloc(char *, void *);void (*auditmemloc)(char *, void *) = _auditmemloc;static void _poolfault(void *, char *, ulong);void (*poolfault)(void *, char *, ulong) = _poolfault; int	poolcompact(Pool*); intmemlow(void){	return heapmem->cursize > (heapmem->maxsize)/2;} /*intmemused(){	return heapmem->cursize/(heapmem->maxsize/(1024*1024));}*/	intpoolsetsize(char *s, int size){	int i; 	for(i = 0; i < table.n; i++) {		if(strcmp(table.pool[i].name, s) == 0) {			table.pool[i].maxsize = size;			return 1;		}	}	return 0;} voidpoolimmutable(void *v){	Bhdr *b; 	D2B(b, v);	b->magic = MAGIC_I;} voidpoolmutable(void *v){	Bhdr *b; 	D2B(b, v);	b->magic = MAGIC_A;} Bhdr*poolchain(Pool *p){	return p->chain;} voidpooldel(Pool *p, Bhdr *t){	Bhdr *s, *f, *rp, *q; 	if(t->parent == nil && p->root != t) {		t->prev->fwd = t->fwd;		t->fwd->prev = t->prev;		return;	} 	if(t->fwd != t) {		f = t->fwd;		s = t->parent;		f->parent = s;		if(s == nil)			p->root = f;		else {			if(s->left == t)				s->left = f;			else				s->right = f;		} 		rp = t->left;		f->left = rp;		if(rp != nil)			rp->parent = f;		rp = t->right;		f->right = rp;		if(rp != nil)			rp->parent = f; 		t->prev->fwd = t->fwd;		t->fwd->prev = t->prev;		return;	} 	if(t->left == nil)		rp = t->right;	else {		if(t->right == nil)			rp = t->left;		else {			f = t;			rp = t->right;			s = rp->left;			while(s != nil) {				f = rp;				rp = s;				s = rp->left;			}			if(f != t) {				s = rp->right;				f->left = s;				if(s != nil)					s->parent = f;				s = t->right;				rp->right = s;				if(s != nil)					s->parent = rp;			}			s = t->left;			rp->left = s;			s->parent = rp;		}	}	q = t->parent;	if(q == nil)		p->root = rp;	else {		if(t == q->left)			q->left = rp;		else			q->right = rp;	}	if(rp != nil)		rp->parent = q;} voidpooladd(Pool *p, Bhdr *q){	int size;	Bhdr *tp, *t; 	q->magic = MAGIC_F; 	q->left = nil;	q->right = nil;	q->parent = nil;	q->fwd = q;	q->prev = q; 	t = p->root;	if(t == nil) {		p->root = q;		return;	} 	size = q->size; 	tp = nil;	while(t != nil) {		if(size == t->size) {			q->prev = t->prev;			q->prev->fwd = q;			q->fwd = t;			t->prev = q;			return;		}		tp = t;		if(size < t->size)			t = t->left;		else			t = t->right;	} 	q->parent = tp;	if(size < tp->size)		tp->left = q;	else		tp->right = q;} void*poolalloc(Pool *p, int size){	Bhdr *q, *t;	int alloc, ldr, ns, frag;	int osize; 	if(size < 0 || size >= 1024*1024*1024)	/* for sanity and to avoid overflow */		return nil;	osize = size;	size = (size + BHDRSIZE + p->quanta) & ~(p->quanta); 	lock(&p->l);	p->nalloc++; 	t = p->root;	q = nil;	while(t) {		if(t->size == size) {			t = t->fwd;			pooldel(p, t);			t->magic = MAGIC_A;			p->cursize += t->size;			if(p->cursize > p->hw)				p->hw = p->cursize;			unlock(&p->l);			return B2D(t);		}		if(size < t->size) {			q = t;			t = t->left;		}		else			t = t->right;	}	if(q != nil) {		pooldel(p, q);		q->magic = MAGIC_A;		frag = q->size - size;		if(frag < (size>>2)) {			p->cursize += q->size;			if(p->cursize > p->hw)				p->hw = p->cursize;			unlock(&p->l);			return B2D(q);		}		/* Split */		ns = q->size - size;		q->size = size;		B2T(q)->hdr = q;		t = B2NB(q);		t->size = ns;		B2T(t)->hdr = t;		pooladd(p, t);		p->cursize += q->size;		if(p->cursize > p->hw)			p->hw = p->cursize;		unlock(&p->l);		return B2D(q);	} 	ns = p->chunk;	if(size > ns)		ns = size;	ldr = p->quanta+1; 	alloc = ns+ldr+ldr;	p->arenasize += alloc;	if(p->arenasize > p->maxsize) {		p->arenasize -= alloc;		ns = p->maxsize-p->arenasize-ldr-ldr;		ns &= ~p->quanta;		if (ns < size) {			if(poolcompact(p)) {				unlock(&p->l);				return poolalloc(p, osize);			} 			unlock(&p->l);			print("arena %s too large: size %d cursize %lud arenasize %lud maxsize %lud\n",			 p->name, size, p->cursize, p->arenasize, p->maxsize);			return nil;		}		alloc = ns+ldr+ldr;		p->arenasize += alloc;	} 	p->nbrk++;	t = (Bhdr *)sbrk(alloc);	if(t == (void*)-1) {		p->nbrk--;		unlock(&p->l);		return nil;	}	/* Double alignment */	t = (Bhdr *)(((ulong)t + 7) & ~7); 	if(p->chain != nil && (char*)t-(char*)B2LIMIT(p->chain)-ldr == 0){		/* can merge chains */		if(0)print("merging chains %p and %p in %s\n", p->chain, t, p->name);		q = B2LIMIT(p->chain);		q->magic = MAGIC_A;		q->size = alloc;		B2T(q)->hdr = q;		t = B2NB(q);		t->magic = MAGIC_E;		p->chain->csize += alloc;		p->cursize += alloc;		unlock(&p->l);		poolfree(p, B2D(q));		/* for backward merge */		return poolalloc(p, osize);	}/*	else if(p->chain != nil)		print("NOT merging chains %x and %x in %s\n", p->chain, t, p->name);	else		print("initial chain %x in %s\n", t, p->name);*/		t->magic = MAGIC_E;		/* Make a leader */	t->size = ldr;	t->csize = ns+ldr;	t->clink = p->chain;	p->chain = t;	B2T(t)->hdr = t;	t = B2NB(t); 	t->magic = MAGIC_A;		/* Make the block we are going to return */	t->size = size;	B2T(t)->hdr = t;	q = t; 	ns -= size;			/* Free the rest */	if(ns > 0) {		q = B2NB(t);		q->size = ns;		B2T(q)->hdr = q;		pooladd(p, q);	}	B2NB(q)->magic = MAGIC_E;	/* Mark the end of the chunk */ 	p->cursize += t->size;	if(p->cursize > p->hw)		p->hw = p->cursize;	unlock(&p->l);	return B2D(t);} extern void myprints(char *); voidpoolfree(Pool *p, void *v){	Bhdr *b, *c; 	D2B(b, v); 	if (p->pnum) AUDITFREE(p->pnum, getcallerpc(&p), v); 	lock(&p->l);	p->nfree++;	p->cursize -= b->size;	c = B2NB(b);	if(c->magic == MAGIC_F) {	/* Join forward */		pooldel(p, c);		c->magic = 0;		b->size += c->size;		B2T(b)->hdr = b;	} 	c = B2PT(b)->hdr;	if(c->magic == MAGIC_F) {	/* Join backward */		pooldel(p, c);		b->magic = 0;		c->size += b->size;		b = c;		B2T(b)->hdr = b;	}	pooladd(p, b);	unlock(&p->l);} static longpoolmax(Pool *p){	Bhdr *t;	long size; 	lock(&p->l);	size = p->maxsize - p->cursize;	t = p->root;	if(t != nil) {		while(t->right != nil)			t = t->right;		if(size < t->size)			size = t->size;	}	size = size - BHDRSIZE - p->quanta;	unlock(&p->l);	if(size < 0)		return 0;	return size;} ulongpoolmaxsize(void){	int i;	ulong total; 	total = 0;	for(i = 0; i < nelem(table.pool); i++)		total += table.pool[i].maxsize;	return total;} intpoolread(char *va, int count, ulong offset){	Pool *p;	int n, i, signed_off; 	n = 0;	signed_off = offset;	for(i = 0; i < table.n; i++) {		p = &table.pool[i];		n += snprint(va+n, count-n, "%11lud %11lud %11lud %11d %11d %11d %11ld %s\n",			p->cursize,			p->maxsize,			p->hw,			p->nalloc,			p->nfree,			p->nbrk,			poolmax(p),			p->name); 		if(signed_off > 0) {			signed_off -= n;			if(signed_off < 0) {				memmove(va, va+n+signed_off, -signed_off);				n = -signed_off;			}			else				n = 0;		} 	}	return n;} void*malloc(size_t size){	void *v; 	v = poolalloc(mainmem, size);	AUDITALLOC(0, getcallerpc(&size), v);	if(v != nil)		memset(v, 0, size);

Lines 1–500 of 825. Load more