The following changes since commit 554623226f800acf48a2ed568900c1c968ec9a8b:

Merge tag 'qemu-sparc-20220508' of https://github.com/mcayland/qemu into staging (2022-05-08 17:03:26 -0500)

for you to fetch changes up to 3dc584abeef0e1277c2de8c1c1974cb49444eb0a:

virtio-scsi: move request-related items from .h to .c (2022-05-09 10:45:04 +0100)

Nicolas Saenz Julienne (3):

Introduce event-loop-base abstract class

util/main-loop: Introduce the main loop into QOM

util/event-loop-base: Introduce options to set the thread pool size

Stefan Hajnoczi (6):

virtio-scsi: fix ctrl and event handler functions in dataplane mode

virtio-scsi: don't waste CPU polling the event virtqueue

virtio-scsi: clean up virtio_scsi_handle_event_vq()

virtio-scsi: clean up virtio_scsi_handle_ctrl_vq()

virtio-scsi: clean up virtio_scsi_handle_cmd_vq()

virtio-scsi: move request-related items from .h to .c

qapi/qom.json | 43 ++++++++--

meson.build | 26 +++---

include/block/aio.h | 10 +++

include/block/thread-pool.h | 3 +

include/hw/virtio/virtio-scsi.h | 43 ----------

include/hw/virtio/virtio.h | 1 +

include/qemu/main-loop.h | 10 +++

include/sysemu/event-loop-base.h | 41 +++++++++

include/sysemu/iothread.h | 6 +-

event-loop-base.c | 140 +++++++++++++++++++++++++++++++

hw/scsi/virtio-scsi-dataplane.c | 2 +-

hw/scsi/virtio-scsi.c | 101 +++++++++++++++-------

hw/virtio/virtio.c | 13 +++

iothread.c | 68 +++++----------

util/aio-posix.c | 1 +

util/async.c | 20 +++++

util/main-loop.c | 65 ++++++++++++++

util/thread-pool.c | 55 +++++++++++-

18 files changed, 505 insertions(+), 143 deletions(-)

create mode 100644 include/sysemu/event-loop-base.h

create mode 100644 event-loop-base.c

2.35.1

From: Nicolas Saenz Julienne <nsaenzju@redhat.com>

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 <nsaenzju@redhat.com>

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>

Acked-by: Markus Armbruster <armbru@redhat.com>

Message-id: 20220425075723.20019-2-nsaenzju@redhat.com

qapi/qom.json | 22 +++++--

meson.build | 23 ++++---

include/sysemu/event-loop-base.h | 36 +++++++++++

include/sysemu/iothread.h | 6 +-

event-loop-base.c | 104 +++++++++++++++++++++++++++++++

iothread.c | 65 ++++++-------------

6 files changed, 192 insertions(+), 64 deletions(-)

create mode 100644 include/sysemu/event-loop-base.h

create mode 100644 event-loop-base.c

diff --git a/qapi/qom.json b/qapi/qom.json

index XXXXXXX..XXXXXXX 100644

--- a/qapi/qom.json

+++ b/qapi/qom.json

@@ -XXX,XX +XXX,XX @@

'*repeat': 'bool',

'*grab-toggle': 'GrabToggleKeys' } }

+##

+# @EventLoopBaseProperties:

+#

+# Common properties for event loops

+#

+# @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': 'EventLoopBaseProperties',

+ 'data': { '*aio-max-batch': 'int' } }

+

##

# @IothreadProperties:

#

@@ -XXX,XX +XXX,XX @@

# algorithm detects it is spending too long polling without

# encountering events. 0 selects a default behaviour (default: 0)

#

-# @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 6.1)

+# The @aio-max-batch option is available since 6.1.

#

# Since: 2.0

##

{ 'struct': 'IothreadProperties',

+ 'base': 'EventLoopBaseProperties',

'data': { '*poll-max-ns': 'int',

'*poll-grow': 'int',

- '*poll-shrink': 'int',

- '*aio-max-batch': 'int' } }

