From: Sepherosa Ziehau <sephe@dragonflybsd.org>
Date: Sun, 26 Oct 2008 04:29:20 +0000 (+0000)
Subject: - Return the real cluster limit used by the objcache
X-Git-Url: https://gitweb.dragonflybsd.org/~lentferj/dragonfly.git/commitdiff_plain/0aa16b5db8a773ef61a45070666220dd11d3191d

- Return the real cluster limit used by the objcache
- For mbuf objcaches, raise backing kmalloc pools' limit according to the
  cluster limits.
  Suggested-by: dillon@

Reviewed-by: aggelos@, nth@
---

diff --git a/sys/kern/kern_exec.c b/sys/kern/kern_exec.c
index 3d8e0718c7..ba3beef3cd 100644
--- a/sys/kern/kern_exec.c
+++ b/sys/kern/kern_exec.c
@@ -24,7 +24,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/kern/kern_exec.c,v 1.107.2.15 2002/07/30 15:40:46 nectar Exp $
- * $DragonFly: src/sys/kern/kern_exec.c,v 1.63 2008/01/06 16:55:51 swildner Exp $
+ * $DragonFly: src/sys/kern/kern_exec.c,v 1.64 2008/10/26 04:29:19 sephe Exp $
  */
 
 #include <sys/param.h>
@@ -106,9 +106,12 @@ static
 void
 exec_objcache_init(void *arg __unused)
 {
+	int cluster_limit;
+
+	cluster_limit = 16;	/* up to this many objects */
 	exec_objcache = objcache_create_mbacked(
 					M_EXECARGS, PATH_MAX + ARG_MAX,
-					16,	/* up to this many objects */
+					&cluster_limit,
 					2,	/* minimal magazine capacity */
 					NULL, NULL, NULL);
 }
diff --git a/sys/kern/kern_objcache.c b/sys/kern/kern_objcache.c
index 0b94d39d26..20b8c43814 100644
--- a/sys/kern/kern_objcache.c
+++ b/sys/kern/kern_objcache.c
@@ -29,7 +29,7 @@
  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
- * $DragonFly: src/sys/kern/kern_objcache.c,v 1.22 2008/02/03 13:37:56 nth Exp $
+ * $DragonFly: src/sys/kern/kern_objcache.c,v 1.23 2008/10/26 04:29:19 sephe Exp $
  */
 
 #include <sys/param.h>
@@ -175,7 +175,7 @@ null_ctor(void *obj, void *privdata, int ocflags)
  * Create an object cache.
  */
 struct objcache *
