From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by smtp.lore.kernel.org (Postfix) with ESMTP id 591EAC07545 for ; Tue, 24 Oct 2023 09:34:16 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id 94E3E6B0204; Tue, 24 Oct 2023 05:34:12 -0400 (EDT) Received: by kanga.kvack.org (Postfix, from userid 40) id 8FE176B0205; Tue, 24 Oct 2023 05:34:12 -0400 (EDT) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id 74FAE6B0206; Tue, 24 Oct 2023 05:34:12 -0400 (EDT) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0010.hostedemail.com [216.40.44.10]) by kanga.kvack.org (Postfix) with ESMTP id 623C66B0204 for ; Tue, 24 Oct 2023 05:34:12 -0400 (EDT) Received: from smtpin12.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay06.hostedemail.com (Postfix) with ESMTP id 3164DB624C for ; Tue, 24 Oct 2023 09:34:12 +0000 (UTC) X-FDA: 81379843944.12.0C9B3C0 Received: from out-207.mta0.migadu.com (out-207.mta0.migadu.com [91.218.175.207]) by imf03.hostedemail.com (Postfix) with ESMTP id 5DD852001A for ; Tue, 24 Oct 2023 09:34:10 +0000 (UTC) Authentication-Results: imf03.hostedemail.com; dkim=pass header.d=linux.dev header.s=key1 header.b=Y7iQvWYn; spf=pass (imf03.hostedemail.com: domain of chengming.zhou@linux.dev designates 91.218.175.207 as permitted sender) smtp.mailfrom=chengming.zhou@linux.dev; dmarc=pass (policy=none) header.from=linux.dev ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1698140050; h=from:from:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=1189G8OwJQsHaUqQ7omEWGXJiWlZJSsRqA7qcxA5H0E=; b=Ss/aXZvdFtmlddbvZ4DDzUJ8N8OdBngZaFv6znqXxS78mfMbwEw02hhRXW0Klxxc5aS9o7 WZumhbqX/M5Hk1plXCo/XNHQTAMRkts69paDXvUEsjq20HJ5ns9wX2NjjwumrnSXSU2Ebz jTF+aY8hEV4kd56BYT3neftTIhuDcgI= ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1698140050; a=rsa-sha256; cv=none; b=8Nj+08FXavRluY2EyTSXRJLxuLwjG0QXSutfGscXD77OrPtF5Oc0/AwZ+AStuRrBXL+/Gx Tj0EsT1Ro6qzVNvB5JFVVSkQH512XdVwtV29QvWMIipl/YJBk+ssXAfm2vwwFFGevmqrH9 T0cnNhj4nCYBfVM6aBG+zFVzcLv7BWo= ARC-Authentication-Results: i=1; imf03.hostedemail.com; dkim=pass header.d=linux.dev header.s=key1 header.b=Y7iQvWYn; spf=pass (imf03.hostedemail.com: domain of chengming.zhou@linux.dev designates 91.218.175.207 as permitted sender) smtp.mailfrom=chengming.zhou@linux.dev; dmarc=pass (policy=none) header.from=linux.dev X-Report-Abuse: Please report any abuse attempt to abuse@migadu.com and include these headers. DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linux.dev; s=key1; t=1698140048; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=1189G8OwJQsHaUqQ7omEWGXJiWlZJSsRqA7qcxA5H0E=; b=Y7iQvWYnYomwhH9HpqqMB6QnGTBOBbLrimV35vPGob+QAc/EDk42XtH9Qiw36iRppPZAfY nbCKMQcN9UNCzVRzFAAYL7APDUqtxspLiF8pMGCAFass0h7cocBOURvFszr/QxFy9Eav/T md+C1DNGHg5ckM7dyaawphlNjCc6pmI= From: chengming.zhou@linux.dev To: cl@linux.com, penberg@kernel.org Cc: rientjes@google.com, iamjoonsoo.kim@lge.com, akpm@linux-foundation.org, vbabka@suse.cz, roman.gushchin@linux.dev, 42.hyeyoo@gmail.com, linux-mm@kvack.org, linux-kernel@vger.kernel.org, chengming.zhou@linux.dev, Chengming Zhou Subject: [RFC PATCH v3 6/7] slub: Delay freezing of partial slabs Date: Tue, 24 Oct 2023 09:33:44 +0000 Message-Id: <20231024093345.3676493-7-chengming.zhou@linux.dev> In-Reply-To: <20231024093345.3676493-1-chengming.zhou@linux.dev> References: <20231024093345.3676493-1-chengming.zhou@linux.dev> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Migadu-Flow: FLOW_OUT X-Rspamd-Queue-Id: 5DD852001A X-Rspam-User: X-Rspamd-Server: rspam11 X-Stat-Signature: f3az8bnu599xe85krzwdgfeny6oq5wmj X-HE-Tag: 1698140050-940830 X-HE-Meta: U2FsdGVkX185dB+InENBiLAar89lpG7adzh8r29wbPqsu+lxVWvCLBopsGJ3slneDZVWZsZBDpy56Irr6UynTtI89IMshKuk8Eivt21NEyXQ02tuSINgOhhnhUMBw5b3DDFqRM6AsrLSMJ+g8oKW8ODrk963Q9hxzHvkHUYi2RToZJW4w0qLhRpdUW3A+HN4xl9GjX+I3vCHx6u43JN5Kvrm+KjvY3r9Z/s9BJsEuxEPu3jYP+KCMqxMM74dTNllPMRrI0zw1+yCu+6qpjCMO/o0t+Y1WDRNNeOhu8NABisnQZxospxkUudfmq5Tt4UJQrtZkmo+QTPCouqR00bjZpUX+azqiu5podwJgbco0GpJK74/8VBhMZx1NUkHZNGML3kKXwR1NzPVwtZrOH1h6TPO6FcdpFTTAGVrN7RJC8NPKtoC009u3grFTuqDjXD8Pye1momyNlwliUHdy6SBBvakWTsl/6cX3F7KDIqkeQCndu5YtEkw/mCItnY3I/EycEo22wiH/EhNMu81qzX21qu7rUxuBn+WYqlMZLC/QzWMNMAMfptru0UJoGyrVtWBNYXjZR/0EqCc9ZOn3jE4OzENVSn15oCcP9y0CCx/uZ4ZY5No/oql6/743PUo2Et3m7XysCuXqfLDaj+FUewg6yE6HulFiloFHI87GrfUQ/Fsjrk7Zh7UKBncZhwGr5N5gLpBoI9GJZtZIx2V5ZS/Uy8CtMQIaXbiRECw3oy6Jn/BTb+n6AoP9ML3QFslivN3Eezan5bM13mK28MWYet1zcG5cwKoIU4s1sXXpw+5FM4v/hLV3HqfqCKtWWs7Bc/VfyROk4e/sQCWp1Idnrhv5X+ON1wbHSk5wvPvdAWY+GayZEDrK47+aZOWa0t77kJw2MA0716WI3l/FKupdX4khKCQxSzvh6isRBzSPAK65nxz8O72QVwFgrg0NLC0TaNXyNC72l4LOrGWvALW1RQ 90CekX9Y WdqXx50YHVULm6I9aC4vOtQWvSsMIAPezAMLUD4iKz55AHOcd0ORAXPng2eezKXleVe24UZ+ILuvgsl5FfyANFi6LcivsYMqCLqu2WL4BF+bBEXci/NBtCD9mrgjFkKkXBHykqAAcbQe/BiMJr9F9FPqWv0xJiFg+e1LX2S/yOE4ks2qHVKvum734zQ2Lhy9WKViu X-Bogosity: Ham, tests=bogofilter, spamicity=0.000000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: List-Subscribe: List-Unsubscribe: From: Chengming Zhou Now we will freeze slabs when moving them out of node partial list to cpu partial list, this method needs two cmpxchg_double operations: 1. freeze slab (acquire_slab()) under the node list_lock 2. get_freelist() when pick used in ___slab_alloc() Actually we don't need to freeze when moving slabs out of node partial list, we can delay freezing to when use slab freelist in ___slab_alloc(), so we can save one cmpxchg_double(). And there are other good points: - The moving of slabs between node partial list and cpu partial list becomes simpler, since we don't need to freeze or unfreeze at all. - The node list_lock contention would be less, since we don't need to freeze any slab under the node list_lock. We can achieve this because there is no concurrent path would manipulate the partial slab list except the __slab_free() path, which is serialized now. Since the slab returned by get_partial() interfaces is not frozen anymore and no freelist in the partial_context, so we need to use the introduced freeze_slab() to freeze it and get its freelist. Similarly, the slabs on the CPU partial list are not frozen anymore, we need to freeze_slab() on it before use. Signed-off-by: Chengming Zhou --- mm/slub.c | 111 +++++++++++------------------------------------------- 1 file changed, 21 insertions(+), 90 deletions(-) diff --git a/mm/slub.c b/mm/slub.c index 5b428648021f..486d44421432 100644 --- a/mm/slub.c +++ b/mm/slub.c @@ -2215,51 +2215,6 @@ static void *alloc_single_from_new_slab(struct kmem_cache *s, return object; } -/* - * Remove slab from the partial list, freeze it and - * return the pointer to the freelist. - * - * Returns a list of objects or NULL if it fails. - */ -static inline void *acquire_slab(struct kmem_cache *s, - struct kmem_cache_node *n, struct slab *slab, - int mode) -{ - void *freelist; - unsigned long counters; - struct slab new; - - lockdep_assert_held(&n->list_lock); - - /* - * Zap the freelist and set the frozen bit. - * The old freelist is the list of objects for the - * per cpu allocation list. - */ - freelist = slab->freelist; - counters = slab->counters; - new.counters = counters; - if (mode) { - new.inuse = slab->objects; - new.freelist = NULL; - } else { - new.freelist = freelist; - } - - VM_BUG_ON(new.frozen); - new.frozen = 1; - - if (!__slab_update_freelist(s, slab, - freelist, counters, - new.freelist, new.counters, - "acquire_slab")) - return NULL; - - remove_partial(n, slab); - WARN_ON(!freelist); - return freelist; -} - #ifdef CONFIG_SLUB_CPU_PARTIAL static void put_cpu_partial(struct kmem_cache *s, struct slab *slab, int drain); #else @@ -2276,7 +2231,6 @@ static struct slab *get_partial_node(struct kmem_cache *s, struct partial_context *pc) { struct slab *slab, *slab2, *partial = NULL; - void *object = NULL; unsigned long flags; unsigned int partial_slabs = 0; @@ -2295,7 +2249,7 @@ static struct slab *get_partial_node(struct kmem_cache *s, continue; if (IS_ENABLED(CONFIG_SLUB_TINY) || kmem_cache_debug(s)) { - object = alloc_single_from_partial(s, n, slab, + void *object = alloc_single_from_partial(s, n, slab, pc->orig_size); if (object) { partial = slab; @@ -2305,13 +2259,10 @@ static struct slab *get_partial_node(struct kmem_cache *s, continue; } - object = acquire_slab(s, n, slab, object == NULL); - if (!object) - break; + remove_partial(n, slab); if (!partial) { partial = slab; - pc->object = object; stat(s, ALLOC_FROM_PARTIAL); } else { put_cpu_partial(s, slab, 0); @@ -2610,9 +2561,6 @@ static void __unfreeze_partials(struct kmem_cache *s, struct slab *partial_slab) unsigned long flags = 0; while (partial_slab) { - struct slab new; - struct slab old; - slab = partial_slab; partial_slab = slab->next; @@ -2625,23 +2573,7 @@ static void __unfreeze_partials(struct kmem_cache *s, struct slab *partial_slab) spin_lock_irqsave(&n->list_lock, flags); } - do { - - old.freelist = slab->freelist; - old.counters = slab->counters; - VM_BUG_ON(!old.frozen); - - new.counters = old.counters; - new.freelist = old.freelist; - - new.frozen = 0; - - } while (!__slab_update_freelist(s, slab, - old.freelist, old.counters, - new.freelist, new.counters, - "unfreezing slab")); - - if (unlikely(!new.inuse && n->nr_partial >= s->min_partial)) { + if (unlikely(!slab->inuse && n->nr_partial >= s->min_partial)) { slab->next = slab_to_discard; slab_to_discard = slab; } else { @@ -3148,7 +3080,6 @@ static void *___slab_alloc(struct kmem_cache *s, gfp_t gfpflags, int node, node = NUMA_NO_NODE; goto new_slab; } -redo: if (unlikely(!node_match(slab, node))) { /* @@ -3224,7 +3155,7 @@ static void *___slab_alloc(struct kmem_cache *s, gfp_t gfpflags, int node, new_slab: - if (slub_percpu_partial(c)) { + while (slub_percpu_partial(c)) { local_lock_irqsave(&s->cpu_slab->lock, flags); if (unlikely(c->slab)) { local_unlock_irqrestore(&s->cpu_slab->lock, flags); @@ -3236,11 +3167,20 @@ static void *___slab_alloc(struct kmem_cache *s, gfp_t gfpflags, int node, goto new_objects; } - slab = c->slab = slub_percpu_partial(c); + slab = slub_percpu_partial(c); slub_set_percpu_partial(c, slab); local_unlock_irqrestore(&s->cpu_slab->lock, flags); stat(s, CPU_PARTIAL_ALLOC); - goto redo; + + if (unlikely(!node_match(slab, node) || + !pfmemalloc_match(slab, gfpflags))) { + slab->next = NULL; + __unfreeze_partials(s, slab); + continue; + } + + freelist = freeze_slab(s, slab); + goto retry_load_slab; } new_objects: @@ -3249,8 +3189,8 @@ static void *___slab_alloc(struct kmem_cache *s, gfp_t gfpflags, int node, pc.orig_size = orig_size; slab = get_partial(s, node, &pc); if (slab) { - freelist = pc.object; if (kmem_cache_debug(s)) { + freelist = pc.object; /* * For debug caches here we had to go through * alloc_single_from_partial() so just store the @@ -3262,6 +3202,7 @@ static void *___slab_alloc(struct kmem_cache *s, gfp_t gfpflags, int node, return freelist; } + freelist = freeze_slab(s, slab); goto retry_load_slab; } @@ -3663,18 +3604,8 @@ static void __slab_free(struct kmem_cache *s, struct slab *slab, was_frozen = new.frozen; new.inuse -= cnt; if ((!new.inuse || !prior) && !was_frozen) { - - if (kmem_cache_has_cpu_partial(s) && !prior) { - - /* - * Slab was on no list before and will be - * partially empty - * We can defer the list move and instead - * freeze it. - */ - new.frozen = 1; - - } else { /* Needs to be taken off a list */ + /* Needs to be taken off a list */ + if (!kmem_cache_has_cpu_partial(s) || prior) { n = get_node(s, slab_nid(slab)); /* @@ -3704,9 +3635,9 @@ static void __slab_free(struct kmem_cache *s, struct slab *slab, * activity can be necessary. */ stat(s, FREE_FROZEN); - } else if (new.frozen) { + } else if (kmem_cache_has_cpu_partial(s) && !prior) { /* - * If we just froze the slab then put it onto the + * If we started with a full slab then put it onto the * per cpu partial list. */ put_cpu_partial(s, slab, 1); -- 2.40.1