#include	"dat.h"
#include	"fns.h"
#include	"error.h"
#include	"interp.h"

enum
{
	Qdir,
	Qctl,
	Qstate,
	Qsum,
	Qevent,
	Qprof,
	Qheap,
	Qgc
};

static
Dirtab memdir[] =
{
	".",			{Qdir, 0, QTDIR},	0,	DMDIR|0555,
	"memctl",		{Qctl},	0,			0666,
	"memstate",	{Qstate},	0,			0444,
	"memsum",	{Qsum},	0,			0444,
	"memevent",	{Qevent},	0,			0444,
	"memprof",	{Qprof},	0,			0444,
	"memheap",	{Qheap},	0,			0444,
	"memgc",		{Qgc},	0,			0444,
};

enum
{
	/* these are the top two bits of size */
	Pflags=	3<<30,
	  Pfree=	0<<30,
	  Palloc=	1<<30,
	  Paend=	2<<30,
	  Pimmutable=	3<<30,

	Npool = 3,
	Nevent = 10000,
	Nstate = 12000
};

/*
 * pool snapshots
 */
typedef struct Pstate Pstate;
struct Pstate
{
	ulong	base;
	ulong	size;
};

static struct
{
	Pstate	state[3+Nstate];
	Pstate*	lim;
	Pstate*	ptr;
	int	summary;
} poolstate[Npool];
static Ref	stateopen;

/*
 * pool/heap allocation events
 */
typedef struct Pevent Pevent;
struct Pevent
{
	int	pool;
	ulong	pc;
	ulong	base;
	ulong	size;
};

static struct
{
	Lock	l;
	Ref	inuse;
	Rendez	r;
	int	open;
	Pevent	events[Nevent];
	int	rd;
	int	wr;
	int	full;
	int	want;
	ulong	lost;
} poolevents;

/*
 * allocation profiles
 */
typedef struct Pprof Pprof;
typedef struct Pbucket Pbucket;

struct Pbucket
{
	ulong	val;
	ulong	pool;
	ulong	count;
	ulong	size;
	Pbucket*	next;
};

static struct {
	Ref	inuse;	/* only one of these things */
	Lock	l;
	Pbucket	buckets[1000];
	Pbucket	snap[1000];
	int	used;
	int	snapped;
	Pbucket*	hash[128];
	ulong	lost;
} memprof;

extern	void	(*memmonitor)(int, ulong, ulong, ulong);
extern	ulong	gcnruns;
extern	ulong	gcsweeps;
extern	ulong	gcbroken;
extern	ulong	gchalted;
extern	ulong	gcepochs;
extern	uvlong	gcdestroys;
extern	uvlong	gcinspects;
extern	uvlong	gcbusy;
extern	uvlong	gcidle;
extern	uvlong	gcidlepass;
extern	uvlong	gcpartial;


static void
mprofreset(void)
{
	lock(&memprof.l);	/* need ilock in kernel */
	memset(memprof.hash, 0, sizeof(memprof.hash));
	memprof.used = 0;
	memprof.lost = 0;
	unlock(&memprof.l);
}

static void
mprofmonitor(int pool, ulong pc, ulong base, ulong size)
{
	Pbucket **h0, **h, *p;

	if((pool&7) == 1)
		return;	/* ignore heap */
	USED(base);
	h0 = &memprof.hash[((pc>>16)^(pc>>4))&(nelem(memprof.hash)-1)];
	lock(&memprof.l);
	for(h = h0; (p = *h) != nil; h = &p->next)
		if(p->val == pc && p->pool == pool){
			p->count++;
			p->size += size;
			*h = p->next;
			p->next = *h0;
			*h0 = p;
			unlock(&memprof.l);
			return;
		}
	if(memprof.used >= nelem(memprof.buckets)){
		memprof.lost++;
		unlock(&memprof.l);
		return;
	}
	p = &memprof.buckets[memprof.used++];
	p->val = pc;
	p->pool = pool;
	p->count = 1;
	p->size = size;
	p->next = *h0;
	*h0 = p;
	unlock(&memprof.l);
}