+ '*poll-shrink': 'int' } }

##

# @MemoryBackendProperties:

diff --git a/meson.build b/meson.build

index XXXXXXX..XXXXXXX 100644

--- a/meson.build

+++ b/meson.build

@@ -XXX,XX +XXX,XX @@ subdir('qom')

subdir('authz')

subdir('crypto')

subdir('ui')

+subdir('hw')

if enable_modules

@@ -XXX,XX +XXX,XX @@ if enable_modules

modulecommon = declare_dependency(link_whole: libmodulecommon, compile_args: '-DBUILD_DSO')

endif

+qom_ss = qom_ss.apply(config_host, strict: false)

+libqom = static_library('qom', qom_ss.sources() + genh,

+ dependencies: [qom_ss.dependencies()],

+ name_suffix: 'fa')

+qom = declare_dependency(link_whole: libqom)

+

+event_loop_base = files('event-loop-base.c')

+event_loop_base = static_library('event-loop-base', sources: event_loop_base + genh,

+ build_by_default: true)

+event_loop_base = declare_dependency(link_whole: event_loop_base,

+ dependencies: [qom])

+

stub_ss = stub_ss.apply(config_all, strict: false)

util_ss.add_all(trace_ss)

@@ -XXX,XX +XXX,XX @@ subdir('monitor')

subdir('net')

subdir('replay')

subdir('semihosting')

-subdir('hw')

subdir('tcg')

subdir('fpu')

subdir('accel')

@@ -XXX,XX +XXX,XX @@ qemu_syms = custom_target('qemu.syms', output: 'qemu.syms',

capture: true,

command: [undefsym, nm, '@INPUT@'])

-qom_ss = qom_ss.apply(config_host, strict: false)

-libqom = static_library('qom', qom_ss.sources() + genh,

- dependencies: [qom_ss.dependencies()],

- name_suffix: 'fa')

-

-qom = declare_dependency(link_whole: libqom)

-

authz_ss = authz_ss.apply(config_host, strict: false)

libauthz = static_library('authz', authz_ss.sources() + genh,

dependencies: [authz_ss.dependencies()],

@@ -XXX,XX +XXX,XX @@ libblockdev = static_library('blockdev', blockdev_ss.sources() + genh,

build_by_default: false)

blockdev = declare_dependency(link_whole: [libblockdev],

- dependencies: [block])

+ dependencies: [block, event_loop_base])

qmp_ss = qmp_ss.apply(config_host, strict: false)