-objcache_create(const char *name, int cluster_limit, int mag_capacity,
+objcache_create(const char *name, int *cluster_limit0, int mag_capacity,
 		objcache_ctor_fn *ctor, objcache_dtor_fn *dtor, void *privdata,
 		objcache_alloc_fn *alloc, objcache_free_fn *free,
 		void *allocator_args)
@@ -187,6 +187,12 @@ objcache_create(const char *name, int cluster_limit, int mag_capacity,
 	int factor;
 	int nmagdepot;
 	int i;
+	int cluster_limit;
+
+	if (cluster_limit0 == NULL)
+		cluster_limit = 0;
+	else
+		cluster_limit = *cluster_limit0;
 
 	/* allocate object cache structure */
 	oc = kmalloc(__offsetof(struct objcache, cache_percpu[ncpus]),
@@ -278,6 +284,8 @@ objcache_create(const char *name, int cluster_limit, int mag_capacity,
 	LIST_INSERT_HEAD(&allobjcaches, oc, oc_next);
 	spin_unlock_wr(&objcachelist_spin);
 
+	if (cluster_limit0 != NULL)
+		*cluster_limit0 = cluster_limit;
 	return (oc);
 }
 
@@ -290,7 +298,7 @@ objcache_create_simple(malloc_type_t mtype, size_t objsize)
 	margs = kmalloc(sizeof(*margs), M_OBJCACHE, M_WAITOK|M_ZERO);
 	margs->objsize = objsize;
 	margs->mtype = mtype;
-	oc = objcache_create(mtype->ks_shortdesc, 0, 0,
+	oc = objcache_create(mtype->ks_shortdesc, NULL, 0,
 			     NULL, NULL, NULL,
 			     objcache_malloc_alloc, objcache_malloc_free,
 			     margs);
@@ -299,7 +307,7 @@ objcache_create_simple(malloc_type_t mtype, size_t objsize)
 
 struct objcache *
 objcache_create_mbacked(malloc_type_t mtype, size_t objsize,
-			int cluster_limit, int mag_capacity,
+			int *cluster_limit, int mag_capacity,
 			objcache_ctor_fn *ctor, objcache_dtor_fn *dtor,
 			void *privdata)
 {
diff --git a/sys/kern/kern_syslink.c b/sys/kern/kern_syslink.c
index ba8c5ff898..ca2c382ff9 100644
--- a/sys/kern/kern_syslink.c
+++ b/sys/kern/kern_syslink.c
@@ -31,7 +31,7 @@
  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
- * $DragonFly: src/sys/kern/kern_syslink.c,v 1.15 2007/08/13 17:47:19 dillon Exp $
+ * $DragonFly: src/sys/kern/kern_syslink.c,v 1.16 2008/10/26 04:29:19 sephe Exp $
  */
 /*
  * This module implements the core syslink() system call and provides
@@ -148,13 +148,13 @@ syslinkinit(void *dummy __unused)
 {
 	size_t n = sizeof(struct slmsg);
 
-	sl_objcache_none = objcache_create_mbacked(M_SYSLINK, n, 0, 64,
+	sl_objcache_none = objcache_create_mbacked(M_SYSLINK, n, NULL, 64,
 						   slmsg_ctor, slmsg_dtor,
 						   &sl_objcache_none);
-	sl_objcache_small= objcache_create_mbacked(M_SYSLINK, n, 0, 64,
+	sl_objcache_small= objcache_create_mbacked(M_SYSLINK, n, NULL, 64,
 						   slmsg_ctor, slmsg_dtor,
 						   &sl_objcache_small);
-	sl_objcache_big  = objcache_create_mbacked(M_SYSLINK, n, 0, 16,
+	sl_objcache_big  = objcache_create_mbacked(M_SYSLINK, n, NULL, 16,
 						   slmsg_ctor, slmsg_dtor,
 						   &sl_objcache_big);
 }
diff --git a/sys/kern/kern_sysref.c b/sys/kern/kern_sysref.c
index 458081b862..d2b17e682e 100644
--- a/sys/kern/kern_sysref.c
+++ b/sys/kern/kern_sysref.c
@@ -31,7 +31,7 @@
  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  * 
- * $DragonFly: src/sys/kern/kern_sysref.c,v 1.6 2007/05/29 17:01:04 dillon Exp $
+ * $DragonFly: src/sys/kern/kern_sysref.c,v 1.7 2008/10/26 04:29:19 sephe Exp $
  */
 /*
  * System resource control module for all cluster-addressable system resource
@@ -144,7 +144,7 @@ sysref_alloc(struct sysref_class *srclass)
 		KKASSERT(srclass->mtype != NULL);
 		srclass->oc = objcache_create_mbacked(
 				srclass->mtype, srclass->objsize, 
-				0, srclass->mag_capacity,
+				NULL, srclass->mag_capacity,
 				sysref_ctor, sysref_dtor, srclass);
 	}
 
diff --git a/sys/kern/lwkt_thread.c b/sys/kern/lwkt_thread.c
index 4afb426fa8..a3b07befaa 100644
--- a/sys/kern/lwkt_thread.c
+++ b/sys/kern/lwkt_thread.c
@@ -31,7 +31,7 @@
  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  * 
- * $DragonFly: src/sys/kern/lwkt_thread.c,v 1.119 2008/09/11 01:11:42 y0netan1 Exp $
+ * $DragonFly: src/sys/kern/lwkt_thread.c,v 1.120 2008/10/26 04:29:19 sephe Exp $
  */
 
 /*
@@ -192,9 +192,9 @@ void
 lwkt_init(void)
 {
     /* An objcache has 2 magazines per CPU so divide cache size by 2. */
-    thread_cache = objcache_create_mbacked(M_THREAD, sizeof(struct thread), 0,
-			CACHE_NTHREADS/2, _lwkt_thread_ctor, _lwkt_thread_dtor,
-			NULL);
+    thread_cache = objcache_create_mbacked(M_THREAD, sizeof(struct thread),
+			NULL, CACHE_NTHREADS/2,
+			_lwkt_thread_ctor, _lwkt_thread_dtor, NULL);
 }
 
 /*
diff --git a/sys/kern/uipc_mbuf.c b/sys/kern/uipc_mbuf.c
index 1f33799875..378211245e 100644
--- a/sys/kern/uipc_mbuf.c
+++ b/sys/kern/uipc_mbuf.c
@@ -65,7 +65,7 @@
  *
  * @(#)uipc_mbuf.c	8.2 (Berkeley) 1/4/94
  * $FreeBSD: src/sys/kern/uipc_mbuf.c,v 1.51.2.24 2003/04/15 06:59:29 silby Exp $
- * $DragonFly: src/sys/kern/uipc_mbuf.c,v 1.68 2008/10/24 11:15:07 sephe Exp $
+ * $DragonFly: src/sys/kern/uipc_mbuf.c,v 1.69 2008/10/26 04:29:19 sephe Exp $
  */
 
 #include "opt_param.h"
@@ -528,10 +528,14 @@ struct objcache_malloc_args mclmeta_malloc_args =
 static void
 mbinit(void *dummy)
 {
+	int mb_limit, cl_limit, mbcl_limit;
+	int limit;
 	int i;
 
-	for (i = 0; i < ncpus; i++)
-	{
+	/*
+	 * Initialize statistics
+	 */
+	for (i = 0; i < ncpus; i++) {
 		atomic_set_long_nonlocked(&mbstat[i].m_msize, MSIZE);
 		atomic_set_long_nonlocked(&mbstat[i].m_mclbytes, MCLBYTES);
 		atomic_set_long_nonlocked(&mbstat[i].m_minclsize, MINCLSIZE);
@@ -539,22 +543,57 @@ mbinit(void *dummy)
 		atomic_set_long_nonlocked(&mbstat[i].m_mhlen, MHLEN);
 	}
 
-	mbuf_cache = objcache_create("mbuf", nmbufs, 0,
+	/*
+	 * Create objtect caches and save cluster limits, which will
+	 * be used to adjust backing kmalloc pools' limit later.
+	 */
+
+	mb_limit = cl_limit = mbcl_limit = 0;
+
+	limit = nmbufs;
+	mbuf_cache = objcache_create("mbuf", &limit, 0,
 	    mbuf_ctor, NULL, NULL,
 	    objcache_malloc_alloc, objcache_malloc_free, &mbuf_malloc_args);
-	mbufphdr_cache = objcache_create("mbuf pkt hdr", nmbufs, 64,
+	if (limit > mb_limit)
+		mb_limit = limit;
+
+	limit = nmbufs;
+	mbufphdr_cache = objcache_create("mbuf pkt hdr", &limit, 64,
 	    mbufphdr_ctor, NULL, NULL,
 	    objcache_malloc_alloc, objcache_malloc_free, &mbuf_malloc_args);
-	mclmeta_cache = objcache_create("cluster mbuf", nmbclusters , 0,
+	if (limit > mb_limit)
+		mb_limit = limit;
+
+	cl_limit = nmbclusters;
+	mclmeta_cache = objcache_create("cluster mbuf", &cl_limit, 0,
 	    mclmeta_ctor, mclmeta_dtor, NULL,
 	    objcache_malloc_alloc, objcache_malloc_free, &mclmeta_malloc_args);
-	mbufcluster_cache = objcache_create("mbuf + cluster", nmbclusters, 0,
+
+	limit = nmbclusters;
+	mbufcluster_cache = objcache_create("mbuf + cluster", &limit, 0,
 	    mbufcluster_ctor, mbufcluster_dtor, NULL,
 	    objcache_malloc_alloc, objcache_malloc_free, &mbuf_malloc_args);
+	if (limit > mbcl_limit)
+		mbcl_limit = limit;
+
+	limit = nmbclusters;
 	mbufphdrcluster_cache = objcache_create("mbuf pkt hdr + cluster",
-	    nmbclusters, 64, mbufphdrcluster_ctor, mbufcluster_dtor, NULL,
+	    &limit, 64, mbufphdrcluster_ctor, mbufcluster_dtor, NULL,
 	    objcache_malloc_alloc, objcache_malloc_free, &mbuf_malloc_args);
-	return;
+	if (limit > mbcl_limit)
+		mbcl_limit = limit;
+
+	/*
+	 * Adjust backing kmalloc pools' limit
+	 */
+	kmalloc_raise_limit(mclmeta_malloc_args.mtype,
+			    mclmeta_malloc_args.objsize * cl_limit);
+	kmalloc_raise_limit(M_MBUFCL, MCLBYTES * cl_limit);
+
+	mb_limit += mbcl_limit;
+	mb_limit += mb_limit / 4; /* save some space for non-pkthdr mbufs */
+	kmalloc_raise_limit(mbuf_malloc_args.mtype,
+			    mbuf_malloc_args.objsize * mb_limit);
 }
 
 /*
diff --git a/sys/sys/objcache.h b/sys/sys/objcache.h
index f5736dfdc7..5080dd6016 100644
--- a/sys/sys/objcache.h
+++ b/sys/sys/objcache.h
@@ -29,7 +29,7 @@
  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
- * $DragonFly: src/sys/sys/objcache.h,v 1.10 2007/05/29 17:01:02 dillon Exp $
+ * $DragonFly: src/sys/sys/objcache.h,v 1.11 2008/10/26 04:29:20 sephe Exp $
  */
 
 #ifndef _OBJCACHE_H_
@@ -60,7 +60,7 @@ typedef void (objcache_free_fn)(void *obj, void *allocator_args);
 struct objcache;
 
 struct objcache
-	*objcache_create(const char *name, int cluster_limit, int mag_capacity,
+	*objcache_create(const char *name, int *cluster_limit, int mag_capacity,
 			 objcache_ctor_fn *ctor, objcache_dtor_fn *dtor,
 			 void *privdata,
 			 objcache_alloc_fn *alloc, objcache_free_fn *free,
@@ -69,7 +69,7 @@ struct objcache
 	*objcache_create_simple(malloc_type_t mtype, size_t objsize);
 struct objcache
 	*objcache_create_mbacked(malloc_type_t mtype, size_t objsize,
-			  int cluster_limit, int mag_capacity,
+			  int *cluster_limit, int mag_capacity,
 			  objcache_ctor_fn *ctor, objcache_dtor_fn *dtor,
 			  void *privdata);
 void	*objcache_get(struct objcache *oc, int ocflags);