static void
_memmonitor(int pool, ulong pc, ulong base, ulong size)
{
	Pevent e;

	e.pool = pool;
	e.pc = pc;
	e.base = base;
	e.size = size;
	lock(&poolevents.l);
	if(!poolevents.full){
		poolevents.events[poolevents.wr] = e;
		if(++poolevents.wr == nelem(poolevents.events))
			poolevents.wr = 0;
		if(poolevents.wr == poolevents.rd)
			poolevents.full = 1;
	}else
		poolevents.lost++;
	if(poolevents.want){
		poolevents.want = 0;
		Wakeup(&poolevents.r);
	}
	unlock(&poolevents.l);
}

static int
ismemdata(void *v)
{
	USED(v);
	return poolevents.full || poolevents.rd != poolevents.wr;
}

static char*
memaudit(int pno, Bhdr *b)
{
	Pstate *p;

	if(pno >= Npool)
		return "too many pools for memaudit";
	if((p = poolstate[pno].ptr) == poolstate[pno].lim){
		if(b->magic == MAGIC_E)
			return nil;
		p = &poolstate[pno].state[1];
		if(b->magic == MAGIC_F)
			p++;
		p->base++;
		p->size += b->size;
		return nil;
	}
	poolstate[pno].ptr++;
	p->base = (ulong)b;
	p->size = b->size;
	switch(b->magic){
	case MAGIC_A:
		p->size |= Palloc;
		break;
	case MAGIC_F:
		p->size |= Pfree;
		break;
	case MAGIC_E:
		p->size = b->csize | Paend;
		break;
	case MAGIC_I:
		p->size |= Pimmutable;
		break;
	default:
		return "bad magic number in block";
	}
	return nil;
}

static void
mput4(uchar *m, ulong v)
{
	m[0] = v>>24;
	m[1] = v>>16;
	m[2] = v>>8;
	m[3] = v;
}

static Chan*
memattach(char *spec)
{
	return devattach('%', spec);
}

static Walkqid*
memwalk(Chan *c, Chan *nc, char **name, int nname)
{
	return devwalk(c, nc, name, nname, memdir, nelem(memdir), devgen);
}

static int
memstat(Chan *c, uchar *db, int n)
{
	return devstat(c, db, n, memdir, nelem(memdir), devgen);
}

static Chan*
memopen(Chan *c, int omode)
{
	if(memmonitor != nil && c->qid.path != Qgc)
		error(Einuse);
	c = devopen(c, omode, memdir, nelem(memdir), devgen);
	switch((ulong)c->qid.path){
	case Qevent:
		if(incref(&poolevents.inuse) != 1){
			decref(&poolevents.inuse);
			c->flag &= ~COPEN;
			error(Einuse);
		}
		poolevents.rd = poolevents.wr = 0;
		poolevents.full = 0;
		poolevents.want = 0;
		poolevents.lost = 0;
		memmonitor = _memmonitor;
		poolevents.open = 1;
		break;
	case Qstate:
		if(incref(&stateopen) != 1){
			decref(&stateopen);
			c->flag &= ~COPEN;
			error(Einuse);
		}
		break;
	case Qprof:
		if(incref(&memprof.inuse) != 1){
			decref(&memprof.inuse);
			c->flag &= ~COPEN;
			error(Einuse);
		}
		memmonitor = mprofmonitor;
		break;
	}
	return c;
}

static void
memclose(Chan *c)
{
	if((c->flag & COPEN) == 0)
		return;
	switch((ulong)c->qid.path) {
	case Qevent:
		memmonitor = nil;
		poolevents.open = 0;
		decref(&poolevents.inuse);
		break;
	case Qstate:
		decref(&stateopen);
		break;
	case Qprof:
		decref(&memprof.inuse);
		memmonitor = nil;
		break;
	}

}