libqmp = static_library('qmp', qmp_ss.sources() + genh,

diff --git a/include/sysemu/event-loop-base.h b/include/sysemu/event-loop-base.h

new file mode 100644

index XXXXXXX..XXXXXXX

--- /dev/null

+++ b/include/sysemu/event-loop-base.h

@@ -XXX,XX +XXX,XX @@

+/*

+ * QEMU event-loop backend

+ *

+ * Copyright (C) 2022 Red Hat Inc

+ *

+ * Authors:

+ * Nicolas Saenz Julienne <nsaenzju@redhat.com>

+ *

+ * This work is licensed under the terms of the GNU GPL, version 2 or later.

+ * 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 XXXXXXX..XXXXXXX 100644

--- a/include/sysemu/iothread.h

+++ b/include/sysemu/iothread.h

@@ -XXX,XX +XXX,XX @@

#include "block/aio.h"

#include "qemu/thread.h"

#include "qom/object.h"

+#include "sysemu/event-loop-base.h"

#define TYPE_IOTHREAD "iothread"

struct IOThread {

- Object parent_obj;

+ EventLoopBase parent_obj;

QemuThread thread;

AioContext *ctx;

@@ -XXX,XX +XXX,XX @@ 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;

diff --git a/event-loop-base.c b/event-loop-base.c

new file mode 100644

index XXXXXXX..XXXXXXX

--- /dev/null

+++ b/event-loop-base.c

@@ -XXX,XX +XXX,XX @@

+/*

+ * QEMU event-loop base

+ *

+ * Copyright (C) 2022 Red Hat Inc

+ *

+ * Authors:

+ * Stefan Hajnoczi <stefanha@redhat.com>

+ * Nicolas Saenz Julienne <nsaenzju@redhat.com>

+ *

+ * This work is licensed under the terms of the GNU GPL, version 2 or later.

+ * 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 = {

+ "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 = EVENT_LOOP_BASE(obj);

+ EventLoopBaseParamInfo *info = opaque;

+ int64_t *field = (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 = EVENT_LOOP_BASE_GET_CLASS(obj);

+ EventLoopBase *base = EVENT_LOOP_BASE(obj);

+ EventLoopBaseParamInfo *info = opaque;

+ int64_t *field = (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 = value;

+

+ if (bc->update_params) {

+ bc->update_params(base, errp);

+ }

+

+ return;

+}

+

+static void event_loop_base_complete(UserCreatable *uc, Error **errp)

+{

+ EventLoopBaseClass *bc = EVENT_LOOP_BASE_GET_CLASS(uc);

+ EventLoopBase *base = EVENT_LOOP_BASE(uc);

+

+ if (bc->init) {

+ bc->init(base, errp);

+ }

+}

+

+static void event_loop_base_class_init(ObjectClass *klass, void *class_data)

+{

+ UserCreatableClass *ucc = USER_CREATABLE_CLASS(klass);

+ ucc->complete = 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 = {

+ .name = TYPE_EVENT_LOOP_BASE,

+ .parent = TYPE_OBJECT,

+ .instance_size = sizeof(EventLoopBase),

+ .class_size = sizeof(EventLoopBaseClass),

+ .class_init = event_loop_base_class_init,

+ .abstract = true,

+ .interfaces = (InterfaceInfo[]) {

+ { TYPE_USER_CREATABLE },

+ { }

+ }

+};

+

+static void register_types(void)

+{

+ type_register_static(&event_loop_base_info);

+}

+type_init(register_types);

*/

iothread_init_gcontext(iothread);

- 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);

@@ -XXX,XX +XXX,XX @@ static void iothread_complete(UserCreatable *obj, Error **errp)

* to inherit.

*/

thread_name = 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);

