shithub: asif

Info  •  Files  •  Log

zalloc: hide implementation and add checks

really complicated now

--- a/asif.h

+++ b/asif.h

@@ -106,19 +106,13 @@

 void*	emalloc(ulong);

 typedef struct Zpool Zpool;

-typedef struct Znode Znode;

-struct Znode{

-	Znode *next;

-	Znode *prev;

+struct Zpool{

+	usize elsize;

 	void data[];

 };

-struct Zpool{

-	int elsize;

-	Znode;

-};

-void	zfree(Znode*, Zpool*);

+void	zfree(void*);

 void*	zalloc(Zpool*);

-Zpool*	znew(int);

+Zpool*	znew(usize);

 #define MIN(a,b)	((a) <= (b) ? (a) : (b))

 #define MAX(a,b)	((a) >= (b) ? (a) : (b))

--- a/zalloc.c

+++ b/zalloc.c

@@ -2,15 +2,65 @@

 #include <libc.h>

 #include "asif.h"

-/* no nodes are ever freed, left to be reclaimed by the kernel on exit */

+/* no nodes are ever freed, left to be reclaimed by the kernel on exit

+ * got more complicated, but should be able to detect some bugs...

+ * unsuitable for very large collections probably */

+

+typedef struct Zhouse Zhouse;

+typedef struct Znode Znode;

+typedef struct Zhdr Zhdr;

+typedef struct Ztail Ztail;

+struct Zhdr{

+	Zhouse *z;

+	Znode *next;

+	Znode *prev;

+};

+struct Znode{

+	Zhdr;

+	void data[];

+};

+struct Ztail{

+	Zpool *z;

+};

+struct Zhouse{

+	Zpool;

+	Znode;

+};

+

 enum{

 	Ninc = 128,

 };

+static Ztail *

+n2t(Znode *p)

+{

+	return (Ztail *)((uchar *)p + sizeof(Zhdr) + p->z->elsize);

+}

+

+static Znode *

+v2n(uchar *data)

+{

+	return (Znode *)(data - sizeof(Zhdr));

+}

+

 static void

-zlink(Znode *p, Zpool *z)

+zcheckpool(Znode *p, Zhouse *z)

 {

-	assert(p != nil && z != nil);

+	Ztail *t;

+

+	assert(p == nil || p != z);

+	assert(z != nil && z->elsize > 0);

+	if(p != nil){

+		assert(p->z == z);

+		t = n2t(p);

+		assert(t->z == z);

+	}

+}

+

+static void

+zlink(Znode *p, Zhouse *z)

+{

+	zcheckpool(p, z);

 	p->prev = z->prev;

 	p->next = &z->Znode;

 	z->prev->next = p;

@@ -18,57 +68,78 @@

 }

 static Znode *

-zunlink(Zpool *z)

+zpop(Zhouse *z)

 {

-	Znode *q;

+	Znode *p;

-	assert(z != nil && z->next != nil);

-	q = z->next;

-	q->next->prev = &z->Znode;

-	z->next = q->next;

-	q->prev = q->next = nil;

-	return q;

+	p = z->next;

+	assert(p != z);

+	zcheckpool(p, z);

+	p->next->prev = &z->Znode;

+	z->next = p->next;

+	p->prev = p->next = nil;

+	return p;

 }

 static void

-zfeed(Zpool *z)

+_zfree(Znode *p)

 {

-	int n;

-	uchar *p, *q;

+	Zhouse *z;

-	assert(z != nil && z->elsize > 0);

-	if(z->next != z)

+	if(p == nil)

 		return;

-	n = z->elsize + sizeof *z;

-	p = emalloc(Ninc * n);		// see comment

-	for(q=p; q<p+Ninc*n; q+=n)

-		zlink((Znode*)q, z);

+	z = p->z;

+	zcheckpool(p, z);

+	memset(p->data, 0, z->elsize);

+	zlink(p, z);

 }

 void

-zfree(Znode *p, Zpool *z)

+zfree(void *data)

 {

-	if(p == nil)

+	if(data == nil)

 		return;

-	assert(z != nil);

-	memset(p->data, 0, z->elsize);

-	zlink(p, z);

+	_zfree(v2n(data));

 }

+static void

+zfeed(Zhouse *z)

+{

+	ulong n;

+	uchar *u, *v;

+	Znode *p;

+	Ztail *t;

+

+	if(z->next != z)

+		return;

+	zcheckpool(nil, z);

+	n = sizeof(Zhdr) + z->elsize + sizeof *t;

+	u = emalloc(Ninc * n);

+	for(v=u; v<u+Ninc*n; v+=n){

+		p = (Znode *)v;

+		t = n2t(p);

+		p->z = z->z;

+		t->z = z->z;

+		zlink(p, z);

+	}

+}

+

 void *

-zalloc(Zpool *z)

+zalloc(Zpool *zp)

 {

 	Znode *p;

+	Zhouse *z;

+	z = (Zhouse *)zp;

 	zfeed(z);

-	p = zunlink(z);

+	p = zpop(z);

 	return p->data;

 }

 Zpool *

-znew(int elsize)

+znew(usize elsize)

 {

-	Zpool *z;

+	Zhouse *z;

 	assert(elsize > 0);

 	z = emalloc(sizeof *z);