From nobody Wed Nov 5 13:13:04 2025 Delivered-To: importer@patchew.org Received-SPF: pass (zoho.com: domain of gnu.org designates 208.118.235.17 as permitted sender) client-ip=208.118.235.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Authentication-Results: mx.zohomail.com; spf=pass (zoho.com: domain of gnu.org designates 208.118.235.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org Return-Path: Received: from lists.gnu.org (208.118.235.17 [208.118.235.17]) by mx.zohomail.com with SMTPS id 1534549880093795.7903302704726; Fri, 17 Aug 2018 16:51:20 -0700 (PDT) Received: from localhost ([::1]:36826 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1fqoWM-0002TQ-NR for importer@patchew.org; Fri, 17 Aug 2018 19:51:10 -0400 Received: from eggs.gnu.org ([2001:4830:134:3::10]:57651) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1fqoPE-0004rh-CY for qemu-devel@nongnu.org; Fri, 17 Aug 2018 19:43:49 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1fqoBj-0003HZ-Mw for qemu-devel@nongnu.org; Fri, 17 Aug 2018 19:29:55 -0400 Received: from out1-smtp.messagingengine.com ([66.111.4.25]:54451) by eggs.gnu.org with esmtps (TLS1.0:DHE_RSA_AES_256_CBC_SHA1:32) (Exim 4.71) (envelope-from ) id 1fqoBj-0003H0-EL for qemu-devel@nongnu.org; Fri, 17 Aug 2018 19:29:51 -0400 Received: from compute4.internal (compute4.nyi.internal [10.202.2.44]) by mailout.nyi.internal (Postfix) with ESMTP id 2CF33225FD; Fri, 17 Aug 2018 19:29:51 -0400 (EDT) Received: from mailfrontend2 ([10.202.2.163]) by compute4.internal (MEProxy); Fri, 17 Aug 2018 19:29:51 -0400 Received: from localhost (flamenco.cs.columbia.edu [128.59.20.216]) by mail.messagingengine.com (Postfix) with ESMTPA id B394F10268; Fri, 17 Aug 2018 19:29:50 -0400 (EDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=braap.org; h=cc :date:from:in-reply-to:message-id:references:subject:to :x-me-sender:x-me-sender:x-sasl-enc; s=mesmtp; bh=dCttIWviY0ltYU 4qNLPRQWx4E7MutHfhHu5aCeHyf50=; b=LzaWi472lkQ35jE+qzL7bBOtztYV// Cibl4XOK/JQhep87ZtDuTPX2lSwDecESJlhT1YWMT+6fYEyqaOUWtnMaKyUz62N9 FWJHCKqP+uEHadGzJXBJ2M7tZD3ta3GMFen9nf0Lrvgl7E81Uvw2lAjVIhjcyuUv wiwVOkPXvtQzg= DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d= messagingengine.com; h=cc:date:from:in-reply-to:message-id :references:subject:to:x-me-sender:x-me-sender:x-sasl-enc; s= fm3; bh=dCttIWviY0ltYU4qNLPRQWx4E7MutHfhHu5aCeHyf50=; b=XK/J+QCw pvoegBiLFVy5hE9RLZiO7VYijIiuRRf+Bc2cIEPertLzlUMopJcE81gqsBzdPpgu +gSoS4YRPfxRLHr84r+Wey6p/TpXCOZMbwCbSkxDu/76Y+QGy6kUmoVO1f6mNF90 KDZnPT7knLXktrq9Bh/rQY39XZL/0TuFSVFEhI3JOMjccLKrEMD3ziDlOvHKrkRa eA8RYIsagoPJVHhx58dVQjTG41jktmU6n+H0L6JjDPbiS2GVY6FC9/ReXR+nKiNj 8oAzuISis0wAi0sUX76XoTfYdfYXUu6glMgxSKeDWoiYUYAxapvTEk0xEWPWtcl4 tBYIIra4ex+XBw== X-ME-Proxy: X-ME-Sender: From: "Emilio G. Cota" To: qemu-devel@nongnu.org Date: Fri, 17 Aug 2018 19:29:19 -0400 Message-Id: <20180817232923.28899-3-cota@braap.org> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20180817232923.28899-1-cota@braap.org> References: <20180817232923.28899-1-cota@braap.org> X-detected-operating-system: by eggs.gnu.org: GNU/Linux 2.2.x-3.x [generic] X-Received-From: 66.111.4.25 Subject: [Qemu-devel] [PATCH 2/6] qht: add qht_iter_remove X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.21 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: =?UTF-8?q?Alex=20Benn=C3=A9e?= , Richard Henderson Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail: RSF_0 Z_629925259 SPT_0 Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" This currently has no users, but the use case is so common that I think we must support it. Note that without the appended we cannot safely remove a set of elements; a 2-step approach (i.e. qht_iter first, keep track of the to-be-deleted elements, and then a bunch of qht_remove calls) would be racy, since between the iteration and the removals other threads might insert additional elements. Signed-off-by: Emilio G. Cota Reviewed-by: Alex Benn=C3=A9e --- include/qemu/qht.h | 19 ++++++++++++ util/qht.c | 74 +++++++++++++++++++++++++++++++++++++++++----- 2 files changed, 85 insertions(+), 8 deletions(-) diff --git a/include/qemu/qht.h b/include/qemu/qht.h index 1fb9116fa0..91bc9b00cf 100644 --- a/include/qemu/qht.h +++ b/include/qemu/qht.h @@ -44,6 +44,8 @@ struct qht_stats { =20 typedef bool (*qht_lookup_func_t)(const void *obj, const void *userp); typedef void (*qht_iter_func_t)(struct qht *ht, void *p, uint32_t h, void = *up); +typedef bool (*qht_iter_bool_func_t)(struct qht *ht, void *p, uint32_t h, + void *up); =20 #define QHT_MODE_AUTO_RESIZE 0x1 /* auto-resize when heavily loaded */ =20 @@ -178,9 +180,26 @@ bool qht_resize(struct qht *ht, size_t n_elems); * * Each time it is called, user-provided @func is passed a pointer-hash pa= ir, * plus @userp. + * + * Note: @ht cannot be accessed from @func + * See also: qht_iter_remove() */ void qht_iter(struct qht *ht, qht_iter_func_t func, void *userp); =20 +/** + * qht_iter_remove - Iterate over a QHT, optionally removing entries + * @ht: QHT to be iterated over + * @func: function to be called for each entry in QHT + * @userp: additional pointer to be passed to @func + * + * Each time it is called, user-provided @func is passed a pointer-hash pa= ir, + * plus @userp. If @func returns true, the pointer-hash pair is removed. + * + * Note: @ht cannot be accessed from @func + * See also: qht_iter() + */ +void qht_iter_remove(struct qht *ht, qht_iter_bool_func_t func, void *user= p); + /** * qht_statistics_init - Gather statistics from a QHT * @ht: QHT to gather statistics from diff --git a/util/qht.c b/util/qht.c index 7b57b50a24..caec53dd0e 100644 --- a/util/qht.c +++ b/util/qht.c @@ -89,6 +89,19 @@ #define QHT_BUCKET_ENTRIES 4 #endif =20 +enum qht_iter_type { + QHT_ITER_VOID, /* do nothing; use retvoid */ + QHT_ITER_RM, /* remove element if retbool returns true */ +}; + +struct qht_iter { + union { + qht_iter_func_t retvoid; + qht_iter_bool_func_t retbool; + } f; + enum qht_iter_type type; +}; + /* * Note: reading partially-updated pointers in @pointers could lead to * segfaults. We thus access them with atomic_read/set; this guarantees @@ -706,9 +719,10 @@ bool qht_remove(struct qht *ht, const void *p, uint32_= t hash) return ret; } =20 -static inline void qht_bucket_iter(struct qht *ht, struct qht_bucket *b, - qht_iter_func_t func, void *userp) +static inline void qht_bucket_iter(struct qht *ht, struct qht_bucket *head, + const struct qht_iter *iter, void *user= p) { + struct qht_bucket *b =3D head; int i; =20 do { @@ -716,7 +730,25 @@ static inline void qht_bucket_iter(struct qht *ht, str= uct qht_bucket *b, if (b->pointers[i] =3D=3D NULL) { return; } - func(ht, b->pointers[i], b->hashes[i], userp); + switch (iter->type) { + case QHT_ITER_VOID: + iter->f.retvoid(ht, b->pointers[i], b->hashes[i], userp); + break; + case QHT_ITER_RM: + if (iter->f.retbool(ht, b->pointers[i], b->hashes[i], user= p)) { + /* replace i with the last valid element in the bucket= */ + seqlock_write_begin(&head->sequence); + qht_bucket_remove_entry(b, i); + seqlock_write_end(&head->sequence); + qht_bucket_debug__locked(b); + /* reevaluate i, since it just got replaced */ + i--; + continue; + } + break; + default: + g_assert_not_reached(); + } } b =3D b->next; } while (b); @@ -724,26 +756,48 @@ static inline void qht_bucket_iter(struct qht *ht, st= ruct qht_bucket *b, =20 /* call with all of the map's locks held */ static inline void qht_map_iter__all_locked(struct qht *ht, struct qht_map= *map, - qht_iter_func_t func, void *us= erp) + const struct qht_iter *iter, + void *userp) { size_t i; =20 for (i =3D 0; i < map->n_buckets; i++) { - qht_bucket_iter(ht, &map->buckets[i], func, userp); + qht_bucket_iter(ht, &map->buckets[i], iter, userp); } } =20 -void qht_iter(struct qht *ht, qht_iter_func_t func, void *userp) +static inline void +do_qht_iter(struct qht *ht, const struct qht_iter *iter, void *userp) { struct qht_map *map; =20 map =3D atomic_rcu_read(&ht->map); qht_map_lock_buckets(map); /* Note: ht here is merely for carrying ht->mode; ht->map won't be rea= d */ - qht_map_iter__all_locked(ht, map, func, userp); + qht_map_iter__all_locked(ht, map, iter, userp); qht_map_unlock_buckets(map); } =20 +void qht_iter(struct qht *ht, qht_iter_func_t func, void *userp) +{ + const struct qht_iter iter =3D { + .f.retvoid =3D func, + .type =3D QHT_ITER_VOID, + }; + + do_qht_iter(ht, &iter, userp); +} + +void qht_iter_remove(struct qht *ht, qht_iter_bool_func_t func, void *user= p) +{ + const struct qht_iter iter =3D { + .f.retbool =3D func, + .type =3D QHT_ITER_RM, + }; + + do_qht_iter(ht, &iter, userp); +} + static void qht_map_copy(struct qht *ht, void *p, uint32_t hash, void *use= rp) { struct qht_map *new =3D userp; @@ -760,6 +814,10 @@ static void qht_map_copy(struct qht *ht, void *p, uint= 32_t hash, void *userp) static void qht_do_resize_reset(struct qht *ht, struct qht_map *new, bool = reset) { struct qht_map *old; + const struct qht_iter iter =3D { + .f.retvoid =3D qht_map_copy, + .type =3D QHT_ITER_VOID, + }; =20 old =3D ht->map; qht_map_lock_buckets(old); @@ -774,7 +832,7 @@ static void qht_do_resize_reset(struct qht *ht, struct = qht_map *new, bool reset) } =20 g_assert(new->n_buckets !=3D old->n_buckets); - qht_map_iter__all_locked(ht, old, qht_map_copy, new); + qht_map_iter__all_locked(ht, old, &iter, new); qht_map_debug__all_locked(new); =20 atomic_rcu_set(&ht->map, new); --=20 2.17.1