@@ -XXX,XX +XXX,XX @@ static IOThreadParamInfo poll_grow_info = {

static IOThreadParamInfo poll_shrink_info = {

-static IOThreadParamInfo aio_max_batch_info = {

- "aio-max-batch", offsetof(IOThread, aio_max_batch),

-};

static void iothread_get_param(Object *obj, Visitor *v,

const char *name, IOThreadParamInfo *info, Error **errp)

@@ -XXX,XX +XXX,XX @@ static void iothread_set_poll_param(Object *obj, Visitor *v,

}

}

-static void iothread_get_aio_param(Object *obj, Visitor *v,

- const char *name, void *opaque, Error **errp)

-{

- IOThreadParamInfo *info = 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 = IOTHREAD(obj);

- IOThreadParamInfo *info = 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 = USER_CREATABLE_CLASS(klass);

- ucc->complete = iothread_complete;

+ EventLoopBaseClass *bc = EVENT_LOOP_BASE_CLASS(klass);

+

+ bc->init = iothread_init;

+ bc->update_params = iothread_set_aio_context_params;

object_class_property_add(klass, "poll-max-ns", "int",

iothread_get_poll_param,

@@ -XXX,XX +XXX,XX @@ static void iothread_class_init(ObjectClass *klass, void *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);

}

static const TypeInfo iothread_info = {

.name = TYPE_IOTHREAD,

- .parent = TYPE_OBJECT,

+ .parent = TYPE_EVENT_LOOP_BASE,

.class_init = iothread_class_init,

.instance_size = sizeof(IOThread),

.instance_init = iothread_instance_init,

.instance_finalize = iothread_instance_finalize,

- .interfaces = (InterfaceInfo[]) {

- {TYPE_USER_CREATABLE},

- {}

- },

static void iothread_register_types(void)

@@ -XXX,XX +XXX,XX @@ static int query_one_iothread(Object *object, void *opaque)

info->poll_max_ns = iothread->poll_max_ns;

info->poll_grow = iothread->poll_grow;

info->poll_shrink = iothread->poll_shrink;

- info->aio_max_batch = iothread->aio_max_batch;

+ info->aio_max_batch = iothread->parent_obj.aio_max_batch;

QAPI_LIST_APPEND(*tail, info);

return 0;

2.35.1

From: Nicolas Saenz Julienne <nsaenzju@redhat.com>

'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=main-loop,aio-max-batch=<value>

Signed-off-by: Nicolas Saenz Julienne <nsaenzju@redhat.com>

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>

Acked-by: Markus Armbruster <armbru@redhat.com>

Message-id: 20220425075723.20019-3-nsaenzju@redhat.com

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>

---

qapi/qom.json | 13 ++++++++

meson.build | 3 +-

include/qemu/main-loop.h | 10 ++++++

include/sysemu/event-loop-base.h | 1 +

event-loop-base.c | 13 ++++++++

util/main-loop.c | 56 ++++++++++++++++++++++++++++++++

6 files changed, 95 insertions(+), 1 deletion(-)

diff --git a/qapi/qom.json b/qapi/qom.json

index XXXXXXX..XXXXXXX 100644

--- a/qapi/qom.json

+++ b/qapi/qom.json

@@ -XXX,XX +XXX,XX @@

'*poll-grow': 'int',

'*poll-shrink': 'int' } }

+##

+# @MainLoopProperties:

+#

+# Properties for the main-loop object.

+#

+# Since: 7.1

+##

+{ 'struct': 'MainLoopProperties',

+ 'base': 'EventLoopBaseProperties',

+ 'data': {} }

+

##

# @MemoryBackendProperties:

#

@@ -XXX,XX +XXX,XX @@

{ 'name': 'input-linux',

'if': 'CONFIG_LINUX' },

'iothread',

+ 'main-loop',

{ 'name': 'memory-backend-epc',

'if': 'CONFIG_LINUX' },

'memory-backend-file',

@@ -XXX,XX +XXX,XX @@

'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/meson.build b/meson.build

index XXXXXXX..XXXXXXX 100644

--- a/meson.build

+++ b/meson.build

@@ -XXX,XX +XXX,XX @@ libqemuutil = static_library('qemuutil',

sources: util_ss.sources() + stub_ss.sources() + genh,

dependencies: [util_ss.dependencies(), libm, threads, glib, socket, malloc, pixman])

qemuutil = declare_dependency(link_with: libqemuutil,

- sources: genh + version_res)

+ sources: genh + version_res,

+ dependencies: [event_loop_base])

if have_system or have_user

decodetree = generator(find_program('scripts/decodetree.py'),

diff --git a/include/qemu/main-loop.h b/include/qemu/main-loop.h

index XXXXXXX..XXXXXXX 100644

--- a/include/qemu/main-loop.h

+++ b/include/qemu/main-loop.h

@@ -XXX,XX +XXX,XX @@

#define QEMU_MAIN_LOOP_H

#include "block/aio.h"

+#include "qom/object.h"

+#include "sysemu/event-loop-base.h"

#define SIG_IPI SIGUSR1

+#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 loop.

*

diff --git a/include/sysemu/event-loop-base.h b/include/sysemu/event-loop-base.h

index XXXXXXX..XXXXXXX 100644

--- a/include/sysemu/event-loop-base.h

+++ b/include/sysemu/event-loop-base.h

@@ -XXX,XX +XXX,XX @@ struct EventLoopBaseClass {

void (*init)(EventLoopBase *base, Error **errp);

void (*update_params)(EventLoopBase *base, Error **errp);

+ bool (*can_be_deleted)(EventLoopBase *base);

};

struct EventLoopBase {

diff --git a/event-loop-base.c b/event-loop-base.c

index XXXXXXX..XXXXXXX 100644

--- a/event-loop-base.c

+++ b/event-loop-base.c

@@ -XXX,XX +XXX,XX @@ static void event_loop_base_complete(UserCreatable *uc, Error **errp)

}

}