static long
memread(Chan *c, void *va, long count, vlong offset)
{
	uchar *m;
	char *e, *s;
	int i, summary;
	long n, nr;
	Pstate *p;
	Pevent pe;
	Pbucket *b;

	if(c->qid.type & QTDIR)
		return devdirread(c, va, count, memdir, nelem(memdir), devgen);

	summary = 0;
	switch((ulong)c->qid.path) {
	default:
		error(Egreg);
	case Qctl:
		return 0;
	case Qsum:
		summary = 1;
		/* fall through */
	case Qstate:
		if(offset == 0){
			for(i=0; i<Npool; i++){
				poolstate[i].ptr = &poolstate[i].state[3];
				poolstate[i].lim = poolstate[i].ptr + Nstate;
				memset(poolstate[i].state, 0, sizeof(poolstate[i].state));
				poolstate[i].summary = summary;
			}
			e = poolaudit(memaudit);
			if(e != nil){
				print("mem: %s\n", e);
				error(e);
			}
		}
		m = va;
		nr = offset/8;
		for(i=0; i<Npool && count >= 8; i++){
			n = poolstate[i].ptr - poolstate[i].state;
			poolstate[i].state[0].base = i;
			poolstate[i].state[0].size = n;
			if(nr >= n){
				nr -= n;
				continue;
			}
			n -= nr;
			p = &poolstate[i].state[nr];
			for(; --n >= 0 && (count -= 8) >= 0; m += 8, p++){
				mput4(m, p->base);
				mput4(m+4, p->size);
			}
		}
		return m-(uchar*)va;
	case Qevent:
		while(!ismemdata(nil)){
			poolevents.want = 1;
			Sleep(&poolevents.r, ismemdata, nil);
		}
		m = va;
		do{
			if((count -= 4*4) < 0)
				return m-(uchar*)va;
			pe = poolevents.events[poolevents.rd];
			mput4(m, pe.pool);
			mput4(m+4, pe.pc);
			mput4(m+8, pe.base);
			mput4(m+12, pe.size);
			m += 4*4;
			if(++poolevents.rd >= nelem(poolevents.events))
				poolevents.rd = 0;
		}while(poolevents.rd != poolevents.wr);
		poolevents.full = 0;
		return m-(uchar*)va;
	case Qprof:
		if(offset == 0){
			lock(&memprof.l);
			memmove(memprof.snap, memprof.buckets, memprof.used*sizeof(memprof.buckets[0]));
			memprof.snapped = memprof.used;
			unlock(&memprof.l);
		}
		m = va;
		for(i = offset/(4*4); i < memprof.snapped && (count -= 4*4) >= 0; i++){
			b = &memprof.snap[i];
			mput4(m, b->pool);
			mput4(m+4, b->val);
			mput4(m+8, b->count);
			mput4(m+12, b->size);
			m += 4*4;
		}
		return m-(uchar*)va;
	case Qgc:
		s = malloc(READSTR);
		if(s == nil)
			error(Enomem);
		if(waserror()){
			free(s);
			nexterror();
		}
		snprint(s, READSTR, "runs: %lud\nsweeps: %lud\nbchain: %lud\nhalted: %lud\nepochs: %lud\ndestroy: %llud\ninspects: %llud\nbusy: %llud\nidle: %llud\nidlepass: %llud\npartial: %llud\n",
			gcnruns, gcsweeps, gcbroken, gchalted, gcepochs, gcdestroys, gcinspects, gcbusy, gcidle, gcidlepass, gcpartial);
		count = readstr(offset, va, count, s);
		poperror();
		free(s);
		return count;
	}
}

static long
memwrite(Chan *c, void *va, long count, vlong offset)
{
	USED(offset);
	USED(count);
	USED(va);

	if(c->qid.type & QTDIR)
		error(Eperm);

	switch((ulong)c->qid.path) {
	default:
		error(Egreg);
	case Qctl:
		error(Ebadarg);
	case Qstate:
		error(Eperm);
	case Qprof:
		mprofreset();
		break;
	}
	return 0;
}

Dev memdevtab = {
	'%',
	"mem",

	devinit,
	memattach,
	memwalk,
	memstat,
	memopen,
	devcreate,
	memclose,
	memread,
	devbread,
	memwrite,
	devbwrite,
	devremove,
	devwstat
};