2005-01-07 02:29:27 +00:00
|
|
|
/*-
|
2017-11-27 15:23:17 +00:00
|
|
|
* SPDX-License-Identifier: BSD-2-Clause-FreeBSD
|
|
|
|
*
|
2019-11-28 07:49:25 +00:00
|
|
|
* Copyright (c) 2002-2019 Jeffrey Roberson <jeff@FreeBSD.org>
|
2005-07-16 09:51:52 +00:00
|
|
|
* Copyright (c) 2004, 2005 Bosko Milekic <bmilekic@FreeBSD.org>
|
|
|
|
* All rights reserved.
|
2002-03-19 09:11:49 +00:00
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice unmodified, this list of conditions, and the following
|
|
|
|
* disclaimer.
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
|
|
|
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
|
|
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
|
|
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
|
|
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
|
|
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
*
|
|
|
|
* $FreeBSD$
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2019-01-15 19:33:47 +00:00
|
|
|
#include <sys/counter.h>
|
2017-09-15 14:59:35 +00:00
|
|
|
#include <sys/_bitset.h>
|
2018-10-24 16:49:16 +00:00
|
|
|
#include <sys/_domainset.h>
|
2016-02-09 20:22:35 +00:00
|
|
|
#include <sys/_task.h>
|
|
|
|
|
2002-03-19 09:11:49 +00:00
|
|
|
/*
|
|
|
|
* This file includes definitions, structures, prototypes, and inlines that
|
|
|
|
* should not be used outside of the actual implementation of UMA.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
2018-01-12 23:25:05 +00:00
|
|
|
* The brief summary; Zones describe unique allocation types. Zones are
|
|
|
|
* organized into per-CPU caches which are filled by buckets. Buckets are
|
|
|
|
* organized according to memory domains. Buckets are filled from kegs which
|
|
|
|
* are also organized according to memory domains. Kegs describe a unique
|
|
|
|
* allocation type, backend memory provider, and layout. Kegs are associated
|
|
|
|
* with one or more zones and zones reference one or more kegs. Kegs provide
|
|
|
|
* slabs which are virtually contiguous collections of pages. Each slab is
|
|
|
|
* broken down int one or more items that will satisfy an individual allocation.
|
|
|
|
*
|
|
|
|
* Allocation is satisfied in the following order:
|
|
|
|
* 1) Per-CPU cache
|
|
|
|
* 2) Per-domain cache of buckets
|
|
|
|
* 3) Slab from any of N kegs
|
|
|
|
* 4) Backend page provider
|
|
|
|
*
|
|
|
|
* More detail on individual objects is contained below:
|
2002-03-19 09:11:49 +00:00
|
|
|
*
|
Bring in mbuma to replace mballoc.
mbuma is an Mbuf & Cluster allocator built on top of a number of
extensions to the UMA framework, all included herein.
Extensions to UMA worth noting:
- Better layering between slab <-> zone caches; introduce
Keg structure which splits off slab cache away from the
zone structure and allows multiple zones to be stacked
on top of a single Keg (single type of slab cache);
perhaps we should look into defining a subset API on
top of the Keg for special use by malloc(9),
for example.
- UMA_ZONE_REFCNT zones can now be added, and reference
counters automagically allocated for them within the end
of the associated slab structures. uma_find_refcnt()
does a kextract to fetch the slab struct reference from
the underlying page, and lookup the corresponding refcnt.
mbuma things worth noting:
- integrates mbuf & cluster allocations with extended UMA
and provides caches for commonly-allocated items; defines
several zones (two primary, one secondary) and two kegs.
- change up certain code paths that always used to do:
m_get() + m_clget() to instead just use m_getcl() and
try to take advantage of the newly defined secondary
Packet zone.
- netstat(1) and systat(1) quickly hacked up to do basic
stat reporting but additional stats work needs to be
done once some other details within UMA have been taken
care of and it becomes clearer to how stats will work
within the modified framework.
From the user perspective, one implication is that the
NMBCLUSTERS compile-time option is no longer used. The
maximum number of clusters is still capped off according
to maxusers, but it can be made unlimited by setting
the kern.ipc.nmbclusters boot-time tunable to zero.
Work should be done to write an appropriate sysctl
handler allowing dynamic tuning of kern.ipc.nmbclusters
at runtime.
Additional things worth noting/known issues (READ):
- One report of 'ips' (ServeRAID) driver acting really
slow in conjunction with mbuma. Need more data.
Latest report is that ips is equally sucking with
and without mbuma.
- Giant leak in NFS code sometimes occurs, can't
reproduce but currently analyzing; brueffer is
able to reproduce but THIS IS NOT an mbuma-specific
problem and currently occurs even WITHOUT mbuma.
- Issues in network locking: there is at least one
code path in the rip code where one or more locks
are acquired and we end up in m_prepend() with
M_WAITOK, which causes WITNESS to whine from within
UMA. Current temporary solution: force all UMA
allocations to be M_NOWAIT from within UMA for now
to avoid deadlocks unless WITNESS is defined and we
can determine with certainty that we're not holding
any locks when we're M_WAITOK.
- I've seen at least one weird socketbuffer empty-but-
mbuf-still-attached panic. I don't believe this
to be related to mbuma but please keep your eyes
open, turn on debugging, and capture crash dumps.
This change removes more code than it adds.
A paper is available detailing the change and considering
various performance issues, it was presented at BSDCan2004:
http://www.unixdaemons.com/~bmilekic/netbuf_bmilekic.pdf
Please read the paper for Future Work and implementation
details, as well as credits.
Testing and Debugging:
rwatson,
brueffer,
Ketrien I. Saihr-Kesenchedra,
...
Reviewed by: Lots of people (for different parts)
2004-05-31 21:46:06 +00:00
|
|
|
* Kegs contain lists of slabs which are stored in either the full bin, empty
|
2002-03-19 09:11:49 +00:00
|
|
|
* bin, or partially allocated bin, to reduce fragmentation. They also contain
|
|
|
|
* the user supplied value for size, which is adjusted for alignment purposes
|
Bring in mbuma to replace mballoc.
mbuma is an Mbuf & Cluster allocator built on top of a number of
extensions to the UMA framework, all included herein.
Extensions to UMA worth noting:
- Better layering between slab <-> zone caches; introduce
Keg structure which splits off slab cache away from the
zone structure and allows multiple zones to be stacked
on top of a single Keg (single type of slab cache);
perhaps we should look into defining a subset API on
top of the Keg for special use by malloc(9),
for example.
- UMA_ZONE_REFCNT zones can now be added, and reference
counters automagically allocated for them within the end
of the associated slab structures. uma_find_refcnt()
does a kextract to fetch the slab struct reference from
the underlying page, and lookup the corresponding refcnt.
mbuma things worth noting:
- integrates mbuf & cluster allocations with extended UMA
and provides caches for commonly-allocated items; defines
several zones (two primary, one secondary) and two kegs.
- change up certain code paths that always used to do:
m_get() + m_clget() to instead just use m_getcl() and
try to take advantage of the newly defined secondary
Packet zone.
- netstat(1) and systat(1) quickly hacked up to do basic
stat reporting but additional stats work needs to be
done once some other details within UMA have been taken
care of and it becomes clearer to how stats will work
within the modified framework.
From the user perspective, one implication is that the
NMBCLUSTERS compile-time option is no longer used. The
maximum number of clusters is still capped off according
to maxusers, but it can be made unlimited by setting
the kern.ipc.nmbclusters boot-time tunable to zero.
Work should be done to write an appropriate sysctl
handler allowing dynamic tuning of kern.ipc.nmbclusters
at runtime.
Additional things worth noting/known issues (READ):
- One report of 'ips' (ServeRAID) driver acting really
slow in conjunction with mbuma. Need more data.
Latest report is that ips is equally sucking with
and without mbuma.
- Giant leak in NFS code sometimes occurs, can't
reproduce but currently analyzing; brueffer is
able to reproduce but THIS IS NOT an mbuma-specific
problem and currently occurs even WITHOUT mbuma.
- Issues in network locking: there is at least one
code path in the rip code where one or more locks
are acquired and we end up in m_prepend() with
M_WAITOK, which causes WITNESS to whine from within
UMA. Current temporary solution: force all UMA
allocations to be M_NOWAIT from within UMA for now
to avoid deadlocks unless WITNESS is defined and we
can determine with certainty that we're not holding
any locks when we're M_WAITOK.
- I've seen at least one weird socketbuffer empty-but-
mbuf-still-attached panic. I don't believe this
to be related to mbuma but please keep your eyes
open, turn on debugging, and capture crash dumps.
This change removes more code than it adds.
A paper is available detailing the change and considering
various performance issues, it was presented at BSDCan2004:
http://www.unixdaemons.com/~bmilekic/netbuf_bmilekic.pdf
Please read the paper for Future Work and implementation
details, as well as credits.
Testing and Debugging:
rwatson,
brueffer,
Ketrien I. Saihr-Kesenchedra,
...
Reviewed by: Lots of people (for different parts)
2004-05-31 21:46:06 +00:00
|
|
|
* and rsize is the result of that. The Keg also stores information for
|
2002-03-19 09:11:49 +00:00
|
|
|
* managing a hash of page addresses that maps pages to uma_slab_t structures
|
|
|
|
* for pages that don't have embedded uma_slab_t's.
|
2018-01-12 23:25:05 +00:00
|
|
|
*
|
|
|
|
* Keg slab lists are organized by memory domain to support NUMA allocation
|
|
|
|
* policies. By default allocations are spread across domains to reduce the
|
|
|
|
* potential for hotspots. Special keg creation flags may be specified to
|
|
|
|
* prefer location allocation. However there is no strict enforcement as frees
|
|
|
|
* may happen on any CPU and these are returned to the CPU-local cache
|
|
|
|
* regardless of the originating domain.
|
2002-03-19 09:11:49 +00:00
|
|
|
*
|
|
|
|
* The uma_slab_t may be embedded in a UMA_SLAB_SIZE chunk of memory or it may
|
|
|
|
* be allocated off the page from a special slab zone. The free list within a
|
2013-06-13 21:05:38 +00:00
|
|
|
* slab is managed with a bitmask. For item sizes that would yield more than
|
|
|
|
* 10% memory waste we potentially allocate a separate uma_slab_t if this will
|
|
|
|
* improve the number of items per slab that will fit.
|
2002-03-19 09:11:49 +00:00
|
|
|
*
|
|
|
|
* The only really gross cases, with regards to memory waste, are for those
|
|
|
|
* items that are just over half the page size. You can get nearly 50% waste,
|
|
|
|
* so you fall back to the memory footprint of the power of two allocator. I
|
|
|
|
* have looked at memory allocation sizes on many of the machines available to
|
|
|
|
* me, and there does not seem to be an abundance of allocations at this range
|
|
|
|
* so at this time it may not make sense to optimize for it. This can, of
|
|
|
|
* course, be solved with dynamic slab sizes.
|
|
|
|
*
|
Bring in mbuma to replace mballoc.
mbuma is an Mbuf & Cluster allocator built on top of a number of
extensions to the UMA framework, all included herein.
Extensions to UMA worth noting:
- Better layering between slab <-> zone caches; introduce
Keg structure which splits off slab cache away from the
zone structure and allows multiple zones to be stacked
on top of a single Keg (single type of slab cache);
perhaps we should look into defining a subset API on
top of the Keg for special use by malloc(9),
for example.
- UMA_ZONE_REFCNT zones can now be added, and reference
counters automagically allocated for them within the end
of the associated slab structures. uma_find_refcnt()
does a kextract to fetch the slab struct reference from
the underlying page, and lookup the corresponding refcnt.
mbuma things worth noting:
- integrates mbuf & cluster allocations with extended UMA
and provides caches for commonly-allocated items; defines
several zones (two primary, one secondary) and two kegs.
- change up certain code paths that always used to do:
m_get() + m_clget() to instead just use m_getcl() and
try to take advantage of the newly defined secondary
Packet zone.
- netstat(1) and systat(1) quickly hacked up to do basic
stat reporting but additional stats work needs to be
done once some other details within UMA have been taken
care of and it becomes clearer to how stats will work
within the modified framework.
From the user perspective, one implication is that the
NMBCLUSTERS compile-time option is no longer used. The
maximum number of clusters is still capped off according
to maxusers, but it can be made unlimited by setting
the kern.ipc.nmbclusters boot-time tunable to zero.
Work should be done to write an appropriate sysctl
handler allowing dynamic tuning of kern.ipc.nmbclusters
at runtime.
Additional things worth noting/known issues (READ):
- One report of 'ips' (ServeRAID) driver acting really
slow in conjunction with mbuma. Need more data.
Latest report is that ips is equally sucking with
and without mbuma.
- Giant leak in NFS code sometimes occurs, can't
reproduce but currently analyzing; brueffer is
able to reproduce but THIS IS NOT an mbuma-specific
problem and currently occurs even WITHOUT mbuma.
- Issues in network locking: there is at least one
code path in the rip code where one or more locks
are acquired and we end up in m_prepend() with
M_WAITOK, which causes WITNESS to whine from within
UMA. Current temporary solution: force all UMA
allocations to be M_NOWAIT from within UMA for now
to avoid deadlocks unless WITNESS is defined and we
can determine with certainty that we're not holding
any locks when we're M_WAITOK.
- I've seen at least one weird socketbuffer empty-but-
mbuf-still-attached panic. I don't believe this
to be related to mbuma but please keep your eyes
open, turn on debugging, and capture crash dumps.
This change removes more code than it adds.
A paper is available detailing the change and considering
various performance issues, it was presented at BSDCan2004:
http://www.unixdaemons.com/~bmilekic/netbuf_bmilekic.pdf
Please read the paper for Future Work and implementation
details, as well as credits.
Testing and Debugging:
rwatson,
brueffer,
Ketrien I. Saihr-Kesenchedra,
...
Reviewed by: Lots of people (for different parts)
2004-05-31 21:46:06 +00:00
|
|
|
* Kegs may serve multiple Zones but by far most of the time they only serve
|
|
|
|
* one. When a Zone is created, a Keg is allocated and setup for it. While
|
|
|
|
* the backing Keg stores slabs, the Zone caches Buckets of items allocated
|
|
|
|
* from the slabs. Each Zone is equipped with an init/fini and ctor/dtor
|
|
|
|
* pair, as well as with its own set of small per-CPU caches, layered above
|
|
|
|
* the Zone's general Bucket cache.
|
|
|
|
*
|
2007-05-09 22:53:34 +00:00
|
|
|
* The PCPU caches are protected by critical sections, and may be accessed
|
|
|
|
* safely only from their associated CPU, while the Zones backed by the same
|
|
|
|
* Keg all share a common Keg lock (to coalesce contention on the backing
|
|
|
|
* slabs). The backing Keg typically only serves one Zone but in the case of
|
|
|
|
* multiple Zones, one of the Zones is considered the Master Zone and all
|
|
|
|
* Zone-related stats from the Keg are done in the Master Zone. For an
|
|
|
|
* example of a Multi-Zone setup, refer to the Mbuf allocation code.
|
2002-03-19 09:11:49 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is the representation for normal (Non OFFPAGE slab)
|
|
|
|
*
|
|
|
|
* i == item
|
|
|
|
* s == slab pointer
|
|
|
|
*
|
|
|
|
* <---------------- Page (UMA_SLAB_SIZE) ------------------>
|
|
|
|
* ___________________________________________________________
|
|
|
|
* | _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ ___________ |
|
|
|
|
* ||i||i||i||i||i||i||i||i||i||i||i||i||i||i||i| |slab header||
|
|
|
|
* ||_||_||_||_||_||_||_||_||_||_||_||_||_||_||_| |___________||
|
|
|
|
* |___________________________________________________________|
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* This is an OFFPAGE slab. These can be larger than UMA_SLAB_SIZE.
|
|
|
|
*
|
|
|
|
* ___________________________________________________________
|
|
|
|
* | _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
|
|
|
|
* ||i||i||i||i||i||i||i||i||i||i||i||i||i||i||i||i||i||i||i| |
|
|
|
|
* ||_||_||_||_||_||_||_||_||_||_||_||_||_||_||_||_||_||_||_| |
|
|
|
|
* |___________________________________________________________|
|
|
|
|
* ___________ ^
|
|
|
|
* |slab header| |
|
|
|
|
* |___________|---*
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef VM_UMA_INT_H
|
|
|
|
#define VM_UMA_INT_H
|
|
|
|
|
|
|
|
#define UMA_SLAB_SIZE PAGE_SIZE /* How big are our slabs? */
|
|
|
|
#define UMA_SLAB_MASK (PAGE_SIZE - 1) /* Mask to get back to the page */
|
|
|
|
#define UMA_SLAB_SHIFT PAGE_SHIFT /* Number of bits PAGE_MASK */
|
|
|
|
|
2013-04-08 19:10:45 +00:00
|
|
|
/* Max waste percentage before going to off page slab management */
|
|
|
|
#define UMA_MAX_WASTE 10
|
2002-03-19 09:11:49 +00:00
|
|
|
|
2018-02-07 18:32:51 +00:00
|
|
|
/*
|
2018-11-28 19:17:27 +00:00
|
|
|
* Actual size of uma_slab when it is placed at an end of a page
|
|
|
|
* with pointer sized alignment requirement.
|
2018-02-07 18:32:51 +00:00
|
|
|
*/
|
2018-11-28 19:17:27 +00:00
|
|
|
#define SIZEOF_UMA_SLAB ((sizeof(struct uma_slab) & UMA_ALIGN_PTR) ? \
|
|
|
|
(sizeof(struct uma_slab) & ~UMA_ALIGN_PTR) + \
|
|
|
|
(UMA_ALIGN_PTR + 1) : sizeof(struct uma_slab))
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Size of memory in a not offpage single page slab available for actual items.
|
|
|
|
*/
|
|
|
|
#define UMA_SLAB_SPACE (PAGE_SIZE - SIZEOF_UMA_SLAB)
|
2018-02-07 18:32:51 +00:00
|
|
|
|
2002-03-19 09:11:49 +00:00
|
|
|
/*
|
|
|
|
* I doubt there will be many cases where this is exceeded. This is the initial
|
|
|
|
* size of the hash table for uma_slabs that are managed off page. This hash
|
|
|
|
* does expand by powers of two. Currently it doesn't get smaller.
|
|
|
|
*/
|
|
|
|
#define UMA_HASH_SIZE_INIT 32
|
|
|
|
|
|
|
|
/*
|
|
|
|
* I should investigate other hashing algorithms. This should yield a low
|
|
|
|
* number of collisions if the pages are relatively contiguous.
|
|
|
|
*/
|
|
|
|
|
2013-06-13 21:05:38 +00:00
|
|
|
#define UMA_HASH(h, s) ((((uintptr_t)s) >> UMA_SLAB_SHIFT) & (h)->uh_hashmask)
|
2002-03-19 09:11:49 +00:00
|
|
|
|
|
|
|
#define UMA_HASH_INSERT(h, s, mem) \
|
|
|
|
SLIST_INSERT_HEAD(&(h)->uh_slab_hash[UMA_HASH((h), \
|
2009-12-05 17:45:56 +00:00
|
|
|
(mem))], (s), us_hlink)
|
2002-03-19 09:11:49 +00:00
|
|
|
#define UMA_HASH_REMOVE(h, s, mem) \
|
|
|
|
SLIST_REMOVE(&(h)->uh_slab_hash[UMA_HASH((h), \
|
2009-12-05 17:45:56 +00:00
|
|
|
(mem))], (s), uma_slab, us_hlink)
|
2002-03-19 09:11:49 +00:00
|
|
|
|
|
|
|
/* Hash table for freed address -> slab translation */
|
|
|
|
|
|
|
|
SLIST_HEAD(slabhead, uma_slab);
|
|
|
|
|
|
|
|
struct uma_hash {
|
|
|
|
struct slabhead *uh_slab_hash; /* Hash table for slabs */
|
2019-02-12 04:33:05 +00:00
|
|
|
u_int uh_hashsize; /* Current size of the hash table */
|
|
|
|
u_int uh_hashmask; /* Mask used during hashing */
|
2002-03-19 09:11:49 +00:00
|
|
|
};
|
|
|
|
|
2010-03-17 21:18:28 +00:00
|
|
|
/*
|
|
|
|
* align field or structure to cache line
|
|
|
|
*/
|
2018-06-04 15:44:17 +00:00
|
|
|
#if defined(__amd64__) || defined(__powerpc64__)
|
2018-05-11 07:04:57 +00:00
|
|
|
#define UMA_ALIGN __aligned(128)
|
2010-03-22 22:39:32 +00:00
|
|
|
#else
|
2010-03-18 20:30:25 +00:00
|
|
|
#define UMA_ALIGN
|
2010-03-22 22:39:32 +00:00
|
|
|
#endif
|
2010-03-17 21:18:28 +00:00
|
|
|
|
2002-03-19 09:11:49 +00:00
|
|
|
/*
|
|
|
|
* Structures for per cpu queues.
|
|
|
|
*/
|
|
|
|
|
|
|
|
struct uma_bucket {
|
2019-09-01 22:22:43 +00:00
|
|
|
TAILQ_ENTRY(uma_bucket) ub_link; /* Link into the zone */
|
2018-08-24 18:47:50 +00:00
|
|
|
int16_t ub_cnt; /* Count of items in bucket. */
|
2003-09-19 06:26:45 +00:00
|
|
|
int16_t ub_entries; /* Max items. */
|
|
|
|
void *ub_bucket[]; /* actual allocation storage */
|
2010-03-22 22:39:32 +00:00
|
|
|
};
|
2002-03-19 09:11:49 +00:00
|
|
|
|
|
|
|
typedef struct uma_bucket * uma_bucket_t;
|
|
|
|
|
|
|
|
struct uma_cache {
|
|
|
|
uma_bucket_t uc_freebucket; /* Bucket we're freeing to */
|
|
|
|
uma_bucket_t uc_allocbucket; /* Bucket to allocate from */
|
2019-08-06 21:50:34 +00:00
|
|
|
uma_bucket_t uc_crossbucket; /* cross domain bucket */
|
2013-04-09 17:43:48 +00:00
|
|
|
uint64_t uc_allocs; /* Count of allocations */
|
|
|
|
uint64_t uc_frees; /* Count of frees */
|
2010-03-17 21:18:28 +00:00
|
|
|
} UMA_ALIGN;
|
2002-03-19 09:11:49 +00:00
|
|
|
|
|
|
|
typedef struct uma_cache * uma_cache_t;
|
|
|
|
|
2018-01-12 23:25:05 +00:00
|
|
|
/*
|
|
|
|
* Per-domain memory list. Embedded in the kegs.
|
|
|
|
*/
|
|
|
|
struct uma_domain {
|
|
|
|
LIST_HEAD(,uma_slab) ud_part_slab; /* partially allocated slabs */
|
|
|
|
LIST_HEAD(,uma_slab) ud_free_slab; /* empty slab list */
|
|
|
|
LIST_HEAD(,uma_slab) ud_full_slab; /* full slabs */
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef struct uma_domain * uma_domain_t;
|
|
|
|
|
Bring in mbuma to replace mballoc.
mbuma is an Mbuf & Cluster allocator built on top of a number of
extensions to the UMA framework, all included herein.
Extensions to UMA worth noting:
- Better layering between slab <-> zone caches; introduce
Keg structure which splits off slab cache away from the
zone structure and allows multiple zones to be stacked
on top of a single Keg (single type of slab cache);
perhaps we should look into defining a subset API on
top of the Keg for special use by malloc(9),
for example.
- UMA_ZONE_REFCNT zones can now be added, and reference
counters automagically allocated for them within the end
of the associated slab structures. uma_find_refcnt()
does a kextract to fetch the slab struct reference from
the underlying page, and lookup the corresponding refcnt.
mbuma things worth noting:
- integrates mbuf & cluster allocations with extended UMA
and provides caches for commonly-allocated items; defines
several zones (two primary, one secondary) and two kegs.
- change up certain code paths that always used to do:
m_get() + m_clget() to instead just use m_getcl() and
try to take advantage of the newly defined secondary
Packet zone.
- netstat(1) and systat(1) quickly hacked up to do basic
stat reporting but additional stats work needs to be
done once some other details within UMA have been taken
care of and it becomes clearer to how stats will work
within the modified framework.
From the user perspective, one implication is that the
NMBCLUSTERS compile-time option is no longer used. The
maximum number of clusters is still capped off according
to maxusers, but it can be made unlimited by setting
the kern.ipc.nmbclusters boot-time tunable to zero.
Work should be done to write an appropriate sysctl
handler allowing dynamic tuning of kern.ipc.nmbclusters
at runtime.
Additional things worth noting/known issues (READ):
- One report of 'ips' (ServeRAID) driver acting really
slow in conjunction with mbuma. Need more data.
Latest report is that ips is equally sucking with
and without mbuma.
- Giant leak in NFS code sometimes occurs, can't
reproduce but currently analyzing; brueffer is
able to reproduce but THIS IS NOT an mbuma-specific
problem and currently occurs even WITHOUT mbuma.
- Issues in network locking: there is at least one
code path in the rip code where one or more locks
are acquired and we end up in m_prepend() with
M_WAITOK, which causes WITNESS to whine from within
UMA. Current temporary solution: force all UMA
allocations to be M_NOWAIT from within UMA for now
to avoid deadlocks unless WITNESS is defined and we
can determine with certainty that we're not holding
any locks when we're M_WAITOK.
- I've seen at least one weird socketbuffer empty-but-
mbuf-still-attached panic. I don't believe this
to be related to mbuma but please keep your eyes
open, turn on debugging, and capture crash dumps.
This change removes more code than it adds.
A paper is available detailing the change and considering
various performance issues, it was presented at BSDCan2004:
http://www.unixdaemons.com/~bmilekic/netbuf_bmilekic.pdf
Please read the paper for Future Work and implementation
details, as well as credits.
Testing and Debugging:
rwatson,
brueffer,
Ketrien I. Saihr-Kesenchedra,
...
Reviewed by: Lots of people (for different parts)
2004-05-31 21:46:06 +00:00
|
|
|
/*
|
|
|
|
* Keg management structure
|
|
|
|
*
|
|
|
|
* TODO: Optimize for cache line size
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
struct uma_keg {
|
o Move zone limit from keg level up to zone level. This means that now
two zones sharing a keg may have different limits. Now this is going
to work:
zone = uma_zcreate();
uma_zone_set_max(zone, limit);
zone2 = uma_zsecond_create(zone);
uma_zone_set_max(zone2, limit2);
Kegs no longer have uk_maxpages field, but zones have uz_items. When
set, it may be rounded up to minimum possible CPU bucket cache size.
For small limits bucket cache can also be reconfigured to be smaller.
Counter uz_items is updated whenever items transition from keg to a
bucket cache or directly to a consumer. If zone has uz_maxitems set and
it is reached, then we are going to sleep.
o Since new limits don't play well with multi-keg zones, remove them. The
idea of multi-keg zones was introduced exactly 10 years ago, and never
have had a practical usage. In discussion with Jeff we came to a wild
agreement that if we ever want to reintroduce the idea of a smart allocator
that would be able to choose between two (or more) totally different
backing stores, that choice should be made one level higher than UMA,
e.g. in malloc(9) or in mget(), or whatever and choice should be controlled
by the caller.
o Sleeping code is improved to account number of sleepers and wake them one
by one, to avoid thundering herd problem.
o Flag UMA_ZONE_NOBUCKETCACHE removed, instead uma_zone_set_maxcache()
KPI added. Having no bucket cache basically means setting maxcache to 0.
o Now with many fields added and many removed (no multi-keg zones!) make
sure that struct uma_zone is perfectly aligned.
Reviewed by: markj, jeff
Tested by: pho
Differential Revision: https://reviews.freebsd.org/D17773
2019-01-15 00:02:06 +00:00
|
|
|
struct mtx uk_lock; /* Lock for the keg must be first.
|
|
|
|
* See shared uz_keg/uz_lockptr
|
|
|
|
* member of struct uma_zone. */
|
Bring in mbuma to replace mballoc.
mbuma is an Mbuf & Cluster allocator built on top of a number of
extensions to the UMA framework, all included herein.
Extensions to UMA worth noting:
- Better layering between slab <-> zone caches; introduce
Keg structure which splits off slab cache away from the
zone structure and allows multiple zones to be stacked
on top of a single Keg (single type of slab cache);
perhaps we should look into defining a subset API on
top of the Keg for special use by malloc(9),
for example.
- UMA_ZONE_REFCNT zones can now be added, and reference
counters automagically allocated for them within the end
of the associated slab structures. uma_find_refcnt()
does a kextract to fetch the slab struct reference from
the underlying page, and lookup the corresponding refcnt.
mbuma things worth noting:
- integrates mbuf & cluster allocations with extended UMA
and provides caches for commonly-allocated items; defines
several zones (two primary, one secondary) and two kegs.
- change up certain code paths that always used to do:
m_get() + m_clget() to instead just use m_getcl() and
try to take advantage of the newly defined secondary
Packet zone.
- netstat(1) and systat(1) quickly hacked up to do basic
stat reporting but additional stats work needs to be
done once some other details within UMA have been taken
care of and it becomes clearer to how stats will work
within the modified framework.
From the user perspective, one implication is that the
NMBCLUSTERS compile-time option is no longer used. The
maximum number of clusters is still capped off according
to maxusers, but it can be made unlimited by setting
the kern.ipc.nmbclusters boot-time tunable to zero.
Work should be done to write an appropriate sysctl
handler allowing dynamic tuning of kern.ipc.nmbclusters
at runtime.
Additional things worth noting/known issues (READ):
- One report of 'ips' (ServeRAID) driver acting really
slow in conjunction with mbuma. Need more data.
Latest report is that ips is equally sucking with
and without mbuma.
- Giant leak in NFS code sometimes occurs, can't
reproduce but currently analyzing; brueffer is
able to reproduce but THIS IS NOT an mbuma-specific
problem and currently occurs even WITHOUT mbuma.
- Issues in network locking: there is at least one
code path in the rip code where one or more locks
are acquired and we end up in m_prepend() with
M_WAITOK, which causes WITNESS to whine from within
UMA. Current temporary solution: force all UMA
allocations to be M_NOWAIT from within UMA for now
to avoid deadlocks unless WITNESS is defined and we
can determine with certainty that we're not holding
any locks when we're M_WAITOK.
- I've seen at least one weird socketbuffer empty-but-
mbuf-still-attached panic. I don't believe this
to be related to mbuma but please keep your eyes
open, turn on debugging, and capture crash dumps.
This change removes more code than it adds.
A paper is available detailing the change and considering
various performance issues, it was presented at BSDCan2004:
http://www.unixdaemons.com/~bmilekic/netbuf_bmilekic.pdf
Please read the paper for Future Work and implementation
details, as well as credits.
Testing and Debugging:
rwatson,
brueffer,
Ketrien I. Saihr-Kesenchedra,
...
Reviewed by: Lots of people (for different parts)
2004-05-31 21:46:06 +00:00
|
|
|
struct uma_hash uk_hash;
|
|
|
|
LIST_HEAD(,uma_zone) uk_zones; /* Keg's zones */
|
|
|
|
|
2018-10-24 16:41:47 +00:00
|
|
|
struct domainset_ref uk_dr; /* Domain selection policy. */
|
2013-04-09 17:43:48 +00:00
|
|
|
uint32_t uk_align; /* Alignment mask */
|
|
|
|
uint32_t uk_pages; /* Total page count */
|
|
|
|
uint32_t uk_free; /* Count of items free in slabs */
|
2013-06-26 00:57:38 +00:00
|
|
|
uint32_t uk_reserve; /* Number of reserved items. */
|
2013-04-09 17:43:48 +00:00
|
|
|
uint32_t uk_size; /* Requested size of each item */
|
|
|
|
uint32_t uk_rsize; /* Real size of each item */
|
Bring in mbuma to replace mballoc.
mbuma is an Mbuf & Cluster allocator built on top of a number of
extensions to the UMA framework, all included herein.
Extensions to UMA worth noting:
- Better layering between slab <-> zone caches; introduce
Keg structure which splits off slab cache away from the
zone structure and allows multiple zones to be stacked
on top of a single Keg (single type of slab cache);
perhaps we should look into defining a subset API on
top of the Keg for special use by malloc(9),
for example.
- UMA_ZONE_REFCNT zones can now be added, and reference
counters automagically allocated for them within the end
of the associated slab structures. uma_find_refcnt()
does a kextract to fetch the slab struct reference from
the underlying page, and lookup the corresponding refcnt.
mbuma things worth noting:
- integrates mbuf & cluster allocations with extended UMA
and provides caches for commonly-allocated items; defines
several zones (two primary, one secondary) and two kegs.
- change up certain code paths that always used to do:
m_get() + m_clget() to instead just use m_getcl() and
try to take advantage of the newly defined secondary
Packet zone.
- netstat(1) and systat(1) quickly hacked up to do basic
stat reporting but additional stats work needs to be
done once some other details within UMA have been taken
care of and it becomes clearer to how stats will work
within the modified framework.
From the user perspective, one implication is that the
NMBCLUSTERS compile-time option is no longer used. The
maximum number of clusters is still capped off according
to maxusers, but it can be made unlimited by setting
the kern.ipc.nmbclusters boot-time tunable to zero.
Work should be done to write an appropriate sysctl
handler allowing dynamic tuning of kern.ipc.nmbclusters
at runtime.
Additional things worth noting/known issues (READ):
- One report of 'ips' (ServeRAID) driver acting really
slow in conjunction with mbuma. Need more data.
Latest report is that ips is equally sucking with
and without mbuma.
- Giant leak in NFS code sometimes occurs, can't
reproduce but currently analyzing; brueffer is
able to reproduce but THIS IS NOT an mbuma-specific
problem and currently occurs even WITHOUT mbuma.
- Issues in network locking: there is at least one
code path in the rip code where one or more locks
are acquired and we end up in m_prepend() with
M_WAITOK, which causes WITNESS to whine from within
UMA. Current temporary solution: force all UMA
allocations to be M_NOWAIT from within UMA for now
to avoid deadlocks unless WITNESS is defined and we
can determine with certainty that we're not holding
any locks when we're M_WAITOK.
- I've seen at least one weird socketbuffer empty-but-
mbuf-still-attached panic. I don't believe this
to be related to mbuma but please keep your eyes
open, turn on debugging, and capture crash dumps.
This change removes more code than it adds.
A paper is available detailing the change and considering
various performance issues, it was presented at BSDCan2004:
http://www.unixdaemons.com/~bmilekic/netbuf_bmilekic.pdf
Please read the paper for Future Work and implementation
details, as well as credits.
Testing and Debugging:
rwatson,
brueffer,
Ketrien I. Saihr-Kesenchedra,
...
Reviewed by: Lots of people (for different parts)
2004-05-31 21:46:06 +00:00
|
|
|
|
|
|
|
uma_init uk_init; /* Keg's init routine */
|
|
|
|
uma_fini uk_fini; /* Keg's fini routine */
|
|
|
|
uma_alloc uk_allocf; /* Allocation function */
|
|
|
|
uma_free uk_freef; /* Free routine */
|
|
|
|
|
2013-02-26 23:35:27 +00:00
|
|
|
u_long uk_offset; /* Next free offset from base KVA */
|
|
|
|
vm_offset_t uk_kva; /* Zone base KVA */
|
Bring in mbuma to replace mballoc.
mbuma is an Mbuf & Cluster allocator built on top of a number of
extensions to the UMA framework, all included herein.
Extensions to UMA worth noting:
- Better layering between slab <-> zone caches; introduce
Keg structure which splits off slab cache away from the
zone structure and allows multiple zones to be stacked
on top of a single Keg (single type of slab cache);
perhaps we should look into defining a subset API on
top of the Keg for special use by malloc(9),
for example.
- UMA_ZONE_REFCNT zones can now be added, and reference
counters automagically allocated for them within the end
of the associated slab structures. uma_find_refcnt()
does a kextract to fetch the slab struct reference from
the underlying page, and lookup the corresponding refcnt.
mbuma things worth noting:
- integrates mbuf & cluster allocations with extended UMA
and provides caches for commonly-allocated items; defines
several zones (two primary, one secondary) and two kegs.
- change up certain code paths that always used to do:
m_get() + m_clget() to instead just use m_getcl() and
try to take advantage of the newly defined secondary
Packet zone.
- netstat(1) and systat(1) quickly hacked up to do basic
stat reporting but additional stats work needs to be
done once some other details within UMA have been taken
care of and it becomes clearer to how stats will work
within the modified framework.
From the user perspective, one implication is that the
NMBCLUSTERS compile-time option is no longer used. The
maximum number of clusters is still capped off according
to maxusers, but it can be made unlimited by setting
the kern.ipc.nmbclusters boot-time tunable to zero.
Work should be done to write an appropriate sysctl
handler allowing dynamic tuning of kern.ipc.nmbclusters
at runtime.
Additional things worth noting/known issues (READ):
- One report of 'ips' (ServeRAID) driver acting really
slow in conjunction with mbuma. Need more data.
Latest report is that ips is equally sucking with
and without mbuma.
- Giant leak in NFS code sometimes occurs, can't
reproduce but currently analyzing; brueffer is
able to reproduce but THIS IS NOT an mbuma-specific
problem and currently occurs even WITHOUT mbuma.
- Issues in network locking: there is at least one
code path in the rip code where one or more locks
are acquired and we end up in m_prepend() with
M_WAITOK, which causes WITNESS to whine from within
UMA. Current temporary solution: force all UMA
allocations to be M_NOWAIT from within UMA for now
to avoid deadlocks unless WITNESS is defined and we
can determine with certainty that we're not holding
any locks when we're M_WAITOK.
- I've seen at least one weird socketbuffer empty-but-
mbuf-still-attached panic. I don't believe this
to be related to mbuma but please keep your eyes
open, turn on debugging, and capture crash dumps.
This change removes more code than it adds.
A paper is available detailing the change and considering
various performance issues, it was presented at BSDCan2004:
http://www.unixdaemons.com/~bmilekic/netbuf_bmilekic.pdf
Please read the paper for Future Work and implementation
details, as well as credits.
Testing and Debugging:
rwatson,
brueffer,
Ketrien I. Saihr-Kesenchedra,
...
Reviewed by: Lots of people (for different parts)
2004-05-31 21:46:06 +00:00
|
|
|
uma_zone_t uk_slabzone; /* Slab zone backing us, if OFFPAGE */
|
|
|
|
|
2017-09-13 21:54:37 +00:00
|
|
|
uint32_t uk_pgoff; /* Offset to uma_slab struct */
|
2013-04-09 17:43:48 +00:00
|
|
|
uint16_t uk_ppera; /* pages per allocation from backend */
|
|
|
|
uint16_t uk_ipers; /* Items per slab */
|
|
|
|
uint32_t uk_flags; /* Internal flags */
|
2013-04-08 19:10:45 +00:00
|
|
|
|
|
|
|
/* Least used fields go to the last cache line. */
|
|
|
|
const char *uk_name; /* Name of creating zone. */
|
|
|
|
LIST_ENTRY(uma_keg) uk_link; /* List of all kegs */
|
2018-01-12 23:25:05 +00:00
|
|
|
|
|
|
|
/* Must be last, variable sized. */
|
|
|
|
struct uma_domain uk_domain[]; /* Keg's slab lists. */
|
Bring in mbuma to replace mballoc.
mbuma is an Mbuf & Cluster allocator built on top of a number of
extensions to the UMA framework, all included herein.
Extensions to UMA worth noting:
- Better layering between slab <-> zone caches; introduce
Keg structure which splits off slab cache away from the
zone structure and allows multiple zones to be stacked
on top of a single Keg (single type of slab cache);
perhaps we should look into defining a subset API on
top of the Keg for special use by malloc(9),
for example.
- UMA_ZONE_REFCNT zones can now be added, and reference
counters automagically allocated for them within the end
of the associated slab structures. uma_find_refcnt()
does a kextract to fetch the slab struct reference from
the underlying page, and lookup the corresponding refcnt.
mbuma things worth noting:
- integrates mbuf & cluster allocations with extended UMA
and provides caches for commonly-allocated items; defines
several zones (two primary, one secondary) and two kegs.
- change up certain code paths that always used to do:
m_get() + m_clget() to instead just use m_getcl() and
try to take advantage of the newly defined secondary
Packet zone.
- netstat(1) and systat(1) quickly hacked up to do basic
stat reporting but additional stats work needs to be
done once some other details within UMA have been taken
care of and it becomes clearer to how stats will work
within the modified framework.
From the user perspective, one implication is that the
NMBCLUSTERS compile-time option is no longer used. The
maximum number of clusters is still capped off according
to maxusers, but it can be made unlimited by setting
the kern.ipc.nmbclusters boot-time tunable to zero.
Work should be done to write an appropriate sysctl
handler allowing dynamic tuning of kern.ipc.nmbclusters
at runtime.
Additional things worth noting/known issues (READ):
- One report of 'ips' (ServeRAID) driver acting really
slow in conjunction with mbuma. Need more data.
Latest report is that ips is equally sucking with
and without mbuma.
- Giant leak in NFS code sometimes occurs, can't
reproduce but currently analyzing; brueffer is
able to reproduce but THIS IS NOT an mbuma-specific
problem and currently occurs even WITHOUT mbuma.
- Issues in network locking: there is at least one
code path in the rip code where one or more locks
are acquired and we end up in m_prepend() with
M_WAITOK, which causes WITNESS to whine from within
UMA. Current temporary solution: force all UMA
allocations to be M_NOWAIT from within UMA for now
to avoid deadlocks unless WITNESS is defined and we
can determine with certainty that we're not holding
any locks when we're M_WAITOK.
- I've seen at least one weird socketbuffer empty-but-
mbuf-still-attached panic. I don't believe this
to be related to mbuma but please keep your eyes
open, turn on debugging, and capture crash dumps.
This change removes more code than it adds.
A paper is available detailing the change and considering
various performance issues, it was presented at BSDCan2004:
http://www.unixdaemons.com/~bmilekic/netbuf_bmilekic.pdf
Please read the paper for Future Work and implementation
details, as well as credits.
Testing and Debugging:
rwatson,
brueffer,
Ketrien I. Saihr-Kesenchedra,
...
Reviewed by: Lots of people (for different parts)
2004-05-31 21:46:06 +00:00
|
|
|
};
|
2009-01-25 09:11:24 +00:00
|
|
|
typedef struct uma_keg * uma_keg_t;
|
Bring in mbuma to replace mballoc.
mbuma is an Mbuf & Cluster allocator built on top of a number of
extensions to the UMA framework, all included herein.
Extensions to UMA worth noting:
- Better layering between slab <-> zone caches; introduce
Keg structure which splits off slab cache away from the
zone structure and allows multiple zones to be stacked
on top of a single Keg (single type of slab cache);
perhaps we should look into defining a subset API on
top of the Keg for special use by malloc(9),
for example.
- UMA_ZONE_REFCNT zones can now be added, and reference
counters automagically allocated for them within the end
of the associated slab structures. uma_find_refcnt()
does a kextract to fetch the slab struct reference from
the underlying page, and lookup the corresponding refcnt.
mbuma things worth noting:
- integrates mbuf & cluster allocations with extended UMA
and provides caches for commonly-allocated items; defines
several zones (two primary, one secondary) and two kegs.
- change up certain code paths that always used to do:
m_get() + m_clget() to instead just use m_getcl() and
try to take advantage of the newly defined secondary
Packet zone.
- netstat(1) and systat(1) quickly hacked up to do basic
stat reporting but additional stats work needs to be
done once some other details within UMA have been taken
care of and it becomes clearer to how stats will work
within the modified framework.
From the user perspective, one implication is that the
NMBCLUSTERS compile-time option is no longer used. The
maximum number of clusters is still capped off according
to maxusers, but it can be made unlimited by setting
the kern.ipc.nmbclusters boot-time tunable to zero.
Work should be done to write an appropriate sysctl
handler allowing dynamic tuning of kern.ipc.nmbclusters
at runtime.
Additional things worth noting/known issues (READ):
- One report of 'ips' (ServeRAID) driver acting really
slow in conjunction with mbuma. Need more data.
Latest report is that ips is equally sucking with
and without mbuma.
- Giant leak in NFS code sometimes occurs, can't
reproduce but currently analyzing; brueffer is
able to reproduce but THIS IS NOT an mbuma-specific
problem and currently occurs even WITHOUT mbuma.
- Issues in network locking: there is at least one
code path in the rip code where one or more locks
are acquired and we end up in m_prepend() with
M_WAITOK, which causes WITNESS to whine from within
UMA. Current temporary solution: force all UMA
allocations to be M_NOWAIT from within UMA for now
to avoid deadlocks unless WITNESS is defined and we
can determine with certainty that we're not holding
any locks when we're M_WAITOK.
- I've seen at least one weird socketbuffer empty-but-
mbuf-still-attached panic. I don't believe this
to be related to mbuma but please keep your eyes
open, turn on debugging, and capture crash dumps.
This change removes more code than it adds.
A paper is available detailing the change and considering
various performance issues, it was presented at BSDCan2004:
http://www.unixdaemons.com/~bmilekic/netbuf_bmilekic.pdf
Please read the paper for Future Work and implementation
details, as well as credits.
Testing and Debugging:
rwatson,
brueffer,
Ketrien I. Saihr-Kesenchedra,
...
Reviewed by: Lots of people (for different parts)
2004-05-31 21:46:06 +00:00
|
|
|
|
2013-06-13 21:05:38 +00:00
|
|
|
/*
|
|
|
|
* Free bits per-slab.
|
|
|
|
*/
|
|
|
|
#define SLAB_SETSIZE (PAGE_SIZE / UMA_SMALLEST_UNIT)
|
|
|
|
BITSET_DEFINE(slabbits, SLAB_SETSIZE);
|
Bring in mbuma to replace mballoc.
mbuma is an Mbuf & Cluster allocator built on top of a number of
extensions to the UMA framework, all included herein.
Extensions to UMA worth noting:
- Better layering between slab <-> zone caches; introduce
Keg structure which splits off slab cache away from the
zone structure and allows multiple zones to be stacked
on top of a single Keg (single type of slab cache);
perhaps we should look into defining a subset API on
top of the Keg for special use by malloc(9),
for example.
- UMA_ZONE_REFCNT zones can now be added, and reference
counters automagically allocated for them within the end
of the associated slab structures. uma_find_refcnt()
does a kextract to fetch the slab struct reference from
the underlying page, and lookup the corresponding refcnt.
mbuma things worth noting:
- integrates mbuf & cluster allocations with extended UMA
and provides caches for commonly-allocated items; defines
several zones (two primary, one secondary) and two kegs.
- change up certain code paths that always used to do:
m_get() + m_clget() to instead just use m_getcl() and
try to take advantage of the newly defined secondary
Packet zone.
- netstat(1) and systat(1) quickly hacked up to do basic
stat reporting but additional stats work needs to be
done once some other details within UMA have been taken
care of and it becomes clearer to how stats will work
within the modified framework.
From the user perspective, one implication is that the
NMBCLUSTERS compile-time option is no longer used. The
maximum number of clusters is still capped off according
to maxusers, but it can be made unlimited by setting
the kern.ipc.nmbclusters boot-time tunable to zero.
Work should be done to write an appropriate sysctl
handler allowing dynamic tuning of kern.ipc.nmbclusters
at runtime.
Additional things worth noting/known issues (READ):
- One report of 'ips' (ServeRAID) driver acting really
slow in conjunction with mbuma. Need more data.
Latest report is that ips is equally sucking with
and without mbuma.
- Giant leak in NFS code sometimes occurs, can't
reproduce but currently analyzing; brueffer is
able to reproduce but THIS IS NOT an mbuma-specific
problem and currently occurs even WITHOUT mbuma.
- Issues in network locking: there is at least one
code path in the rip code where one or more locks
are acquired and we end up in m_prepend() with
M_WAITOK, which causes WITNESS to whine from within
UMA. Current temporary solution: force all UMA
allocations to be M_NOWAIT from within UMA for now
to avoid deadlocks unless WITNESS is defined and we
can determine with certainty that we're not holding
any locks when we're M_WAITOK.
- I've seen at least one weird socketbuffer empty-but-
mbuf-still-attached panic. I don't believe this
to be related to mbuma but please keep your eyes
open, turn on debugging, and capture crash dumps.
This change removes more code than it adds.
A paper is available detailing the change and considering
various performance issues, it was presented at BSDCan2004:
http://www.unixdaemons.com/~bmilekic/netbuf_bmilekic.pdf
Please read the paper for Future Work and implementation
details, as well as credits.
Testing and Debugging:
rwatson,
brueffer,
Ketrien I. Saihr-Kesenchedra,
...
Reviewed by: Lots of people (for different parts)
2004-05-31 21:46:06 +00:00
|
|
|
|
2013-06-13 21:05:38 +00:00
|
|
|
/*
|
|
|
|
* The slab structure manages a single contiguous allocation from backing
|
|
|
|
* store and subdivides it into individually allocatable items.
|
|
|
|
*/
|
|
|
|
struct uma_slab {
|
2019-11-29 03:14:10 +00:00
|
|
|
LIST_ENTRY(uma_slab) us_link; /* slabs in zone */
|
Bring in mbuma to replace mballoc.
mbuma is an Mbuf & Cluster allocator built on top of a number of
extensions to the UMA framework, all included herein.
Extensions to UMA worth noting:
- Better layering between slab <-> zone caches; introduce
Keg structure which splits off slab cache away from the
zone structure and allows multiple zones to be stacked
on top of a single Keg (single type of slab cache);
perhaps we should look into defining a subset API on
top of the Keg for special use by malloc(9),
for example.
- UMA_ZONE_REFCNT zones can now be added, and reference
counters automagically allocated for them within the end
of the associated slab structures. uma_find_refcnt()
does a kextract to fetch the slab struct reference from
the underlying page, and lookup the corresponding refcnt.
mbuma things worth noting:
- integrates mbuf & cluster allocations with extended UMA
and provides caches for commonly-allocated items; defines
several zones (two primary, one secondary) and two kegs.
- change up certain code paths that always used to do:
m_get() + m_clget() to instead just use m_getcl() and
try to take advantage of the newly defined secondary
Packet zone.
- netstat(1) and systat(1) quickly hacked up to do basic
stat reporting but additional stats work needs to be
done once some other details within UMA have been taken
care of and it becomes clearer to how stats will work
within the modified framework.
From the user perspective, one implication is that the
NMBCLUSTERS compile-time option is no longer used. The
maximum number of clusters is still capped off according
to maxusers, but it can be made unlimited by setting
the kern.ipc.nmbclusters boot-time tunable to zero.
Work should be done to write an appropriate sysctl
handler allowing dynamic tuning of kern.ipc.nmbclusters
at runtime.
Additional things worth noting/known issues (READ):
- One report of 'ips' (ServeRAID) driver acting really
slow in conjunction with mbuma. Need more data.
Latest report is that ips is equally sucking with
and without mbuma.
- Giant leak in NFS code sometimes occurs, can't
reproduce but currently analyzing; brueffer is
able to reproduce but THIS IS NOT an mbuma-specific
problem and currently occurs even WITHOUT mbuma.
- Issues in network locking: there is at least one
code path in the rip code where one or more locks
are acquired and we end up in m_prepend() with
M_WAITOK, which causes WITNESS to whine from within
UMA. Current temporary solution: force all UMA
allocations to be M_NOWAIT from within UMA for now
to avoid deadlocks unless WITNESS is defined and we
can determine with certainty that we're not holding
any locks when we're M_WAITOK.
- I've seen at least one weird socketbuffer empty-but-
mbuf-still-attached panic. I don't believe this
to be related to mbuma but please keep your eyes
open, turn on debugging, and capture crash dumps.
This change removes more code than it adds.
A paper is available detailing the change and considering
various performance issues, it was presented at BSDCan2004:
http://www.unixdaemons.com/~bmilekic/netbuf_bmilekic.pdf
Please read the paper for Future Work and implementation
details, as well as credits.
Testing and Debugging:
rwatson,
brueffer,
Ketrien I. Saihr-Kesenchedra,
...
Reviewed by: Lots of people (for different parts)
2004-05-31 21:46:06 +00:00
|
|
|
SLIST_ENTRY(uma_slab) us_hlink; /* Link for hash table */
|
2013-04-09 17:43:48 +00:00
|
|
|
uint8_t *us_data; /* First item */
|
2013-06-13 21:05:38 +00:00
|
|
|
struct slabbits us_free; /* Free bitmask. */
|
|
|
|
#ifdef INVARIANTS
|
|
|
|
struct slabbits us_debugfree; /* Debug bitmask. */
|
|
|
|
#endif
|
2013-04-09 17:43:48 +00:00
|
|
|
uint16_t us_freecount; /* How many are free? */
|
|
|
|
uint8_t us_flags; /* Page flags see uma.h */
|
2018-01-12 23:25:05 +00:00
|
|
|
uint8_t us_domain; /* Backing NUMA domain. */
|
Bring in mbuma to replace mballoc.
mbuma is an Mbuf & Cluster allocator built on top of a number of
extensions to the UMA framework, all included herein.
Extensions to UMA worth noting:
- Better layering between slab <-> zone caches; introduce
Keg structure which splits off slab cache away from the
zone structure and allows multiple zones to be stacked
on top of a single Keg (single type of slab cache);
perhaps we should look into defining a subset API on
top of the Keg for special use by malloc(9),
for example.
- UMA_ZONE_REFCNT zones can now be added, and reference
counters automagically allocated for them within the end
of the associated slab structures. uma_find_refcnt()
does a kextract to fetch the slab struct reference from
the underlying page, and lookup the corresponding refcnt.
mbuma things worth noting:
- integrates mbuf & cluster allocations with extended UMA
and provides caches for commonly-allocated items; defines
several zones (two primary, one secondary) and two kegs.
- change up certain code paths that always used to do:
m_get() + m_clget() to instead just use m_getcl() and
try to take advantage of the newly defined secondary
Packet zone.
- netstat(1) and systat(1) quickly hacked up to do basic
stat reporting but additional stats work needs to be
done once some other details within UMA have been taken
care of and it becomes clearer to how stats will work
within the modified framework.
From the user perspective, one implication is that the
NMBCLUSTERS compile-time option is no longer used. The
maximum number of clusters is still capped off according
to maxusers, but it can be made unlimited by setting
the kern.ipc.nmbclusters boot-time tunable to zero.
Work should be done to write an appropriate sysctl
handler allowing dynamic tuning of kern.ipc.nmbclusters
at runtime.
Additional things worth noting/known issues (READ):
- One report of 'ips' (ServeRAID) driver acting really
slow in conjunction with mbuma. Need more data.
Latest report is that ips is equally sucking with
and without mbuma.
- Giant leak in NFS code sometimes occurs, can't
reproduce but currently analyzing; brueffer is
able to reproduce but THIS IS NOT an mbuma-specific
problem and currently occurs even WITHOUT mbuma.
- Issues in network locking: there is at least one
code path in the rip code where one or more locks
are acquired and we end up in m_prepend() with
M_WAITOK, which causes WITNESS to whine from within
UMA. Current temporary solution: force all UMA
allocations to be M_NOWAIT from within UMA for now
to avoid deadlocks unless WITNESS is defined and we
can determine with certainty that we're not holding
any locks when we're M_WAITOK.
- I've seen at least one weird socketbuffer empty-but-
mbuf-still-attached panic. I don't believe this
to be related to mbuma but please keep your eyes
open, turn on debugging, and capture crash dumps.
This change removes more code than it adds.
A paper is available detailing the change and considering
various performance issues, it was presented at BSDCan2004:
http://www.unixdaemons.com/~bmilekic/netbuf_bmilekic.pdf
Please read the paper for Future Work and implementation
details, as well as credits.
Testing and Debugging:
rwatson,
brueffer,
Ketrien I. Saihr-Kesenchedra,
...
Reviewed by: Lots of people (for different parts)
2004-05-31 21:46:06 +00:00
|
|
|
};
|
|
|
|
|
2018-01-12 23:25:05 +00:00
|
|
|
#if MAXMEMDOM >= 255
|
|
|
|
#error "Slab domain type insufficient"
|
|
|
|
#endif
|
|
|
|
|
Bring in mbuma to replace mballoc.
mbuma is an Mbuf & Cluster allocator built on top of a number of
extensions to the UMA framework, all included herein.
Extensions to UMA worth noting:
- Better layering between slab <-> zone caches; introduce
Keg structure which splits off slab cache away from the
zone structure and allows multiple zones to be stacked
on top of a single Keg (single type of slab cache);
perhaps we should look into defining a subset API on
top of the Keg for special use by malloc(9),
for example.
- UMA_ZONE_REFCNT zones can now be added, and reference
counters automagically allocated for them within the end
of the associated slab structures. uma_find_refcnt()
does a kextract to fetch the slab struct reference from
the underlying page, and lookup the corresponding refcnt.
mbuma things worth noting:
- integrates mbuf & cluster allocations with extended UMA
and provides caches for commonly-allocated items; defines
several zones (two primary, one secondary) and two kegs.
- change up certain code paths that always used to do:
m_get() + m_clget() to instead just use m_getcl() and
try to take advantage of the newly defined secondary
Packet zone.
- netstat(1) and systat(1) quickly hacked up to do basic
stat reporting but additional stats work needs to be
done once some other details within UMA have been taken
care of and it becomes clearer to how stats will work
within the modified framework.
From the user perspective, one implication is that the
NMBCLUSTERS compile-time option is no longer used. The
maximum number of clusters is still capped off according
to maxusers, but it can be made unlimited by setting
the kern.ipc.nmbclusters boot-time tunable to zero.
Work should be done to write an appropriate sysctl
handler allowing dynamic tuning of kern.ipc.nmbclusters
at runtime.
Additional things worth noting/known issues (READ):
- One report of 'ips' (ServeRAID) driver acting really
slow in conjunction with mbuma. Need more data.
Latest report is that ips is equally sucking with
and without mbuma.
- Giant leak in NFS code sometimes occurs, can't
reproduce but currently analyzing; brueffer is
able to reproduce but THIS IS NOT an mbuma-specific
problem and currently occurs even WITHOUT mbuma.
- Issues in network locking: there is at least one
code path in the rip code where one or more locks
are acquired and we end up in m_prepend() with
M_WAITOK, which causes WITNESS to whine from within
UMA. Current temporary solution: force all UMA
allocations to be M_NOWAIT from within UMA for now
to avoid deadlocks unless WITNESS is defined and we
can determine with certainty that we're not holding
any locks when we're M_WAITOK.
- I've seen at least one weird socketbuffer empty-but-
mbuf-still-attached panic. I don't believe this
to be related to mbuma but please keep your eyes
open, turn on debugging, and capture crash dumps.
This change removes more code than it adds.
A paper is available detailing the change and considering
various performance issues, it was presented at BSDCan2004:
http://www.unixdaemons.com/~bmilekic/netbuf_bmilekic.pdf
Please read the paper for Future Work and implementation
details, as well as credits.
Testing and Debugging:
rwatson,
brueffer,
Ketrien I. Saihr-Kesenchedra,
...
Reviewed by: Lots of people (for different parts)
2004-05-31 21:46:06 +00:00
|
|
|
typedef struct uma_slab * uma_slab_t;
|
2009-01-25 09:11:24 +00:00
|
|
|
|
2019-09-01 22:22:43 +00:00
|
|
|
TAILQ_HEAD(uma_bucketlist, uma_bucket);
|
|
|
|
|
2018-01-12 23:25:05 +00:00
|
|
|
struct uma_zone_domain {
|
2019-09-01 22:22:43 +00:00
|
|
|
struct uma_bucketlist uzd_buckets; /* full buckets */
|
2018-11-13 19:44:40 +00:00
|
|
|
long uzd_nitems; /* total item count */
|
|
|
|
long uzd_imax; /* maximum item count this period */
|
|
|
|
long uzd_imin; /* minimum item count this period */
|
|
|
|
long uzd_wss; /* working set size estimate */
|
2018-01-12 23:25:05 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
typedef struct uma_zone_domain * uma_zone_domain_t;
|
|
|
|
|
2002-03-19 09:11:49 +00:00
|
|
|
/*
|
|
|
|
* Zone management structure
|
|
|
|
*
|
|
|
|
* TODO: Optimize for cache line size
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
struct uma_zone {
|
2018-06-23 08:10:09 +00:00
|
|
|
/* Offset 0, used in alloc/free fast/medium fast path and const. */
|
o Move zone limit from keg level up to zone level. This means that now
two zones sharing a keg may have different limits. Now this is going
to work:
zone = uma_zcreate();
uma_zone_set_max(zone, limit);
zone2 = uma_zsecond_create(zone);
uma_zone_set_max(zone2, limit2);
Kegs no longer have uk_maxpages field, but zones have uz_items. When
set, it may be rounded up to minimum possible CPU bucket cache size.
For small limits bucket cache can also be reconfigured to be smaller.
Counter uz_items is updated whenever items transition from keg to a
bucket cache or directly to a consumer. If zone has uz_maxitems set and
it is reached, then we are going to sleep.
o Since new limits don't play well with multi-keg zones, remove them. The
idea of multi-keg zones was introduced exactly 10 years ago, and never
have had a practical usage. In discussion with Jeff we came to a wild
agreement that if we ever want to reintroduce the idea of a smart allocator
that would be able to choose between two (or more) totally different
backing stores, that choice should be made one level higher than UMA,
e.g. in malloc(9) or in mget(), or whatever and choice should be controlled
by the caller.
o Sleeping code is improved to account number of sleepers and wake them one
by one, to avoid thundering herd problem.
o Flag UMA_ZONE_NOBUCKETCACHE removed, instead uma_zone_set_maxcache()
KPI added. Having no bucket cache basically means setting maxcache to 0.
o Now with many fields added and many removed (no multi-keg zones!) make
sure that struct uma_zone is perfectly aligned.
Reviewed by: markj, jeff
Tested by: pho
Differential Revision: https://reviews.freebsd.org/D17773
2019-01-15 00:02:06 +00:00
|
|
|
union {
|
|
|
|
uma_keg_t uz_keg; /* This zone's keg */
|
|
|
|
struct mtx *uz_lockptr; /* To keg or to self */
|
|
|
|
};
|
2018-01-12 23:25:05 +00:00
|
|
|
struct uma_zone_domain *uz_domain; /* per-domain buckets */
|
2018-06-23 08:10:09 +00:00
|
|
|
uint32_t uz_flags; /* Flags inherited from kegs */
|
|
|
|
uint32_t uz_size; /* Size inherited from kegs */
|
2002-03-19 09:11:49 +00:00
|
|
|
uma_ctor uz_ctor; /* Constructor for each allocation */
|
|
|
|
uma_dtor uz_dtor; /* Destructor */
|
o Move zone limit from keg level up to zone level. This means that now
two zones sharing a keg may have different limits. Now this is going
to work:
zone = uma_zcreate();
uma_zone_set_max(zone, limit);
zone2 = uma_zsecond_create(zone);
uma_zone_set_max(zone2, limit2);
Kegs no longer have uk_maxpages field, but zones have uz_items. When
set, it may be rounded up to minimum possible CPU bucket cache size.
For small limits bucket cache can also be reconfigured to be smaller.
Counter uz_items is updated whenever items transition from keg to a
bucket cache or directly to a consumer. If zone has uz_maxitems set and
it is reached, then we are going to sleep.
o Since new limits don't play well with multi-keg zones, remove them. The
idea of multi-keg zones was introduced exactly 10 years ago, and never
have had a practical usage. In discussion with Jeff we came to a wild
agreement that if we ever want to reintroduce the idea of a smart allocator
that would be able to choose between two (or more) totally different
backing stores, that choice should be made one level higher than UMA,
e.g. in malloc(9) or in mget(), or whatever and choice should be controlled
by the caller.
o Sleeping code is improved to account number of sleepers and wake them one
by one, to avoid thundering herd problem.
o Flag UMA_ZONE_NOBUCKETCACHE removed, instead uma_zone_set_maxcache()
KPI added. Having no bucket cache basically means setting maxcache to 0.
o Now with many fields added and many removed (no multi-keg zones!) make
sure that struct uma_zone is perfectly aligned.
Reviewed by: markj, jeff
Tested by: pho
Differential Revision: https://reviews.freebsd.org/D17773
2019-01-15 00:02:06 +00:00
|
|
|
uint64_t uz_items; /* Total items count */
|
|
|
|
uint64_t uz_max_items; /* Maximum number of items to alloc */
|
|
|
|
uint32_t uz_sleepers; /* Number of sleepers on memory */
|
2019-11-28 00:19:09 +00:00
|
|
|
uint16_t uz_bucket_size; /* Number of items in full bucket */
|
|
|
|
uint16_t uz_bucket_size_max; /* Maximum number of bucket items */
|
2018-06-23 08:10:09 +00:00
|
|
|
|
|
|
|
/* Offset 64, used in bucket replenish. */
|
2013-06-17 03:43:47 +00:00
|
|
|
uma_import uz_import; /* Import new memory to cache. */
|
|
|
|
uma_release uz_release; /* Release memory from cache. */
|
|
|
|
void *uz_arg; /* Import/release argument. */
|
o Move zone limit from keg level up to zone level. This means that now
two zones sharing a keg may have different limits. Now this is going
to work:
zone = uma_zcreate();
uma_zone_set_max(zone, limit);
zone2 = uma_zsecond_create(zone);
uma_zone_set_max(zone2, limit2);
Kegs no longer have uk_maxpages field, but zones have uz_items. When
set, it may be rounded up to minimum possible CPU bucket cache size.
For small limits bucket cache can also be reconfigured to be smaller.
Counter uz_items is updated whenever items transition from keg to a
bucket cache or directly to a consumer. If zone has uz_maxitems set and
it is reached, then we are going to sleep.
o Since new limits don't play well with multi-keg zones, remove them. The
idea of multi-keg zones was introduced exactly 10 years ago, and never
have had a practical usage. In discussion with Jeff we came to a wild
agreement that if we ever want to reintroduce the idea of a smart allocator
that would be able to choose between two (or more) totally different
backing stores, that choice should be made one level higher than UMA,
e.g. in malloc(9) or in mget(), or whatever and choice should be controlled
by the caller.
o Sleeping code is improved to account number of sleepers and wake them one
by one, to avoid thundering herd problem.
o Flag UMA_ZONE_NOBUCKETCACHE removed, instead uma_zone_set_maxcache()
KPI added. Having no bucket cache basically means setting maxcache to 0.
o Now with many fields added and many removed (no multi-keg zones!) make
sure that struct uma_zone is perfectly aligned.
Reviewed by: markj, jeff
Tested by: pho
Differential Revision: https://reviews.freebsd.org/D17773
2019-01-15 00:02:06 +00:00
|
|
|
uma_init uz_init; /* Initializer for each item */
|
|
|
|
uma_fini uz_fini; /* Finalizer for each item. */
|
2019-02-07 03:55:05 +00:00
|
|
|
void *uz_spare;
|
o Move zone limit from keg level up to zone level. This means that now
two zones sharing a keg may have different limits. Now this is going
to work:
zone = uma_zcreate();
uma_zone_set_max(zone, limit);
zone2 = uma_zsecond_create(zone);
uma_zone_set_max(zone2, limit2);
Kegs no longer have uk_maxpages field, but zones have uz_items. When
set, it may be rounded up to minimum possible CPU bucket cache size.
For small limits bucket cache can also be reconfigured to be smaller.
Counter uz_items is updated whenever items transition from keg to a
bucket cache or directly to a consumer. If zone has uz_maxitems set and
it is reached, then we are going to sleep.
o Since new limits don't play well with multi-keg zones, remove them. The
idea of multi-keg zones was introduced exactly 10 years ago, and never
have had a practical usage. In discussion with Jeff we came to a wild
agreement that if we ever want to reintroduce the idea of a smart allocator
that would be able to choose between two (or more) totally different
backing stores, that choice should be made one level higher than UMA,
e.g. in malloc(9) or in mget(), or whatever and choice should be controlled
by the caller.
o Sleeping code is improved to account number of sleepers and wake them one
by one, to avoid thundering herd problem.
o Flag UMA_ZONE_NOBUCKETCACHE removed, instead uma_zone_set_maxcache()
KPI added. Having no bucket cache basically means setting maxcache to 0.
o Now with many fields added and many removed (no multi-keg zones!) make
sure that struct uma_zone is perfectly aligned.
Reviewed by: markj, jeff
Tested by: pho
Differential Revision: https://reviews.freebsd.org/D17773
2019-01-15 00:02:06 +00:00
|
|
|
uint64_t uz_bkt_count; /* Items in bucket cache */
|
|
|
|
uint64_t uz_bkt_max; /* Maximum bucket cache size */
|
Bring in mbuma to replace mballoc.
mbuma is an Mbuf & Cluster allocator built on top of a number of
extensions to the UMA framework, all included herein.
Extensions to UMA worth noting:
- Better layering between slab <-> zone caches; introduce
Keg structure which splits off slab cache away from the
zone structure and allows multiple zones to be stacked
on top of a single Keg (single type of slab cache);
perhaps we should look into defining a subset API on
top of the Keg for special use by malloc(9),
for example.
- UMA_ZONE_REFCNT zones can now be added, and reference
counters automagically allocated for them within the end
of the associated slab structures. uma_find_refcnt()
does a kextract to fetch the slab struct reference from
the underlying page, and lookup the corresponding refcnt.
mbuma things worth noting:
- integrates mbuf & cluster allocations with extended UMA
and provides caches for commonly-allocated items; defines
several zones (two primary, one secondary) and two kegs.
- change up certain code paths that always used to do:
m_get() + m_clget() to instead just use m_getcl() and
try to take advantage of the newly defined secondary
Packet zone.
- netstat(1) and systat(1) quickly hacked up to do basic
stat reporting but additional stats work needs to be
done once some other details within UMA have been taken
care of and it becomes clearer to how stats will work
within the modified framework.
From the user perspective, one implication is that the
NMBCLUSTERS compile-time option is no longer used. The
maximum number of clusters is still capped off according
to maxusers, but it can be made unlimited by setting
the kern.ipc.nmbclusters boot-time tunable to zero.
Work should be done to write an appropriate sysctl
handler allowing dynamic tuning of kern.ipc.nmbclusters
at runtime.
Additional things worth noting/known issues (READ):
- One report of 'ips' (ServeRAID) driver acting really
slow in conjunction with mbuma. Need more data.
Latest report is that ips is equally sucking with
and without mbuma.
- Giant leak in NFS code sometimes occurs, can't
reproduce but currently analyzing; brueffer is
able to reproduce but THIS IS NOT an mbuma-specific
problem and currently occurs even WITHOUT mbuma.
- Issues in network locking: there is at least one
code path in the rip code where one or more locks
are acquired and we end up in m_prepend() with
M_WAITOK, which causes WITNESS to whine from within
UMA. Current temporary solution: force all UMA
allocations to be M_NOWAIT from within UMA for now
to avoid deadlocks unless WITNESS is defined and we
can determine with certainty that we're not holding
any locks when we're M_WAITOK.
- I've seen at least one weird socketbuffer empty-but-
mbuf-still-attached panic. I don't believe this
to be related to mbuma but please keep your eyes
open, turn on debugging, and capture crash dumps.
This change removes more code than it adds.
A paper is available detailing the change and considering
various performance issues, it was presented at BSDCan2004:
http://www.unixdaemons.com/~bmilekic/netbuf_bmilekic.pdf
Please read the paper for Future Work and implementation
details, as well as credits.
Testing and Debugging:
rwatson,
brueffer,
Ketrien I. Saihr-Kesenchedra,
...
Reviewed by: Lots of people (for different parts)
2004-05-31 21:46:06 +00:00
|
|
|
|
2018-06-23 08:10:09 +00:00
|
|
|
/* Offset 128 Rare. */
|
|
|
|
/*
|
|
|
|
* The lock is placed here to avoid adjacent line prefetcher
|
|
|
|
* in fast paths and to take up space near infrequently accessed
|
|
|
|
* members to reduce alignment overhead.
|
|
|
|
*/
|
|
|
|
struct mtx uz_lock; /* Lock for the zone */
|
o Move zone limit from keg level up to zone level. This means that now
two zones sharing a keg may have different limits. Now this is going
to work:
zone = uma_zcreate();
uma_zone_set_max(zone, limit);
zone2 = uma_zsecond_create(zone);
uma_zone_set_max(zone2, limit2);
Kegs no longer have uk_maxpages field, but zones have uz_items. When
set, it may be rounded up to minimum possible CPU bucket cache size.
For small limits bucket cache can also be reconfigured to be smaller.
Counter uz_items is updated whenever items transition from keg to a
bucket cache or directly to a consumer. If zone has uz_maxitems set and
it is reached, then we are going to sleep.
o Since new limits don't play well with multi-keg zones, remove them. The
idea of multi-keg zones was introduced exactly 10 years ago, and never
have had a practical usage. In discussion with Jeff we came to a wild
agreement that if we ever want to reintroduce the idea of a smart allocator
that would be able to choose between two (or more) totally different
backing stores, that choice should be made one level higher than UMA,
e.g. in malloc(9) or in mget(), or whatever and choice should be controlled
by the caller.
o Sleeping code is improved to account number of sleepers and wake them one
by one, to avoid thundering herd problem.
o Flag UMA_ZONE_NOBUCKETCACHE removed, instead uma_zone_set_maxcache()
KPI added. Having no bucket cache basically means setting maxcache to 0.
o Now with many fields added and many removed (no multi-keg zones!) make
sure that struct uma_zone is perfectly aligned.
Reviewed by: markj, jeff
Tested by: pho
Differential Revision: https://reviews.freebsd.org/D17773
2019-01-15 00:02:06 +00:00
|
|
|
LIST_ENTRY(uma_zone) uz_link; /* List of all zones in keg */
|
|
|
|
const char *uz_name; /* Text name of the zone */
|
2015-12-20 02:05:33 +00:00
|
|
|
/* The next two fields are used to print a rate-limited warnings. */
|
2012-12-07 22:27:13 +00:00
|
|
|
const char *uz_warning; /* Warning to print on failure */
|
|
|
|
struct timeval uz_ratecheck; /* Warnings rate-limiting */
|
2016-02-03 23:30:17 +00:00
|
|
|
struct task uz_maxaction; /* Task to run when at limit */
|
2019-11-28 00:19:09 +00:00
|
|
|
uint16_t uz_bucket_size_min; /* Min number of items in bucket */
|
2015-12-20 02:05:33 +00:00
|
|
|
|
2019-11-28 00:19:09 +00:00
|
|
|
/* Offset 256+, stats and misc. */
|
2019-01-16 04:02:08 +00:00
|
|
|
counter_u64_t uz_allocs; /* Total number of allocations */
|
2019-01-15 18:24:34 +00:00
|
|
|
counter_u64_t uz_frees; /* Total number of frees */
|
|
|
|
counter_u64_t uz_fails; /* Total number of alloc failures */
|
2018-06-23 08:10:09 +00:00
|
|
|
uint64_t uz_sleeps; /* Total number of alloc sleeps */
|
2019-08-06 21:50:34 +00:00
|
|
|
uint64_t uz_xdomain; /* Total number of cross-domain frees */
|
2019-11-28 00:19:09 +00:00
|
|
|
char *uz_ctlname; /* sysctl safe name string. */
|
|
|
|
struct sysctl_oid *uz_oid; /* sysctl oid pointer. */
|
|
|
|
int uz_namecnt; /* duplicate name count. */
|
2018-06-23 08:10:09 +00:00
|
|
|
|
2002-03-19 09:11:49 +00:00
|
|
|
/*
|
|
|
|
* This HAS to be the last item because we adjust the zone size
|
|
|
|
* based on NCPU and then allocate the space for the zones.
|
|
|
|
*/
|
2018-01-12 23:25:05 +00:00
|
|
|
struct uma_cache uz_cpu[]; /* Per cpu caches */
|
|
|
|
|
|
|
|
/* uz_domain follows here. */
|
2002-03-19 09:11:49 +00:00
|
|
|
};
|
|
|
|
|
2003-09-19 08:37:44 +00:00
|
|
|
/*
|
|
|
|
* These flags must not overlap with the UMA_ZONE flags specified in uma.h.
|
|
|
|
*/
|
o Move zone limit from keg level up to zone level. This means that now
two zones sharing a keg may have different limits. Now this is going
to work:
zone = uma_zcreate();
uma_zone_set_max(zone, limit);
zone2 = uma_zsecond_create(zone);
uma_zone_set_max(zone2, limit2);
Kegs no longer have uk_maxpages field, but zones have uz_items. When
set, it may be rounded up to minimum possible CPU bucket cache size.
For small limits bucket cache can also be reconfigured to be smaller.
Counter uz_items is updated whenever items transition from keg to a
bucket cache or directly to a consumer. If zone has uz_maxitems set and
it is reached, then we are going to sleep.
o Since new limits don't play well with multi-keg zones, remove them. The
idea of multi-keg zones was introduced exactly 10 years ago, and never
have had a practical usage. In discussion with Jeff we came to a wild
agreement that if we ever want to reintroduce the idea of a smart allocator
that would be able to choose between two (or more) totally different
backing stores, that choice should be made one level higher than UMA,
e.g. in malloc(9) or in mget(), or whatever and choice should be controlled
by the caller.
o Sleeping code is improved to account number of sleepers and wake them one
by one, to avoid thundering herd problem.
o Flag UMA_ZONE_NOBUCKETCACHE removed, instead uma_zone_set_maxcache()
KPI added. Having no bucket cache basically means setting maxcache to 0.
o Now with many fields added and many removed (no multi-keg zones!) make
sure that struct uma_zone is perfectly aligned.
Reviewed by: markj, jeff
Tested by: pho
Differential Revision: https://reviews.freebsd.org/D17773
2019-01-15 00:02:06 +00:00
|
|
|
#define UMA_ZFLAG_CACHE 0x04000000 /* uma_zcache_create()d it */
|
2019-09-01 22:22:43 +00:00
|
|
|
#define UMA_ZFLAG_RECLAIMING 0x08000000 /* Running zone_reclaim(). */
|
2013-06-26 00:57:38 +00:00
|
|
|
#define UMA_ZFLAG_BUCKET 0x10000000 /* Bucket zone. */
|
2005-07-16 02:23:41 +00:00
|
|
|
#define UMA_ZFLAG_INTERNAL 0x20000000 /* No offpage no PCPU. */
|
2019-11-27 19:49:55 +00:00
|
|
|
#define UMA_ZFLAG_TRASH 0x40000000 /* Add trash ctor/dtor. */
|
2005-07-16 02:23:41 +00:00
|
|
|
#define UMA_ZFLAG_CACHEONLY 0x80000000 /* Don't ask VM for buckets. */
|
2002-03-19 09:11:49 +00:00
|
|
|
|
2013-06-26 00:57:38 +00:00
|
|
|
#define UMA_ZFLAG_INHERIT \
|
|
|
|
(UMA_ZFLAG_INTERNAL | UMA_ZFLAG_CACHEONLY | UMA_ZFLAG_BUCKET)
|
2009-01-25 09:11:24 +00:00
|
|
|
|
2010-03-17 21:18:28 +00:00
|
|
|
#undef UMA_ALIGN
|
|
|
|
|
2005-08-04 10:03:53 +00:00
|
|
|
#ifdef _KERNEL
|
2002-03-19 09:11:49 +00:00
|
|
|
/* Internal prototypes */
|
2013-04-09 17:43:48 +00:00
|
|
|
static __inline uma_slab_t hash_sfind(struct uma_hash *hash, uint8_t *data);
|
2002-03-19 09:11:49 +00:00
|
|
|
|
|
|
|
/* Lock Macros */
|
|
|
|
|
2009-01-25 09:11:24 +00:00
|
|
|
#define KEG_LOCK_INIT(k, lc) \
|
2002-04-29 23:45:41 +00:00
|
|
|
do { \
|
|
|
|
if ((lc)) \
|
2009-01-25 09:11:24 +00:00
|
|
|
mtx_init(&(k)->uk_lock, (k)->uk_name, \
|
|
|
|
(k)->uk_name, MTX_DEF | MTX_DUPOK); \
|
2002-04-29 23:45:41 +00:00
|
|
|
else \
|
2009-01-25 09:11:24 +00:00
|
|
|
mtx_init(&(k)->uk_lock, (k)->uk_name, \
|
2002-04-29 23:45:41 +00:00
|
|
|
"UMA zone", MTX_DEF | MTX_DUPOK); \
|
|
|
|
} while (0)
|
2013-06-20 19:08:12 +00:00
|
|
|
|
2009-01-25 09:11:24 +00:00
|
|
|
#define KEG_LOCK_FINI(k) mtx_destroy(&(k)->uk_lock)
|
|
|
|
#define KEG_LOCK(k) mtx_lock(&(k)->uk_lock)
|
|
|
|
#define KEG_UNLOCK(k) mtx_unlock(&(k)->uk_lock)
|
o Move zone limit from keg level up to zone level. This means that now
two zones sharing a keg may have different limits. Now this is going
to work:
zone = uma_zcreate();
uma_zone_set_max(zone, limit);
zone2 = uma_zsecond_create(zone);
uma_zone_set_max(zone2, limit2);
Kegs no longer have uk_maxpages field, but zones have uz_items. When
set, it may be rounded up to minimum possible CPU bucket cache size.
For small limits bucket cache can also be reconfigured to be smaller.
Counter uz_items is updated whenever items transition from keg to a
bucket cache or directly to a consumer. If zone has uz_maxitems set and
it is reached, then we are going to sleep.
o Since new limits don't play well with multi-keg zones, remove them. The
idea of multi-keg zones was introduced exactly 10 years ago, and never
have had a practical usage. In discussion with Jeff we came to a wild
agreement that if we ever want to reintroduce the idea of a smart allocator
that would be able to choose between two (or more) totally different
backing stores, that choice should be made one level higher than UMA,
e.g. in malloc(9) or in mget(), or whatever and choice should be controlled
by the caller.
o Sleeping code is improved to account number of sleepers and wake them one
by one, to avoid thundering herd problem.
o Flag UMA_ZONE_NOBUCKETCACHE removed, instead uma_zone_set_maxcache()
KPI added. Having no bucket cache basically means setting maxcache to 0.
o Now with many fields added and many removed (no multi-keg zones!) make
sure that struct uma_zone is perfectly aligned.
Reviewed by: markj, jeff
Tested by: pho
Differential Revision: https://reviews.freebsd.org/D17773
2019-01-15 00:02:06 +00:00
|
|
|
#define KEG_LOCK_ASSERT(k) mtx_assert(&(k)->uk_lock, MA_OWNED)
|
|
|
|
|
|
|
|
#define KEG_GET(zone, keg) do { \
|
|
|
|
(keg) = (zone)->uz_keg; \
|
|
|
|
KASSERT((void *)(keg) != (void *)&(zone)->uz_lock, \
|
|
|
|
("%s: Invalid zone %p type", __func__, (zone))); \
|
|
|
|
} while (0)
|
2013-06-20 19:08:12 +00:00
|
|
|
|
|
|
|
#define ZONE_LOCK_INIT(z, lc) \
|
|
|
|
do { \
|
|
|
|
if ((lc)) \
|
|
|
|
mtx_init(&(z)->uz_lock, (z)->uz_name, \
|
|
|
|
(z)->uz_name, MTX_DEF | MTX_DUPOK); \
|
|
|
|
else \
|
|
|
|
mtx_init(&(z)->uz_lock, (z)->uz_name, \
|
|
|
|
"UMA zone", MTX_DEF | MTX_DUPOK); \
|
|
|
|
} while (0)
|
2018-11-13 19:44:40 +00:00
|
|
|
|
2013-06-20 19:08:12 +00:00
|
|
|
#define ZONE_LOCK(z) mtx_lock((z)->uz_lockptr)
|
|
|
|
#define ZONE_TRYLOCK(z) mtx_trylock((z)->uz_lockptr)
|
|
|
|
#define ZONE_UNLOCK(z) mtx_unlock((z)->uz_lockptr)
|
|
|
|
#define ZONE_LOCK_FINI(z) mtx_destroy(&(z)->uz_lock)
|
2018-11-13 19:44:40 +00:00
|
|
|
#define ZONE_LOCK_ASSERT(z) mtx_assert((z)->uz_lockptr, MA_OWNED)
|
2002-03-19 09:11:49 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Find a slab within a hash table. This is used for OFFPAGE zones to lookup
|
|
|
|
* the slab structure.
|
|
|
|
*
|
|
|
|
* Arguments:
|
|
|
|
* hash The hash table to search.
|
|
|
|
* data The base page of the item.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* A pointer to a slab if successful, else NULL.
|
|
|
|
*/
|
|
|
|
static __inline uma_slab_t
|
2013-04-09 17:43:48 +00:00
|
|
|
hash_sfind(struct uma_hash *hash, uint8_t *data)
|
2002-03-19 09:11:49 +00:00
|
|
|
{
|
|
|
|
uma_slab_t slab;
|
2019-02-12 04:33:05 +00:00
|
|
|
u_int hval;
|
2002-03-19 09:11:49 +00:00
|
|
|
|
|
|
|
hval = UMA_HASH(hash, data);
|
|
|
|
|
|
|
|
SLIST_FOREACH(slab, &hash->uh_slab_hash[hval], us_hlink) {
|
2013-04-09 17:43:48 +00:00
|
|
|
if ((uint8_t *)slab->us_data == data)
|
2002-03-19 09:11:49 +00:00
|
|
|
return (slab);
|
|
|
|
}
|
|
|
|
return (NULL);
|
|
|
|
}
|
|
|
|
|
2002-09-18 08:26:30 +00:00
|
|
|
static __inline uma_slab_t
|
|
|
|
vtoslab(vm_offset_t va)
|
|
|
|
{
|
|
|
|
vm_page_t p;
|
|
|
|
|
|
|
|
p = PHYS_TO_VM_PAGE(pmap_kextract(va));
|
2019-11-28 07:49:25 +00:00
|
|
|
return (p->plinks.uma.slab);
|
2002-09-18 08:26:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static __inline void
|
2019-11-28 07:49:25 +00:00
|
|
|
vtozoneslab(vm_offset_t va, uma_zone_t *zone, uma_slab_t *slab)
|
2002-09-18 08:26:30 +00:00
|
|
|
{
|
|
|
|
vm_page_t p;
|
|
|
|
|
2004-11-26 15:04:26 +00:00
|
|
|
p = PHYS_TO_VM_PAGE(pmap_kextract(va));
|
2019-11-28 07:49:25 +00:00
|
|
|
*slab = p->plinks.uma.slab;
|
|
|
|
*zone = p->plinks.uma.zone;
|
|
|
|
}
|
|
|
|
|
|
|
|
static __inline void
|
|
|
|
vsetzoneslab(vm_offset_t va, uma_zone_t zone, uma_slab_t slab)
|
|
|
|
{
|
|
|
|
vm_page_t p;
|
|
|
|
|
|
|
|
p = PHYS_TO_VM_PAGE(pmap_kextract(va));
|
|
|
|
p->plinks.uma.slab = slab;
|
|
|
|
p->plinks.uma.zone = zone;
|
2002-09-18 08:26:30 +00:00
|
|
|
}
|
|
|
|
|
2019-11-29 03:14:10 +00:00
|
|
|
extern unsigned long uma_kmem_limit;
|
|
|
|
extern unsigned long uma_kmem_total;
|
|
|
|
|
|
|
|
/* Adjust bytes under management by UMA. */
|
|
|
|
static inline void
|
|
|
|
uma_total_dec(unsigned long size)
|
|
|
|
{
|
|
|
|
|
|
|
|
atomic_subtract_long(&uma_kmem_total, size);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
uma_total_inc(unsigned long size)
|
|
|
|
{
|
|
|
|
|
|
|
|
if (atomic_fetchadd_long(&uma_kmem_total, size) > uma_kmem_limit)
|
|
|
|
uma_reclaim_wakeup();
|
|
|
|
}
|
|
|
|
|
2002-11-01 01:01:27 +00:00
|
|
|
/*
|
|
|
|
* The following two functions may be defined by architecture specific code
|
2016-05-02 20:16:29 +00:00
|
|
|
* if they can provide more efficient allocation functions. This is useful
|
2002-11-01 01:01:27 +00:00
|
|
|
* for using direct mapped addresses.
|
|
|
|
*/
|
2018-01-12 23:25:05 +00:00
|
|
|
void *uma_small_alloc(uma_zone_t zone, vm_size_t bytes, int domain,
|
|
|
|
uint8_t *pflag, int wait);
|
2015-04-01 12:42:26 +00:00
|
|
|
void uma_small_free(void *mem, vm_size_t size, uint8_t flags);
|
2017-11-28 23:40:54 +00:00
|
|
|
|
|
|
|
/* Set a global soft limit on UMA managed memory. */
|
|
|
|
void uma_set_limit(unsigned long limit);
|
2005-08-04 10:03:53 +00:00
|
|
|
#endif /* _KERNEL */
|
2002-11-01 01:01:27 +00:00
|
|
|
|
2002-03-19 09:11:49 +00:00
|
|
|
#endif /* VM_UMA_INT_H */
|