+static bool event_loop_base_can_be_deleted(UserCreatable *uc)

+{

+ EventLoopBaseClass *bc = EVENT_LOOP_BASE_GET_CLASS(uc);

+ EventLoopBase *backend = 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_data)

{

UserCreatableClass *ucc = USER_CREATABLE_CLASS(klass);

ucc->complete = event_loop_base_complete;

+ ucc->can_be_deleted = event_loop_base_can_be_deleted;

object_class_property_add(klass, "aio-max-batch", "int",

event_loop_base_get_param,

diff --git a/util/main-loop.c b/util/main-loop.c

index XXXXXXX..XXXXXXX 100644

--- a/util/main-loop.c

+++ b/util/main-loop.c

@@ -XXX,XX +XXX,XX @@

#include "qemu/error-report.h"

#include "qemu/queue.h"

#include "qemu/compiler.h"

+#include "qom/object.h"

#ifndef _WIN32

#include <sys/wait.h>

@@ -XXX,XX +XXX,XX @@ int qemu_init_main_loop(Error **errp)

return 0;

}

+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 = MAIN_LOOP(base);

+

+ if (mloop) {

+ error_setg(errp, "only one main-loop instance allowed");

+ return;

+ }

+

+ main_loop_update_params(base, errp);

+

+ mloop = 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 = EVENT_LOOP_BASE_CLASS(oc);

+

+ bc->init = main_loop_init;

+ bc->update_params = main_loop_update_params;

+ bc->can_be_deleted = main_loop_can_be_deleted;

+}

+

+static const TypeInfo main_loop_info = {

+ .name = TYPE_MAIN_LOOP,

+ .parent = TYPE_EVENT_LOOP_BASE,

+ .class_init = main_loop_class_init,

+ .instance_size = 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;

#ifndef _WIN32

--

2.35.1

From: Nicolas Saenz Julienne <nsaenzju@redhat.com>

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 <nsaenzju@redhat.com>

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>

Acked-by: Markus Armbruster <armbru@redhat.com>

Message-id: 20220425075723.20019-4-nsaenzju@redhat.com

qapi/qom.json | 10 +++++-

include/block/aio.h | 10 ++++++

include/block/thread-pool.h | 3 ++

include/sysemu/event-loop-base.h | 4 +++

event-loop-base.c | 23 +++++++++++++

iothread.c | 3 ++

util/aio-posix.c | 1 +

util/async.c | 20 ++++++++++++

util/main-loop.c | 9 ++++++

util/thread-pool.c | 55 +++++++++++++++++++++++++++++---

10 files changed, 133 insertions(+), 5 deletions(-)

@@ -XXX,XX +XXX,XX @@ static void iothread_set_aio_context_params(EventLoopBase *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_min,

+ base->thread_pool_max, errp);

}

diff --git a/util/aio-posix.c b/util/aio-posix.c

index XXXXXXX..XXXXXXX 100644

--- a/util/aio-posix.c

+++ b/util/aio-posix.c

@@ -XXX,XX +XXX,XX @@

#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 XXXXXXX..XXXXXXX 100644

--- a/util/async.c

+++ b/util/async.c

@@ -XXX,XX +XXX,XX @@ AioContext *aio_context_new(Error **errp)

ctx->aio_max_batch = 0;

