motorhead/qemu
1
0
Fork 0
mirror of https://github.com/Motorhead1991/qemu.git synced 2025-08-11 03:24:58 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions

virtiofsd: Use --thread-pool-size=0 to mean no thread pool

Browse source 
Right now we create a thread pool and main thread hands over the request
to thread in thread pool to process. Number of threads in thread pool
can be managed by option --thread-pool-size.

In tests we have noted that many of the workloads are getting better
performance if we don't use a thread pool at all and process all
the requests in the context of a thread receiving the request.

Hence give user an option to be able to run virtiofsd without using
a thread pool.

To implement this, I have used existing option --thread-pool-size. This
option defines how many maximum threads can be in the thread pool.
Thread pool size zero freezes thead pool. I can't see why will one
start virtiofsd with a frozen thread pool (hence frozen file system).
So I am redefining --thread-pool-size=0 to mean, don't use a thread pool.
Instead process the request in the context of thread receiving request
from the queue.

Signed-off-by: Vivek Goyal <vgoyal@redhat.com>
Message-Id: <20201109143548.GA1479853@redhat.com>
Reviewed-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
This commit is contained in:
Vivek Goyal 2020-11-09 09:35:48 -05:00 • committed by Dr. David Alan Gilbert
parent ff688cd2c7
commit e49393a349
1 changed files with 26 additions and 8 deletions
Download patch file Download diff file Expand all files Collapse all files

34
tools/virtiofsd/fuse_virtio.c
View file

@ -578,13 +578,18 @@ static void *fv_queue_thread(void *opaque)
struct VuDev *dev = &qi->virtio_dev->dev; struct VuDev *dev = &qi->virtio_dev->dev;
struct VuVirtq *q = vu_get_queue(dev, qi->qidx); struct VuVirtq *q = vu_get_queue(dev, qi->qidx);
struct fuse_session *se = qi->virtio_dev->se; struct fuse_session *se = qi->virtio_dev->se;
GThreadPool *pool; GThreadPool *pool = NULL;
GList *req_list = NULL;
pool = g_thread_pool_new(fv_queue_worker, qi, se->thread_pool_size, FALSE, if (se->thread_pool_size) {
NULL); fuse_log(FUSE_LOG_DEBUG, "%s: Creating thread pool for Queue %d\n",
if (!pool) { __func__, qi->qidx);
fuse_log(FUSE_LOG_ERR, "%s: g_thread_pool_new failed\n", __func__); pool = g_thread_pool_new(fv_queue_worker, qi, se->thread_pool_size,
return NULL; FALSE, NULL);
if (!pool) {
fuse_log(FUSE_LOG_ERR, "%s: g_thread_pool_new failed\n", __func__);
return NULL;
}
} }
fuse_log(FUSE_LOG_INFO, "%s: Start for queue %d kick_fd %d\n", __func__, fuse_log(FUSE_LOG_INFO, "%s: Start for queue %d kick_fd %d\n", __func__,
@ -659,14 +664,27 @@ static void *fv_queue_thread(void *opaque)
req->reply_sent = false; req->reply_sent = false;
g_thread_pool_push(pool, req, NULL); if (!se->thread_pool_size) {
req_list = g_list_prepend(req_list, req);
} else {
g_thread_pool_push(pool, req, NULL);
}
} }
pthread_mutex_unlock(&qi->vq_lock); pthread_mutex_unlock(&qi->vq_lock);
pthread_rwlock_unlock(&qi->virtio_dev->vu_dispatch_rwlock); pthread_rwlock_unlock(&qi->virtio_dev->vu_dispatch_rwlock);
/* Process all the requests. */
if (!se->thread_pool_size && req_list != NULL) {
g_list_foreach(req_list, fv_queue_worker, qi);
g_list_free(req_list);
req_list = NULL;
}
} }
g_thread_pool_free(pool, FALSE, TRUE); if (pool) {
g_thread_pool_free(pool, FALSE, TRUE);
}
return NULL; return NULL;
} }