From nobody Sat May 18 06:50:38 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=fail; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=fail(p=none dis=none) header.from=redhat.com Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1647439932942925.9789516568491; Wed, 16 Mar 2022 07:12:12 -0700 (PDT) Received: from localhost ([::1]:46496 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1nUUNn-00075k-BU for importer@patchew.org; Wed, 16 Mar 2022 10:12:11 -0400 Received: from eggs.gnu.org ([209.51.188.92]:47992) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1nUU6m-0005Sq-GG for qemu-devel@nongnu.org; Wed, 16 Mar 2022 09:54:39 -0400 Received: from us-smtp-delivery-124.mimecast.com ([170.10.129.124]:44417) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1nUU6k-0000cG-1n for qemu-devel@nongnu.org; Wed, 16 Mar 2022 09:54:36 -0400 Received: from mail-wm1-f69.google.com (mail-wm1-f69.google.com [209.85.128.69]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id us-mta-35-k-pNzb0_Pt6AybizYrK3bQ-1; Wed, 16 Mar 2022 09:54:30 -0400 Received: by mail-wm1-f69.google.com with SMTP id a26-20020a7bc1da000000b003857205ec7cso1084176wmj.2 for ; Wed, 16 Mar 2022 06:54:30 -0700 (PDT) Received: from vian.redhat.com ([2a0c:5a80:3506:3400:69b5:c807:1d52:ff67]) by smtp.gmail.com with ESMTPSA id w7-20020a1cf607000000b00389a5390180sm1770157wmc.25.2022.03.16.06.54.27 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 16 Mar 2022 06:54:28 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1647438873; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=0n/KToaMwV0MVuk1t9AkE2/GeN2rh/LBvIHjSpamd8c=; b=h1BJN+Jv4Crqjfau7HDtfOK9PyHC7YSdeYLVkIQX7QJDmqCWSUCtFu53ovKg0eduGIuxto afY6buxV8s5XT/KAEq+qV+Q3IFdEjyMzZ1wBLyeN2MTasA1ZJul6UIT39ItyEQuWLcWzZy PoPo/FzKUA6Of9U3TefwfaszwJNm6vQ= X-MC-Unique: k-pNzb0_Pt6AybizYrK3bQ-1 X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=0n/KToaMwV0MVuk1t9AkE2/GeN2rh/LBvIHjSpamd8c=; b=dAH3mUPoc8sFp/dpty0eIAmUbOOxRfWy+UjpBgJcIU8RRtuPEW3EV8mJZlo8cljBrJ AgKjHda/M7W0BZ/13kcr4RamaQ+IEkPh/AwaOxkTi8wmGpiUkQfugfrPHg9gfDh0oWNv nN8hLIUeihQc3g0Wd5BLGOhIstmuA4or7Gy4S7E4wwidc37ktGQmyshtu5IynpTCuBmk dcR/a+ELQNMVXrrgo4sqTBh60bafzkShPSQKI37wWU+twV0cpkZaPMNxxoaQ0Itry2J7 LQ5LL/u5TzvguXWeAFfvgNHH4QbhOh1NUtsF6stah+0LjDiOlWJ5YS36TUYvIEREQNFZ m6Uw== X-Gm-Message-State: AOAM531AwWzQsF1WicFFrDBVI4L8kTIxKbH3XbpdpGt8+PqTAVNXXwGn z6hgCB5ibsSii+5ZrPr7l+aPAbPTPf2PoszXHuSP69FSVLS7fEbWX+1Ao2Kq2OoWEVRz8/uKj+q 9qo5I9w7A9RVyvT8= X-Received: by 2002:a05:600c:3b14:b0:389:e95d:75af with SMTP id m20-20020a05600c3b1400b00389e95d75afmr7290433wms.143.1647438869171; Wed, 16 Mar 2022 06:54:29 -0700 (PDT) X-Google-Smtp-Source: ABdhPJyx/Z21FFYcQBpcOrhTcPFh03170WMwC1HGnpfOQs5pzeR8vWMi9FqxRmtnXtEiRcYSMX2bcA== X-Received: by 2002:a05:600c:3b14:b0:389:e95d:75af with SMTP id m20-20020a05600c3b1400b00389e95d75afmr7290410wms.143.1647438868884; Wed, 16 Mar 2022 06:54:28 -0700 (PDT) From: Nicolas Saenz Julienne To: kwolf@redhat.com, stefanha@redhat.com, berrange@redhat.com Subject: [PATCH v3 1/3] Introduce event-loop-base abstract class Date: Wed, 16 Mar 2022 14:53:21 +0100 Message-Id: <20220316135321.142850-2-nsaenzju@redhat.com> X-Mailer: git-send-email 2.35.1 In-Reply-To: <20220316135321.142850-1-nsaenzju@redhat.com> References: <20220316135321.142850-1-nsaenzju@redhat.com> MIME-Version: 1.0 Authentication-Results: relay.mimecast.com; auth=pass smtp.auth=CUSA124A263 smtp.mailfrom=nsaenzju@redhat.com X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=170.10.129.124; envelope-from=nsaenzju@redhat.com; helo=us-smtp-delivery-124.mimecast.com X-Spam_score_int: -21 X-Spam_score: -2.2 X-Spam_bar: -- X-Spam_report: (-2.2 / 5.0 requ) BAYES_00=-1.9, DKIMWL_WL_HIGH=-0.082, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, RCVD_IN_MSPIKE_H4=0.001, RCVD_IN_MSPIKE_WL=0.001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001, T_SCC_BODY_TEXT_LINE=-0.01 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: fam@euphon.net, eduardo@habkost.net, qemu-block@nongnu.org, michael.roth@amd.com, mtosatti@redhat.com, qemu-devel@nongnu.org, armbru@redhat.com, hreitz@redhat.com, pbonzini@redhat.com, Nicolas Saenz Julienne , eblake@redhat.com Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: fail (Header signature does not verify) X-ZM-MESSAGEID: 1647439935057100003 Content-Type: text/plain; charset="utf-8" Introduce the 'event-loop-base' abstract class, it'll hold the properties common to all event loops and provide the necessary hooks for their creation and maintenance. Then have iothread inherit from it. EventLoopBaseClass is defined as user creatable and provides a hook for its children to attach themselves to the user creatable class 'complete' function. It also provides an update_params() callback to propagate property changes onto its children. The new 'event-loop-base' class will live in the root directory. It is built on its own using the 'link_whole' option (there are no direct function dependencies between the class and its children, it all happens trough 'constructor' magic). And also imposes new compilation dependencies: qom <- event-loop-base <- blockdev (iothread.c) And in subsequent patches: qom <- event-loop-base <- qemuutil (util/main-loop.c) All this forced some amount of reordering in meson.build: - Moved qom build definition before qemuutil. Doing it the other way around (i.e. moving qemuutil after qom) isn't possible as a lot of core libraries that live in between the two depend on it. - Process the 'hw' subdir earlier, as it introduces files into the 'qom' source set. No functional changes intended. Signed-off-by: Nicolas Saenz Julienne Reviewed-by: Stefan Hajnoczi --- Changes since v2: - reword commit message to better explain compilation dependencies. Changes since v1: - Rename to event-loop-base - Move event-loop-base into root directory - Build event-loop-base on its own, use link_whole to avoid the problem of the object file not being linked due to lacking direct calls from dependencies. - Move poll parameters into iothread, as main loop can't poll - Update Authorship (I took what iothread.c had and added myself, I hope that's fine) - Introduce update_params() callback event-loop-base.c | 104 +++++++++++++++++++++++++++++++ include/sysemu/event-loop-base.h | 36 +++++++++++ include/sysemu/iothread.h | 6 +- iothread.c | 65 ++++++------------- meson.build | 23 ++++--- 5 files changed, 175 insertions(+), 59 deletions(-) create mode 100644 event-loop-base.c create mode 100644 include/sysemu/event-loop-base.h diff --git a/event-loop-base.c b/event-loop-base.c new file mode 100644 index 0000000000..a924c73a7c --- /dev/null +++ b/event-loop-base.c @@ -0,0 +1,104 @@ +/* + * QEMU event-loop base + * + * Copyright (C) 2022 Red Hat Inc + * + * Authors: + * Stefan Hajnoczi + * Nicolas Saenz Julienne + * + * This work is licensed under the terms of the GNU GPL, version 2 or late= r. + * See the COPYING file in the top-level directory. + */ + +#include "qemu/osdep.h" +#include "qom/object_interfaces.h" +#include "qapi/error.h" +#include "sysemu/event-loop-base.h" + +typedef struct { + const char *name; + ptrdiff_t offset; /* field's byte offset in EventLoopBase struct */ +} EventLoopBaseParamInfo; + +static EventLoopBaseParamInfo aio_max_batch_info =3D { + "aio-max-batch", offsetof(EventLoopBase, aio_max_batch), +}; + +static void event_loop_base_get_param(Object *obj, Visitor *v, + const char *name, void *opaque, Error **errp) +{ + EventLoopBase *event_loop_base =3D EVENT_LOOP_BASE(obj); + EventLoopBaseParamInfo *info =3D opaque; + int64_t *field =3D (void *)event_loop_base + info->offset; + + visit_type_int64(v, name, field, errp); +} + +static void event_loop_base_set_param(Object *obj, Visitor *v, + const char *name, void *opaque, Error **errp) +{ + EventLoopBaseClass *bc =3D EVENT_LOOP_BASE_GET_CLASS(obj); + EventLoopBase *base =3D EVENT_LOOP_BASE(obj); + EventLoopBaseParamInfo *info =3D opaque; + int64_t *field =3D (void *)base + info->offset; + int64_t value; + + if (!visit_type_int64(v, name, &value, errp)) { + return; + } + + if (value < 0) { + error_setg(errp, "%s value must be in range [0, %" PRId64 "]", + info->name, INT64_MAX); + return; + } + + *field =3D value; + + if (bc->update_params) { + bc->update_params(base, errp); + } + + return; +} + +static void event_loop_base_complete(UserCreatable *uc, Error **errp) +{ + EventLoopBaseClass *bc =3D EVENT_LOOP_BASE_GET_CLASS(uc); + EventLoopBase *base =3D EVENT_LOOP_BASE(uc); + + if (bc->init) { + bc->init(base, errp); + } +} + +static void event_loop_base_class_init(ObjectClass *klass, void *class_dat= a) +{ + UserCreatableClass *ucc =3D USER_CREATABLE_CLASS(klass); + ucc->complete =3D event_loop_base_complete; + + object_class_property_add(klass, "aio-max-batch", "int", + event_loop_base_get_param, + event_loop_base_set_param, + NULL, &aio_max_batch_info); +} + +static const TypeInfo event_loop_base_info =3D { + .name =3D TYPE_EVENT_LOOP_BASE, + .parent =3D TYPE_OBJECT, + .instance_size =3D sizeof(EventLoopBase), + .class_size =3D sizeof(EventLoopBaseClass), + .class_init =3D event_loop_base_class_init, + .abstract =3D true, + .interfaces =3D (InterfaceInfo[]) { + { TYPE_USER_CREATABLE }, + { } + } +}; + +static void register_types(void) +{ + type_register_static(&event_loop_base_info); +} +type_init(register_types); diff --git a/include/sysemu/event-loop-base.h b/include/sysemu/event-loop-b= ase.h new file mode 100644 index 0000000000..8e77d8b69f --- /dev/null +++ b/include/sysemu/event-loop-base.h @@ -0,0 +1,36 @@ +/* + * QEMU event-loop backend + * + * Copyright (C) 2022 Red Hat Inc + * + * Authors: + * Nicolas Saenz Julienne + * + * This work is licensed under the terms of the GNU GPL, version 2 or late= r. + * See the COPYING file in the top-level directory. + */ +#ifndef QEMU_EVENT_LOOP_BASE_H +#define QEMU_EVENT_LOOP_BASE_H + +#include "qom/object.h" +#include "block/aio.h" +#include "qemu/typedefs.h" + +#define TYPE_EVENT_LOOP_BASE "event-loop-base" +OBJECT_DECLARE_TYPE(EventLoopBase, EventLoopBaseClass, + EVENT_LOOP_BASE) + +struct EventLoopBaseClass { + ObjectClass parent_class; + + void (*init)(EventLoopBase *base, Error **errp); + void (*update_params)(EventLoopBase *base, Error **errp); +}; + +struct EventLoopBase { + Object parent; + + /* AioContext AIO engine parameters */ + int64_t aio_max_batch; +}; +#endif diff --git a/include/sysemu/iothread.h b/include/sysemu/iothread.h index 7f714bd136..8f8601d6ab 100644 --- a/include/sysemu/iothread.h +++ b/include/sysemu/iothread.h @@ -17,11 +17,12 @@ #include "block/aio.h" #include "qemu/thread.h" #include "qom/object.h" +#include "sysemu/event-loop-base.h" =20 #define TYPE_IOTHREAD "iothread" =20 struct IOThread { - Object parent_obj; + EventLoopBase parent_obj; =20 QemuThread thread; AioContext *ctx; @@ -37,9 +38,6 @@ struct IOThread { int64_t poll_max_ns; int64_t poll_grow; int64_t poll_shrink; - - /* AioContext AIO engine parameters */ - int64_t aio_max_batch; }; typedef struct IOThread IOThread; =20 diff --git a/iothread.c b/iothread.c index 0f98af0f2a..8fa2f3bfb8 100644 --- a/iothread.c +++ b/iothread.c @@ -17,6 +17,7 @@ #include "qemu/module.h" #include "block/aio.h" #include "block/block.h" +#include "sysemu/event-loop-base.h" #include "sysemu/iothread.h" #include "qapi/error.h" #include "qapi/qapi-commands-misc.h" @@ -152,10 +153,15 @@ static void iothread_init_gcontext(IOThread *iothread) iothread->main_loop =3D g_main_loop_new(iothread->worker_context, TRUE= ); } =20 -static void iothread_set_aio_context_params(IOThread *iothread, Error **er= rp) +static void iothread_set_aio_context_params(EventLoopBase *base, Error **e= rrp) { + IOThread *iothread =3D IOTHREAD(base); ERRP_GUARD(); =20 + if (!iothread->ctx) { + return; + } + aio_context_set_poll_params(iothread->ctx, iothread->poll_max_ns, iothread->poll_grow, @@ -166,14 +172,15 @@ static void iothread_set_aio_context_params(IOThread = *iothread, Error **errp) } =20 aio_context_set_aio_params(iothread->ctx, - iothread->aio_max_batch, + iothread->parent_obj.aio_max_batch, errp); } =20 -static void iothread_complete(UserCreatable *obj, Error **errp) + +static void iothread_init(EventLoopBase *base, Error **errp) { Error *local_error =3D NULL; - IOThread *iothread =3D IOTHREAD(obj); + IOThread *iothread =3D IOTHREAD(base); char *thread_name; =20 iothread->stopping =3D false; @@ -189,7 +196,7 @@ static void iothread_complete(UserCreatable *obj, Error= **errp) */ iothread_init_gcontext(iothread); =20 - iothread_set_aio_context_params(iothread, &local_error); + iothread_set_aio_context_params(base, &local_error); if (local_error) { error_propagate(errp, local_error); aio_context_unref(iothread->ctx); @@ -201,7 +208,7 @@ static void iothread_complete(UserCreatable *obj, Error= **errp) * to inherit. */ thread_name =3D g_strdup_printf("IO %s", - object_get_canonical_path_component(OBJECT(obj))); + object_get_canonical_path_component(OBJECT(base))); qemu_thread_create(&iothread->thread, thread_name, iothread_run, iothread, QEMU_THREAD_JOINABLE); g_free(thread_name); @@ -226,9 +233,6 @@ static IOThreadParamInfo poll_grow_info =3D { static IOThreadParamInfo poll_shrink_info =3D { "poll-shrink", offsetof(IOThread, poll_shrink), }; -static IOThreadParamInfo aio_max_batch_info =3D { - "aio-max-batch", offsetof(IOThread, aio_max_batch), -}; =20 static void iothread_get_param(Object *obj, Visitor *v, const char *name, IOThreadParamInfo *info, Error **errp) @@ -288,35 +292,12 @@ static void iothread_set_poll_param(Object *obj, Visi= tor *v, } } =20 -static void iothread_get_aio_param(Object *obj, Visitor *v, - const char *name, void *opaque, Error **errp) -{ - IOThreadParamInfo *info =3D opaque; - - iothread_get_param(obj, v, name, info, errp); -} - -static void iothread_set_aio_param(Object *obj, Visitor *v, - const char *name, void *opaque, Error **errp) -{ - IOThread *iothread =3D IOTHREAD(obj); - IOThreadParamInfo *info =3D opaque; - - if (!iothread_set_param(obj, v, name, info, errp)) { - return; - } - - if (iothread->ctx) { - aio_context_set_aio_params(iothread->ctx, - iothread->aio_max_batch, - errp); - } -} - static void iothread_class_init(ObjectClass *klass, void *class_data) { - UserCreatableClass *ucc =3D USER_CREATABLE_CLASS(klass); - ucc->complete =3D iothread_complete; + EventLoopBaseClass *bc =3D EVENT_LOOP_BASE_CLASS(klass); + + bc->init =3D iothread_init; + bc->update_params =3D iothread_set_aio_context_params; =20 object_class_property_add(klass, "poll-max-ns", "int", iothread_get_poll_param, @@ -330,23 +311,15 @@ static void iothread_class_init(ObjectClass *klass, v= oid *class_data) iothread_get_poll_param, iothread_set_poll_param, NULL, &poll_shrink_info); - object_class_property_add(klass, "aio-max-batch", "int", - iothread_get_aio_param, - iothread_set_aio_param, - NULL, &aio_max_batch_info); } =20 static const TypeInfo iothread_info =3D { .name =3D TYPE_IOTHREAD, - .parent =3D TYPE_OBJECT, + .parent =3D TYPE_EVENT_LOOP_BASE, .class_init =3D iothread_class_init, .instance_size =3D sizeof(IOThread), .instance_init =3D iothread_instance_init, .instance_finalize =3D iothread_instance_finalize, - .interfaces =3D (InterfaceInfo[]) { - {TYPE_USER_CREATABLE}, - {} - }, }; =20 static void iothread_register_types(void) @@ -383,7 +356,7 @@ static int query_one_iothread(Object *object, void *opa= que) info->poll_max_ns =3D iothread->poll_max_ns; info->poll_grow =3D iothread->poll_grow; info->poll_shrink =3D iothread->poll_shrink; - info->aio_max_batch =3D iothread->aio_max_batch; + info->aio_max_batch =3D iothread->parent_obj.aio_max_batch; =20 QAPI_LIST_APPEND(*tail, info); return 0; diff --git a/meson.build b/meson.build index 2d6601467f..281c0691cc 100644 --- a/meson.build +++ b/meson.build @@ -2741,6 +2741,7 @@ subdir('qom') subdir('authz') subdir('crypto') subdir('ui') +subdir('hw') =20 =20 if enable_modules @@ -2748,6 +2749,18 @@ if enable_modules modulecommon =3D declare_dependency(link_whole: libmodulecommon, compile= _args: '-DBUILD_DSO') endif =20 +qom_ss =3D qom_ss.apply(config_host, strict: false) +libqom =3D static_library('qom', qom_ss.sources() + genh, + dependencies: [qom_ss.dependencies()], + name_suffix: 'fa') +qom =3D declare_dependency(link_whole: libqom) + +event_loop_base =3D files('event-loop-base.c') +event_loop_base =3D static_library('event-loop-base', sources: event_loop_= base, + build_by_default: true) +event_loop_base =3D declare_dependency(link_whole: event_loop_base, + dependencies: [qom]) + stub_ss =3D stub_ss.apply(config_all, strict: false) =20 util_ss.add_all(trace_ss) @@ -2834,7 +2847,6 @@ subdir('monitor') subdir('net') subdir('replay') subdir('semihosting') -subdir('hw') subdir('tcg') subdir('fpu') subdir('accel') @@ -2959,13 +2971,6 @@ qemu_syms =3D custom_target('qemu.syms', output: 'qe= mu.syms', capture: true, command: [undefsym, nm, '@INPUT@']) =20 -qom_ss =3D qom_ss.apply(config_host, strict: false) -libqom =3D static_library('qom', qom_ss.sources() + genh, - dependencies: [qom_ss.dependencies()], - name_suffix: 'fa') - -qom =3D declare_dependency(link_whole: libqom) - authz_ss =3D authz_ss.apply(config_host, strict: false) libauthz =3D static_library('authz', authz_ss.sources() + genh, dependencies: [authz_ss.dependencies()], @@ -3018,7 +3023,7 @@ libblockdev =3D static_library('blockdev', blockdev_s= s.sources() + genh, build_by_default: false) =20 blockdev =3D declare_dependency(link_whole: [libblockdev], - dependencies: [block]) + dependencies: [block, event_loop_base]) =20 qmp_ss =3D qmp_ss.apply(config_host, strict: false) libqmp =3D static_library('qmp', qmp_ss.sources() + genh, --=20 2.35.1 From nobody Sat May 18 06:50:38 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=fail; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=fail(p=none dis=none) header.from=redhat.com Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1647440083534684.6012364033547; Wed, 16 Mar 2022 07:14:43 -0700 (PDT) Received: from localhost ([::1]:53206 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1nUUQE-00038t-0w for importer@patchew.org; Wed, 16 Mar 2022 10:14:42 -0400 Received: from eggs.gnu.org ([209.51.188.92]:48000) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1nUU6n-0005Su-CF for qemu-devel@nongnu.org; Wed, 16 Mar 2022 09:54:39 -0400 Received: from us-smtp-delivery-124.mimecast.com ([170.10.129.124]:25463) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1nUU6k-0000cO-Q0 for qemu-devel@nongnu.org; Wed, 16 Mar 2022 09:54:36 -0400 Received: from mail-wm1-f70.google.com (mail-wm1-f70.google.com [209.85.128.70]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id us-mta-85-EWNHfciFNp66-ialHwF1jA-1; Wed, 16 Mar 2022 09:54:31 -0400 Received: by mail-wm1-f70.google.com with SMTP id r64-20020a1c2b43000000b0038b59eb1940so1952193wmr.0 for ; Wed, 16 Mar 2022 06:54:30 -0700 (PDT) Received: from vian.redhat.com ([2a0c:5a80:3506:3400:69b5:c807:1d52:ff67]) by smtp.gmail.com with ESMTPSA id w7-20020a1cf607000000b00389a5390180sm1770157wmc.25.2022.03.16.06.54.28 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 16 Mar 2022 06:54:29 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1647438874; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=o2oHDkXntfXJQYcQDYIHU2biG/79LTv3yT9m6YzK7mg=; b=IspCooUoCJ4wJQ77qv5CGpsw9vUvPiA+Sus+X1LTVZfyGrsuIiB5BCSk1W0RrPVKjqW3jl B1CX29hpv1Le8//OjDEY2eTOxAOrlJ/4NgqXsh6nbogZul0xN1gM+4oYTAG1A/hrAGULa8 LdpcF/dyaNMVhTnYnOhMDcA2cwYV8kw= X-MC-Unique: EWNHfciFNp66-ialHwF1jA-1 X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=o2oHDkXntfXJQYcQDYIHU2biG/79LTv3yT9m6YzK7mg=; b=JqN7uG0VbWZLnGOzdUPeOZPFUqBPWqJ3Ds3o89MHd1JugfQ1VIYvBATBFMk70lZBjQ VpSqV7n7rQDTjf9qWPKxnMudOtV3Ysh24iy7KuYCQj260rbohDtFWfzNAaxQ9XM9dCQr MjP2bjEr5n8XBLJRxSnevQ9H2e1RIODVfNqTyKLODIMCLkmN1RSztYMsEytNNXxnc9Zu DIJVWHVIoMX0SqATv/TD/oCj2TV0GL/S0g4U7tG5XAb6ABB0BpV6FxeRIL36hpNLCOZ4 Q7Dk+Y1M7sCfxbiUhl0YcVeLeiq0nXuoCp+BaaZ51yLmaihoNhOEBAtqbSfDWMUDX7Vv TJ0w== X-Gm-Message-State: AOAM531Jb3rOcNr5ICpjlO63lTdMPpGwVo4fxG/w/d9K/5u/8kOZVKdX pN7k+OuqP8vIxk+2pHooCgWyyohrolGreyRX8reuHIzR6DXD1C79STJ7MkedcM7atERcw9lbDpZ iEnzFoyYFfEOUq/k= X-Received: by 2002:a5d:4a8f:0:b0:1f0:4af2:4e29 with SMTP id o15-20020a5d4a8f000000b001f04af24e29mr35731wrq.519.1647438869976; Wed, 16 Mar 2022 06:54:29 -0700 (PDT) X-Google-Smtp-Source: ABdhPJz9XRrqiTK4yUlFzGasmvX5eicANWWdAHMf72ZcpS7Cjfs5cI6v/UlWZk8HAWNYSKXjUQAIMQ== X-Received: by 2002:a5d:4a8f:0:b0:1f0:4af2:4e29 with SMTP id o15-20020a5d4a8f000000b001f04af24e29mr35708wrq.519.1647438869757; Wed, 16 Mar 2022 06:54:29 -0700 (PDT) From: Nicolas Saenz Julienne To: kwolf@redhat.com, stefanha@redhat.com, berrange@redhat.com Subject: [PATCH v3 2/3] util/main-loop: Introduce the main loop into QOM Date: Wed, 16 Mar 2022 14:53:22 +0100 Message-Id: <20220316135321.142850-3-nsaenzju@redhat.com> X-Mailer: git-send-email 2.35.1 In-Reply-To: <20220316135321.142850-1-nsaenzju@redhat.com> References: <20220316135321.142850-1-nsaenzju@redhat.com> MIME-Version: 1.0 Authentication-Results: relay.mimecast.com; auth=pass smtp.auth=CUSA124A263 smtp.mailfrom=nsaenzju@redhat.com X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=170.10.129.124; envelope-from=nsaenzju@redhat.com; helo=us-smtp-delivery-124.mimecast.com X-Spam_score_int: -21 X-Spam_score: -2.2 X-Spam_bar: -- X-Spam_report: (-2.2 / 5.0 requ) BAYES_00=-1.9, DKIMWL_WL_HIGH=-0.082, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, RCVD_IN_MSPIKE_H4=0.001, RCVD_IN_MSPIKE_WL=0.001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001, T_SCC_BODY_TEXT_LINE=-0.01 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: fam@euphon.net, eduardo@habkost.net, qemu-block@nongnu.org, michael.roth@amd.com, mtosatti@redhat.com, qemu-devel@nongnu.org, armbru@redhat.com, hreitz@redhat.com, pbonzini@redhat.com, Nicolas Saenz Julienne , eblake@redhat.com Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: fail (Header signature does not verify) X-ZM-MESSAGEID: 1647440084831100001 Content-Type: text/plain; charset="utf-8" 'event-loop-base' provides basic property handling for all 'AioContext' based event loops. So let's define a new 'MainLoopClass' that inherits from it. This will permit tweaking the main loop's properties through qapi as well as through the command line using the '-object' keyword[1]. Only one instance of 'MainLoopClass' might be created at any time. 'EventLoopBaseClass' learns a new callback, 'can_be_deleted()' so as to mark 'MainLoop' as non-deletable. [1] For example: -object main-loop,id=3Dmain-loop,aio-max-batch=3D Signed-off-by: Nicolas Saenz Julienne Reviewed-by: Stefan Hajnoczi Acked-by: Markus Armbruster --- Changes since v2: - Fix mainloop's qapi versioning Changes since v1: - Fix json files to differentiate between iothread and main-loop - Use OBJECT_DECLARE_TYPE() - Fix build dependencies event-loop-base.c | 13 ++++++++ include/qemu/main-loop.h | 10 ++++++ include/sysemu/event-loop-base.h | 1 + meson.build | 3 +- qapi/qom.json | 15 +++++++++ util/main-loop.c | 56 ++++++++++++++++++++++++++++++++ 6 files changed, 97 insertions(+), 1 deletion(-) diff --git a/event-loop-base.c b/event-loop-base.c index a924c73a7c..e7f99a6ec8 100644 --- a/event-loop-base.c +++ b/event-loop-base.c @@ -73,10 +73,23 @@ static void event_loop_base_complete(UserCreatable *uc,= Error **errp) } } =20 +static bool event_loop_base_can_be_deleted(UserCreatable *uc) +{ + EventLoopBaseClass *bc =3D EVENT_LOOP_BASE_GET_CLASS(uc); + EventLoopBase *backend =3D EVENT_LOOP_BASE(uc); + + if (bc->can_be_deleted) { + return bc->can_be_deleted(backend); + } + + return true; +} + static void event_loop_base_class_init(ObjectClass *klass, void *class_dat= a) { UserCreatableClass *ucc =3D USER_CREATABLE_CLASS(klass); ucc->complete =3D event_loop_base_complete; + ucc->can_be_deleted =3D event_loop_base_can_be_deleted; =20 object_class_property_add(klass, "aio-max-batch", "int", event_loop_base_get_param, diff --git a/include/qemu/main-loop.h b/include/qemu/main-loop.h index 7a4d6a0920..0aa36a4f17 100644 --- a/include/qemu/main-loop.h +++ b/include/qemu/main-loop.h @@ -26,9 +26,19 @@ #define QEMU_MAIN_LOOP_H =20 #include "block/aio.h" +#include "qom/object.h" +#include "sysemu/event-loop-base.h" =20 #define SIG_IPI SIGUSR1 =20 +#define TYPE_MAIN_LOOP "main-loop" +OBJECT_DECLARE_TYPE(MainLoop, MainLoopClass, MAIN_LOOP) + +struct MainLoop { + EventLoopBase parent_obj; +}; +typedef struct MainLoop MainLoop; + /** * qemu_init_main_loop: Set up the process so that it can run the main loo= p. * diff --git a/include/sysemu/event-loop-base.h b/include/sysemu/event-loop-b= ase.h index 8e77d8b69f..fced4c9fea 100644 --- a/include/sysemu/event-loop-base.h +++ b/include/sysemu/event-loop-base.h @@ -25,6 +25,7 @@ struct EventLoopBaseClass { =20 void (*init)(EventLoopBase *base, Error **errp); void (*update_params)(EventLoopBase *base, Error **errp); + bool (*can_be_deleted)(EventLoopBase *base); }; =20 struct EventLoopBase { diff --git a/meson.build b/meson.build index 281c0691cc..2931904ffe 100644 --- a/meson.build +++ b/meson.build @@ -2769,7 +2769,8 @@ libqemuutil =3D static_library('qemuutil', sources: util_ss.sources() + stub_ss.sources(= ) + genh, dependencies: [util_ss.dependencies(), libm, = threads, glib, socket, malloc, pixman]) qemuutil =3D declare_dependency(link_with: libqemuutil, - sources: genh + version_res) + sources: genh + version_res, + dependencies: [event_loop_base]) =20 if have_system or have_user decodetree =3D generator(find_program('scripts/decodetree.py'), diff --git a/qapi/qom.json b/qapi/qom.json index eeb5395ff3..10800166e8 100644 --- a/qapi/qom.json +++ b/qapi/qom.json @@ -528,6 +528,19 @@ '*poll-shrink': 'int', '*aio-max-batch': 'int' } } =20 +## +# @MainLoopProperties: +# +# Properties for the main-loop object. +# +# @aio-max-batch: maximum number of requests in a batch for the AIO engine, +# 0 means that the engine will use its default (default:0) +# +# Since: 7.1 +## +{ 'struct': 'MainLoopProperties', + 'data': { '*aio-max-batch': 'int' } } + ## # @MemoryBackendProperties: # @@ -818,6 +831,7 @@ { 'name': 'input-linux', 'if': 'CONFIG_LINUX' }, 'iothread', + 'main-loop', { 'name': 'memory-backend-epc', 'if': 'CONFIG_LINUX' }, 'memory-backend-file', @@ -883,6 +897,7 @@ 'input-linux': { 'type': 'InputLinuxProperties', 'if': 'CONFIG_LINUX' }, 'iothread': 'IothreadProperties', + 'main-loop': 'MainLoopProperties', 'memory-backend-epc': { 'type': 'MemoryBackendEpcProperties', 'if': 'CONFIG_LINUX' }, 'memory-backend-file': 'MemoryBackendFileProperties', diff --git a/util/main-loop.c b/util/main-loop.c index 4d5a5b9943..3bf5709374 100644 --- a/util/main-loop.c +++ b/util/main-loop.c @@ -33,6 +33,7 @@ #include "qemu/error-report.h" #include "qemu/queue.h" #include "qemu/compiler.h" +#include "qom/object.h" =20 #ifndef _WIN32 #include @@ -184,6 +185,61 @@ int qemu_init_main_loop(Error **errp) return 0; } =20 +static void main_loop_update_params(EventLoopBase *base, Error **errp) +{ + if (!qemu_aio_context) { + error_setg(errp, "qemu aio context not ready"); + return; + } + + aio_context_set_aio_params(qemu_aio_context, base->aio_max_batch, errp= ); +} + +MainLoop *mloop; + +static void main_loop_init(EventLoopBase *base, Error **errp) +{ + MainLoop *m =3D MAIN_LOOP(base); + + if (mloop) { + error_setg(errp, "only one main-loop instance allowed"); + return; + } + + main_loop_update_params(base, errp); + + mloop =3D m; + return; +} + +static bool main_loop_can_be_deleted(EventLoopBase *base) +{ + return false; +} + +static void main_loop_class_init(ObjectClass *oc, void *class_data) +{ + EventLoopBaseClass *bc =3D EVENT_LOOP_BASE_CLASS(oc); + + bc->init =3D main_loop_init; + bc->update_params =3D main_loop_update_params; + bc->can_be_deleted =3D main_loop_can_be_deleted; +} + +static const TypeInfo main_loop_info =3D { + .name =3D TYPE_MAIN_LOOP, + .parent =3D TYPE_EVENT_LOOP_BASE, + .class_init =3D main_loop_class_init, + .instance_size =3D sizeof(MainLoop), +}; + +static void main_loop_register_types(void) +{ + type_register_static(&main_loop_info); +} + +type_init(main_loop_register_types) + static int max_priority; =20 #ifndef _WIN32 --=20 2.35.1 From nobody Sat May 18 06:50:38 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=fail; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=fail(p=none dis=none) header.from=redhat.com Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1647440593891740.4933687424159; Wed, 16 Mar 2022 07:23:13 -0700 (PDT) Received: from localhost ([::1]:39426 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1nUUYS-0004ea-B6 for importer@patchew.org; Wed, 16 Mar 2022 10:23:12 -0400 Received: from eggs.gnu.org ([209.51.188.92]:48026) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1nUU6o-0005Sw-GS for qemu-devel@nongnu.org; Wed, 16 Mar 2022 09:54:39 -0400 Received: from us-smtp-delivery-124.mimecast.com ([170.10.133.124]:40604) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1nUU6l-0000cX-6J for qemu-devel@nongnu.org; Wed, 16 Mar 2022 09:54:38 -0400 Received: from mail-wm1-f72.google.com (mail-wm1-f72.google.com [209.85.128.72]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id us-mta-108-mYd-AVUJMbGWQ_Eaic7tXg-1; Wed, 16 Mar 2022 09:54:33 -0400 Received: by mail-wm1-f72.google.com with SMTP id k26-20020a05600c0b5a00b0038c6c41159bso1099102wmr.0 for ; Wed, 16 Mar 2022 06:54:32 -0700 (PDT) Received: from vian.redhat.com ([2a0c:5a80:3506:3400:69b5:c807:1d52:ff67]) by smtp.gmail.com with ESMTPSA id w7-20020a1cf607000000b00389a5390180sm1770157wmc.25.2022.03.16.06.54.29 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 16 Mar 2022 06:54:30 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1647438874; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=u7ozu/4+VhkTrjcrfkajs8TEU9K/VQ+aLvhvFCbJ22c=; b=JvSxYQNppXenglDpJURUZ3u9MIM6n60XiptPXCP4vmI2jaa0MXaLmT5bpeYNCPPrO0ae1s 1c+sAnvkv+qAe7IvtwI1YP0CehVB3i0+FJC9FURt3DB4WKlhl09hiNXGFJ3TulEI2iUTpz uHnh5xDq0iuImT+hmnHl3PXzBE1G6NQ= X-MC-Unique: mYd-AVUJMbGWQ_Eaic7tXg-1 X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=u7ozu/4+VhkTrjcrfkajs8TEU9K/VQ+aLvhvFCbJ22c=; b=3HKQ3cN9vBdbrvsJiByzuYE3sU3AO4cvrsQuhzpXeW4hjdB/cDKRbA5+axdQrZqvVZ eMU+tjejwUbojDwBmNg/v1a0TMEwmuYpeANkzfe0gOQO/cyf/x/IRr0BVWZB8fHf4dbL G9pDrImW8q1OXrFBnh4ZKeQm/yEi0eB+yXu/O6PsPHBmoC1i34BSsESuA9yvSJnhK8fp 1tzoNpLYzwAHmWZV9Agxj4vwIdvDSagLOrXo+aezKi9EexziLB4+HZqDnvNdBWEfpfSF ZTOjU+xZk5tJdoEFycv1PhcH8V/FAmuAUqxIDvFRJGhm9yA82Dy1oRIBUUS6HTdoc8W3 6VUA== X-Gm-Message-State: AOAM530sq+TebyA8Dl3yFJFtR/PZpvZQmenEJsHZWawIOdsQJOXKRGGj 00yDahYnHoBlfvk8TwN3nkhWJ7kyh/E1w6vmM4LZkS25RUQhDehR1u6nkZx5YvTpQuMpGniONJu NgOG5qeSjO+FO4vk= X-Received: by 2002:adf:f6d0:0:b0:1f0:7ab4:f905 with SMTP id y16-20020adff6d0000000b001f07ab4f905mr113022wrp.54.1647438870990; Wed, 16 Mar 2022 06:54:30 -0700 (PDT) X-Google-Smtp-Source: ABdhPJz7J89kJnVem/EB3lW2CgZdtK00EbbpWqKHNL2g156XdojWvfNeNriMyY1WMXf+5tPdDyeafw== X-Received: by 2002:adf:f6d0:0:b0:1f0:7ab4:f905 with SMTP id y16-20020adff6d0000000b001f07ab4f905mr113005wrp.54.1647438870731; Wed, 16 Mar 2022 06:54:30 -0700 (PDT) From: Nicolas Saenz Julienne To: kwolf@redhat.com, stefanha@redhat.com, berrange@redhat.com Subject: [PATCH v3 3/3] util/event-loop-base: Introduce options to set the thread pool size Date: Wed, 16 Mar 2022 14:53:23 +0100 Message-Id: <20220316135321.142850-4-nsaenzju@redhat.com> X-Mailer: git-send-email 2.35.1 In-Reply-To: <20220316135321.142850-1-nsaenzju@redhat.com> References: <20220316135321.142850-1-nsaenzju@redhat.com> MIME-Version: 1.0 Authentication-Results: relay.mimecast.com; auth=pass smtp.auth=CUSA124A263 smtp.mailfrom=nsaenzju@redhat.com X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=170.10.133.124; envelope-from=nsaenzju@redhat.com; helo=us-smtp-delivery-124.mimecast.com X-Spam_score_int: -21 X-Spam_score: -2.2 X-Spam_bar: -- X-Spam_report: (-2.2 / 5.0 requ) BAYES_00=-1.9, DKIMWL_WL_HIGH=-0.082, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, RCVD_IN_MSPIKE_H5=0.001, RCVD_IN_MSPIKE_WL=0.001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001, T_SCC_BODY_TEXT_LINE=-0.01 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: fam@euphon.net, eduardo@habkost.net, qemu-block@nongnu.org, michael.roth@amd.com, mtosatti@redhat.com, qemu-devel@nongnu.org, armbru@redhat.com, hreitz@redhat.com, pbonzini@redhat.com, Nicolas Saenz Julienne , eblake@redhat.com Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: fail (Header signature does not verify) X-ZM-MESSAGEID: 1647440595051100001 Content-Type: text/plain; charset="utf-8" The thread pool regulates itself: when idle, it kills threads until empty, when in demand, it creates new threads until full. This behaviour doesn't play well with latency sensitive workloads where the price of creating a new thread is too high. For example, when paired with qemu's '-mlock', or using safety features like SafeStack, creating a new thread has been measured take multiple milliseconds. In order to mitigate this let's introduce a new 'EventLoopBase' property to set the thread pool size. The threads will be created during the pool's initialization or upon updating the property's value, remain available during its lifetime regardless of demand, and destroyed upon freeing it. A properly characterized workload will then be able to configure the pool to avoid any latency spikes. Signed-off-by: Nicolas Saenz Julienne Reviewed-by: Stefan Hajnoczi --- Changes since v2: - Don't wait when decreasing pool size - Fix qapi versioning Changes since v1: - Add INT_MAX check - Have copy of thread pool sizes in AioContext to properly decouple both instances - More coherent variable naming - Handle case where max_threads decreases - Code comments event-loop-base.c | 23 +++++++++++++ include/block/aio.h | 10 ++++++ include/block/thread-pool.h | 3 ++ include/sysemu/event-loop-base.h | 4 +++ iothread.c | 3 ++ qapi/qom.json | 21 ++++++++++-- util/aio-posix.c | 1 + util/async.c | 20 ++++++++++++ util/main-loop.c | 9 ++++++ util/thread-pool.c | 55 +++++++++++++++++++++++++++++--- 10 files changed, 143 insertions(+), 6 deletions(-) diff --git a/event-loop-base.c b/event-loop-base.c index e7f99a6ec8..d5be4dc6fc 100644 --- a/event-loop-base.c +++ b/event-loop-base.c @@ -14,6 +14,7 @@ #include "qemu/osdep.h" #include "qom/object_interfaces.h" #include "qapi/error.h" +#include "block/thread-pool.h" #include "sysemu/event-loop-base.h" =20 typedef struct { @@ -21,9 +22,22 @@ typedef struct { ptrdiff_t offset; /* field's byte offset in EventLoopBase struct */ } EventLoopBaseParamInfo; =20 +static void event_loop_base_instance_init(Object *obj) +{ + EventLoopBase *base =3D EVENT_LOOP_BASE(obj); + + base->thread_pool_max =3D THREAD_POOL_MAX_THREADS_DEFAULT; +} + static EventLoopBaseParamInfo aio_max_batch_info =3D { "aio-max-batch", offsetof(EventLoopBase, aio_max_batch), }; +static EventLoopBaseParamInfo thread_pool_min_info =3D { + "thread-pool-min", offsetof(EventLoopBase, thread_pool_min), +}; +static EventLoopBaseParamInfo thread_pool_max_info =3D { + "thread-pool-max", offsetof(EventLoopBase, thread_pool_max), +}; =20 static void event_loop_base_get_param(Object *obj, Visitor *v, const char *name, void *opaque, Error **errp) @@ -95,12 +109,21 @@ static void event_loop_base_class_init(ObjectClass *kl= ass, void *class_data) event_loop_base_get_param, event_loop_base_set_param, NULL, &aio_max_batch_info); + object_class_property_add(klass, "thread-pool-min", "int", + event_loop_base_get_param, + event_loop_base_set_param, + NULL, &thread_pool_min_info); + object_class_property_add(klass, "thread-pool-max", "int", + event_loop_base_get_param, + event_loop_base_set_param, + NULL, &thread_pool_max_info); } =20 static const TypeInfo event_loop_base_info =3D { .name =3D TYPE_EVENT_LOOP_BASE, .parent =3D TYPE_OBJECT, .instance_size =3D sizeof(EventLoopBase), + .instance_init =3D event_loop_base_instance_init, .class_size =3D sizeof(EventLoopBaseClass), .class_init =3D event_loop_base_class_init, .abstract =3D true, diff --git a/include/block/aio.h b/include/block/aio.h index 5634173b12..d128558f1d 100644 --- a/include/block/aio.h +++ b/include/block/aio.h @@ -192,6 +192,8 @@ struct AioContext { QSLIST_HEAD(, Coroutine) scheduled_coroutines; QEMUBH *co_schedule_bh; =20 + int thread_pool_min; + int thread_pool_max; /* Thread pool for performing work and receiving completion callbacks. * Has its own locking. */ @@ -769,4 +771,12 @@ void aio_context_set_poll_params(AioContext *ctx, int6= 4_t max_ns, void aio_context_set_aio_params(AioContext *ctx, int64_t max_batch, Error **errp); =20 +/** + * aio_context_set_thread_pool_params: + * @ctx: the aio context + * @min: min number of threads to have readily available in the thread pool + * @min: max number of threads the thread pool can contain + */ +void aio_context_set_thread_pool_params(AioContext *ctx, int64_t min, + int64_t max, Error **errp); #endif diff --git a/include/block/thread-pool.h b/include/block/thread-pool.h index 7dd7d730a0..2020bcc92d 100644 --- a/include/block/thread-pool.h +++ b/include/block/thread-pool.h @@ -20,6 +20,8 @@ =20 #include "block/block.h" =20 +#define THREAD_POOL_MAX_THREADS_DEFAULT 64 + typedef int ThreadPoolFunc(void *opaque); =20 typedef struct ThreadPool ThreadPool; @@ -33,5 +35,6 @@ BlockAIOCB *thread_pool_submit_aio(ThreadPool *pool, int coroutine_fn thread_pool_submit_co(ThreadPool *pool, ThreadPoolFunc *func, void *arg); void thread_pool_submit(ThreadPool *pool, ThreadPoolFunc *func, void *arg); +void thread_pool_update_params(ThreadPool *pool, struct AioContext *ctx); =20 #endif diff --git a/include/sysemu/event-loop-base.h b/include/sysemu/event-loop-b= ase.h index fced4c9fea..2748bf6ae1 100644 --- a/include/sysemu/event-loop-base.h +++ b/include/sysemu/event-loop-base.h @@ -33,5 +33,9 @@ struct EventLoopBase { =20 /* AioContext AIO engine parameters */ int64_t aio_max_batch; + + /* AioContext thread pool parameters */ + int64_t thread_pool_min; + int64_t thread_pool_max; }; #endif diff --git a/iothread.c b/iothread.c index 8fa2f3bfb8..529194a566 100644 --- a/iothread.c +++ b/iothread.c @@ -174,6 +174,9 @@ static void iothread_set_aio_context_params(EventLoopBa= se *base, Error **errp) aio_context_set_aio_params(iothread->ctx, iothread->parent_obj.aio_max_batch, errp); + + aio_context_set_thread_pool_params(iothread->ctx, base->thread_pool_mi= n, + base->thread_pool_max, errp); } =20 =20 diff --git a/qapi/qom.json b/qapi/qom.json index 10800166e8..b54fafebf5 100644 --- a/qapi/qom.json +++ b/qapi/qom.json @@ -520,13 +520,22 @@ # 0 means that the engine will use its default # (default:0, since 6.1) # +# @thread-pool-min: minimum number of threads readily available in the thr= ead +# pool +# (default:0, since 7.1) +# +# @thread-pool-max: maximum number of threads the thread pool can contain +# (default:64, since 7.1) +# # Since: 2.0 ## { 'struct': 'IothreadProperties', 'data': { '*poll-max-ns': 'int', '*poll-grow': 'int', '*poll-shrink': 'int', - '*aio-max-batch': 'int' } } + '*aio-max-batch': 'int', + '*thread-pool-min': 'int', + '*thread-pool-max': 'int' } } =20 ## # @MainLoopProperties: @@ -536,10 +545,18 @@ # @aio-max-batch: maximum number of requests in a batch for the AIO engine, # 0 means that the engine will use its default (default:0) # +# @thread-pool-min: minimum number of threads readily available in the thr= ead +# pool (default:0) +# +# @thread-pool-max: maximum number of threads the thread pool can contain +# (default:64) +# # Since: 7.1 ## { 'struct': 'MainLoopProperties', - 'data': { '*aio-max-batch': 'int' } } + 'data': { '*aio-max-batch': 'int', + '*thread-pool-min': 'int', + '*thread-pool-max': 'int' } } =20 ## # @MemoryBackendProperties: diff --git a/util/aio-posix.c b/util/aio-posix.c index 7b9f629218..926e6dafba 100644 --- a/util/aio-posix.c +++ b/util/aio-posix.c @@ -15,6 +15,7 @@ =20 #include "qemu/osdep.h" #include "block/block.h" +#include "block/thread-pool.h" #include "qemu/main-loop.h" #include "qemu/rcu.h" #include "qemu/rcu_queue.h" diff --git a/util/async.c b/util/async.c index 2ea1172f3e..554ba70cca 100644 --- a/util/async.c +++ b/util/async.c @@ -563,6 +563,9 @@ AioContext *aio_context_new(Error **errp) =20 ctx->aio_max_batch =3D 0; =20 + ctx->thread_pool_min =3D 0; + ctx->thread_pool_max =3D THREAD_POOL_MAX_THREADS_DEFAULT; + return ctx; fail: g_source_destroy(&ctx->source); @@ -696,3 +699,20 @@ void qemu_set_current_aio_context(AioContext *ctx) assert(!get_my_aiocontext()); set_my_aiocontext(ctx); } + +void aio_context_set_thread_pool_params(AioContext *ctx, int64_t min, + int64_t max, Error **errp) +{ + + if (min > max || !max || min > INT_MAX || max > INT_MAX) { + error_setg(errp, "bad thread-pool-min/thread-pool-max values"); + return; + } + + ctx->thread_pool_min =3D min; + ctx->thread_pool_max =3D max; + + if (ctx->thread_pool) { + thread_pool_update_params(ctx->thread_pool, ctx); + } +} diff --git a/util/main-loop.c b/util/main-loop.c index 3bf5709374..ae02afb0f8 100644 --- a/util/main-loop.c +++ b/util/main-loop.c @@ -30,6 +30,7 @@ #include "sysemu/replay.h" #include "qemu/main-loop.h" #include "block/aio.h" +#include "block/thread-pool.h" #include "qemu/error-report.h" #include "qemu/queue.h" #include "qemu/compiler.h" @@ -187,12 +188,20 @@ int qemu_init_main_loop(Error **errp) =20 static void main_loop_update_params(EventLoopBase *base, Error **errp) { + ERRP_GUARD(); + if (!qemu_aio_context) { error_setg(errp, "qemu aio context not ready"); return; } =20 aio_context_set_aio_params(qemu_aio_context, base->aio_max_batch, errp= ); + if (*errp) { + return; + } + + aio_context_set_thread_pool_params(qemu_aio_context, base->thread_pool= _min, + base->thread_pool_max, errp); } =20 MainLoop *mloop; diff --git a/util/thread-pool.c b/util/thread-pool.c index d763cea505..d91819749a 100644 --- a/util/thread-pool.c +++ b/util/thread-pool.c @@ -58,7 +58,6 @@ struct ThreadPool { QemuMutex lock; QemuCond worker_stopped; QemuSemaphore sem; - int max_threads; QEMUBH *new_thread_bh; =20 /* The following variables are only accessed from one AioContext. */ @@ -71,8 +70,27 @@ struct ThreadPool { int new_threads; /* backlog of threads we need to create */ int pending_threads; /* threads created but not running yet */ bool stopping; + int min_threads; + int max_threads; }; =20 +static inline bool back_to_sleep(ThreadPool *pool, int ret) +{ + /* + * The semaphore timed out, we should exit the loop except when: + * - There is work to do, we raced with the signal. + * - The max threads threshold just changed, we raced with the signal. + * - The thread pool forces a minimum number of readily available thr= eads. + */ + if (ret =3D=3D -1 && (!QTAILQ_EMPTY(&pool->request_list) || + pool->cur_threads > pool->max_threads || + pool->cur_threads <=3D pool->min_threads)) { + return true; + } + + return false; +} + static void *worker_thread(void *opaque) { ThreadPool *pool =3D opaque; @@ -91,8 +109,9 @@ static void *worker_thread(void *opaque) ret =3D qemu_sem_timedwait(&pool->sem, 10000); qemu_mutex_lock(&pool->lock); pool->idle_threads--; - } while (ret =3D=3D -1 && !QTAILQ_EMPTY(&pool->request_list)); - if (ret =3D=3D -1 || pool->stopping) { + } while (back_to_sleep(pool, ret)); + if (ret =3D=3D -1 || pool->stopping || + pool->cur_threads > pool->max_threads) { break; } =20 @@ -294,6 +313,33 @@ void thread_pool_submit(ThreadPool *pool, ThreadPoolFu= nc *func, void *arg) thread_pool_submit_aio(pool, func, arg, NULL, NULL); } =20 +void thread_pool_update_params(ThreadPool *pool, AioContext *ctx) +{ + qemu_mutex_lock(&pool->lock); + + pool->min_threads =3D ctx->thread_pool_min; + pool->max_threads =3D ctx->thread_pool_max; + + /* + * We either have to: + * - Increase the number available of threads until over the min_thre= ads + * threshold. + * - Decrease the number of available threads until under the max_thr= eads + * threshold. + * - Do nothing. The current number of threads fall in between the mi= n and + * max thresholds. We'll let the pool manage itself. + */ + for (int i =3D pool->cur_threads; i < pool->min_threads; i++) { + spawn_thread(pool); + } + + for (int i =3D pool->cur_threads; i > pool->max_threads; i--) { + qemu_sem_post(&pool->sem); + } + + qemu_mutex_unlock(&pool->lock); +} + static void thread_pool_init_one(ThreadPool *pool, AioContext *ctx) { if (!ctx) { @@ -306,11 +352,12 @@ static void thread_pool_init_one(ThreadPool *pool, Ai= oContext *ctx) qemu_mutex_init(&pool->lock); qemu_cond_init(&pool->worker_stopped); qemu_sem_init(&pool->sem, 0); - pool->max_threads =3D 64; pool->new_thread_bh =3D aio_bh_new(ctx, spawn_thread_bh_fn, pool); =20 QLIST_INIT(&pool->head); QTAILQ_INIT(&pool->request_list); + + thread_pool_update_params(pool, ctx); } =20 ThreadPool *thread_pool_new(AioContext *ctx) --=20 2.35.1