+ ctx->thread_pool_min = 0;

+ ctx->thread_pool_max = THREAD_POOL_MAX_THREADS_DEFAULT;

+

return ctx;

fail:

g_source_destroy(&ctx->source);

@@ -XXX,XX +XXX,XX @@ 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 = min;

+ ctx->thread_pool_max = 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 XXXXXXX..XXXXXXX 100644

--- a/util/main-loop.c

+++ b/util/main-loop.c

@@ -XXX,XX +XXX,XX @@

#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"

@@ -XXX,XX +XXX,XX @@ int qemu_init_main_loop(Error **errp)

static void main_loop_update_params(EventLoopBase *base, Error **errp)

+ ERRP_GUARD();

+

if (!qemu_aio_context) {

error_setg(errp, "qemu aio context not ready");

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);

}

MainLoop *mloop;

diff --git a/util/thread-pool.c b/util/thread-pool.c

index XXXXXXX..XXXXXXX 100644

--- a/util/thread-pool.c

+++ b/util/thread-pool.c

@@ -XXX,XX +XXX,XX @@ struct ThreadPool {

QemuMutex lock;

QemuCond worker_stopped;

QemuSemaphore sem;

- int max_threads;

QEMUBH *new_thread_bh;

/* The following variables are only accessed from one AioContext. */

@@ -XXX,XX +XXX,XX @@ 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;

};

+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 threads.

+ */

+ if (ret == -1 && (!QTAILQ_EMPTY(&pool->request_list) ||

+ pool->cur_threads > pool->max_threads ||

+ pool->cur_threads <= pool->min_threads)) {

+ return true;

+ }

+

+ return false;

+}

+

static void *worker_thread(void *opaque)

ThreadPool *pool = opaque;

@@ -XXX,XX +XXX,XX @@ static void *worker_thread(void *opaque)

ret = qemu_sem_timedwait(&pool->sem, 10000);

qemu_mutex_lock(&pool->lock);

pool->idle_threads--;

- } while (ret == -1 && !QTAILQ_EMPTY(&pool->request_list));

- if (ret == -1 || pool->stopping) {

+ } while (back_to_sleep(pool, ret));

+ if (ret == -1 || pool->stopping ||

+ pool->cur_threads > pool->max_threads) {

break;

}

@@ -XXX,XX +XXX,XX @@ void thread_pool_submit(ThreadPool *pool, ThreadPoolFunc *func, void *arg)

thread_pool_submit_aio(pool, func, arg, NULL, NULL);

}

+void thread_pool_update_params(ThreadPool *pool, AioContext *ctx)

+{

+ qemu_mutex_lock(&pool->lock);

+

+ pool->min_threads = ctx->thread_pool_min;

+ pool->max_threads = ctx->thread_pool_max;

+

+ /*

+ * We either have to:

+ * - Increase the number available of threads until over the min_threads

+ * threshold.

+ * - Decrease the number of available threads until under the max_threads

+ * threshold.

+ * - Do nothing. The current number of threads fall in between the min and

+ * max thresholds. We'll let the pool manage itself.

+ */

+ for (int i = pool->cur_threads; i < pool->min_threads; i++) {

+ spawn_thread(pool);

+ }

+

+ for (int i = 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) {

@@ -XXX,XX +XXX,XX @@ static void thread_pool_init_one(ThreadPool *pool, AioContext *ctx)

qemu_mutex_init(&pool->lock);

qemu_cond_init(&pool->worker_stopped);

qemu_sem_init(&pool->sem, 0);

- pool->max_threads = 64;

pool->new_thread_bh = aio_bh_new(ctx, spawn_thread_bh_fn, pool);

QLIST_INIT(&pool->head);

QTAILQ_INIT(&pool->request_list);

+

+ thread_pool_update_params(pool, ctx);

}

ThreadPool *thread_pool_new(AioContext *ctx)

2.35.1