* [Qemu-devel] [PATCH] [RFC] Add glib support to main loop
@ 2011-07-27 0:06 Anthony Liguori
2011-07-27 20:43 ` Blue Swirl
0 siblings, 1 reply; 7+ messages in thread
From: Anthony Liguori @ 2011-07-27 0:06 UTC (permalink / raw)
To: qemu-devel; +Cc: Amit Shah, Paolo Bonzini, Anthony Liguori, Hans de Goede
This allows GSources to be used to register callback events in QEMU. This is
useful as it allows us to take greater advantage of glib and also because it
allows us to write code that is more easily testable outside of QEMU since we
can make use of glib's main loop in unit tests.
All new code should use glib's callback mechanisms for registering fd events
which are very well documented at:
http://developer.gnome.org/glib/stable/glib-The-Main-Event-Loop.html
And:
http://developer.gnome.org/gio/stable/
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
---
vl.c | 74 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 74 insertions(+), 0 deletions(-)
diff --git a/vl.c b/vl.c
index 4b6688b..19774ac 100644
--- a/vl.c
+++ b/vl.c
@@ -111,6 +111,8 @@ int main(int argc, char **argv)
#define main qemu_main
#endif /* CONFIG_COCOA */
+#include <glib.h>
+
#include "hw/hw.h"
#include "hw/boards.h"
#include "hw/usb.h"
@@ -1309,6 +1311,75 @@ void qemu_system_vmstop_request(int reason)
qemu_notify_event();
}
+static GPollFD poll_fds[1024 * 2]; /* this is probably overkill */
+static int n_poll_fds;
+static int max_priority;
+
+static void glib_select_fill(int *max_fd, fd_set *rfds, fd_set *wfds,
+ fd_set *xfds, struct timeval *tv)
+{
+ GMainContext *context = g_main_context_default();
+ int i;
+ int timeout = 0, cur_timeout;
+
+ g_main_context_prepare(context, &max_priority);
+
+ n_poll_fds = g_main_context_query(context, max_priority, &timeout,
+ poll_fds, ARRAY_SIZE(poll_fds));
+ g_assert(n_poll_fds <= ARRAY_SIZE(poll_fds));
+
+ for (i = 0; i < n_poll_fds; i++) {
+ GPollFD *p = &poll_fds[i];
+
+ if ((p->events & G_IO_IN)) {
+ FD_SET(p->fd, rfds);
+ *max_fd = MAX(*max_fd, p->fd);
+ }
+ if ((p->events & G_IO_OUT)) {
+ FD_SET(p->fd, wfds);
+ *max_fd = MAX(*max_fd, p->fd);
+ }
+ if ((p->events & G_IO_ERR)) {
+ FD_SET(p->fd, xfds);
+ *max_fd = MAX(*max_fd, p->fd);
+ }
+ }
+
+ cur_timeout = (tv->tv_sec * 1000) + ((tv->tv_usec + 500) / 1000);
+ if (timeout >= 0 && timeout < cur_timeout) {
+ tv->tv_sec = timeout / 1000;
+ tv->tv_usec = (timeout % 1000) * 1000;
+ }
+}
+
+static void glib_select_poll(fd_set *rfds, fd_set *wfds, fd_set *xfds,
+ bool err)
+{
+ GMainContext *context = g_main_context_default();
+
+ if (!err) {
+ int i;
+
+ for (i = 0; i < n_poll_fds; i++) {
+ GPollFD *p = &poll_fds[i];
+
+ if ((p->events & G_IO_IN) && FD_ISSET(p->fd, rfds)) {
+ p->revents |= G_IO_IN;
+ }
+ if ((p->events & G_IO_OUT) && FD_ISSET(p->fd, wfds)) {
+ p->revents |= G_IO_OUT;
+ }
+ if ((p->events & G_IO_ERR) && FD_ISSET(p->fd, xfds)) {
+ p->revents |= G_IO_ERR;
+ }
+ }
+ }
+
+ if (g_main_context_check(context, max_priority, poll_fds, n_poll_fds)) {
+ g_main_context_dispatch(context);
+ }
+}
+
void main_loop_wait(int nonblocking)
{
fd_set rfds, wfds, xfds;
@@ -1334,8 +1405,10 @@ void main_loop_wait(int nonblocking)
FD_ZERO(&rfds);
FD_ZERO(&wfds);
FD_ZERO(&xfds);
+
qemu_iohandler_fill(&nfds, &rfds, &wfds, &xfds);
slirp_select_fill(&nfds, &rfds, &wfds, &xfds);
+ glib_select_fill(&nfds, &rfds, &wfds, &xfds, &tv);
qemu_mutex_unlock_iothread();
ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv);
@@ -1343,6 +1416,7 @@ void main_loop_wait(int nonblocking)
qemu_iohandler_poll(&rfds, &wfds, &xfds, ret);
slirp_select_poll(&rfds, &wfds, &xfds, (ret < 0));
+ glib_select_poll(&rfds, &wfds, &xfds, (ret < 0));
qemu_run_all_timers();
--
1.7.4.1
^ permalink raw reply related [flat|nested] 7+ messages in thread
* Re: [Qemu-devel] [PATCH] [RFC] Add glib support to main loop
2011-07-27 0:06 [Qemu-devel] [PATCH] [RFC] Add glib support to main loop Anthony Liguori
@ 2011-07-27 20:43 ` Blue Swirl
2011-07-27 20:48 ` Anthony Liguori
0 siblings, 1 reply; 7+ messages in thread
From: Blue Swirl @ 2011-07-27 20:43 UTC (permalink / raw)
To: Anthony Liguori; +Cc: Amit Shah, Paolo Bonzini, qemu-devel, Hans de Goede
On Wed, Jul 27, 2011 at 3:06 AM, Anthony Liguori <aliguori@us.ibm.com> wrote:
> This allows GSources to be used to register callback events in QEMU. This is
> useful as it allows us to take greater advantage of glib and also because it
> allows us to write code that is more easily testable outside of QEMU since we
> can make use of glib's main loop in unit tests.
>
> All new code should use glib's callback mechanisms for registering fd events
> which are very well documented at:
>
> http://developer.gnome.org/glib/stable/glib-The-Main-Event-Loop.html
>
> And:
>
> http://developer.gnome.org/gio/stable/
>
> Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
> ---
> vl.c | 74 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> 1 files changed, 74 insertions(+), 0 deletions(-)
>
> diff --git a/vl.c b/vl.c
> index 4b6688b..19774ac 100644
> --- a/vl.c
> +++ b/vl.c
> @@ -111,6 +111,8 @@ int main(int argc, char **argv)
> #define main qemu_main
> #endif /* CONFIG_COCOA */
>
> +#include <glib.h>
> +
> #include "hw/hw.h"
> #include "hw/boards.h"
> #include "hw/usb.h"
> @@ -1309,6 +1311,75 @@ void qemu_system_vmstop_request(int reason)
> qemu_notify_event();
> }
>
> +static GPollFD poll_fds[1024 * 2]; /* this is probably overkill */
> +static int n_poll_fds;
> +static int max_priority;
> +
> +static void glib_select_fill(int *max_fd, fd_set *rfds, fd_set *wfds,
> + fd_set *xfds, struct timeval *tv)
> +{
> + GMainContext *context = g_main_context_default();
> + int i;
> + int timeout = 0, cur_timeout;
> +
> + g_main_context_prepare(context, &max_priority);
> +
> + n_poll_fds = g_main_context_query(context, max_priority, &timeout,
> + poll_fds, ARRAY_SIZE(poll_fds));
> + g_assert(n_poll_fds <= ARRAY_SIZE(poll_fds));
The use of g_assert() means that production code should define
G_DISABLE_ASSERT in addition to NDEBUG. Should we make both default
for stable versions?
> +
> + for (i = 0; i < n_poll_fds; i++) {
> + GPollFD *p = &poll_fds[i];
> +
> + if ((p->events & G_IO_IN)) {
> + FD_SET(p->fd, rfds);
> + *max_fd = MAX(*max_fd, p->fd);
> + }
> + if ((p->events & G_IO_OUT)) {
> + FD_SET(p->fd, wfds);
> + *max_fd = MAX(*max_fd, p->fd);
> + }
> + if ((p->events & G_IO_ERR)) {
> + FD_SET(p->fd, xfds);
> + *max_fd = MAX(*max_fd, p->fd);
> + }
> + }
> +
> + cur_timeout = (tv->tv_sec * 1000) + ((tv->tv_usec + 500) / 1000);
> + if (timeout >= 0 && timeout < cur_timeout) {
> + tv->tv_sec = timeout / 1000;
> + tv->tv_usec = (timeout % 1000) * 1000;
> + }
> +}
> +
> +static void glib_select_poll(fd_set *rfds, fd_set *wfds, fd_set *xfds,
> + bool err)
> +{
> + GMainContext *context = g_main_context_default();
> +
> + if (!err) {
> + int i;
> +
> + for (i = 0; i < n_poll_fds; i++) {
> + GPollFD *p = &poll_fds[i];
> +
> + if ((p->events & G_IO_IN) && FD_ISSET(p->fd, rfds)) {
> + p->revents |= G_IO_IN;
> + }
> + if ((p->events & G_IO_OUT) && FD_ISSET(p->fd, wfds)) {
> + p->revents |= G_IO_OUT;
> + }
> + if ((p->events & G_IO_ERR) && FD_ISSET(p->fd, xfds)) {
> + p->revents |= G_IO_ERR;
> + }
> + }
> + }
> +
> + if (g_main_context_check(context, max_priority, poll_fds, n_poll_fds)) {
> + g_main_context_dispatch(context);
> + }
> +}
> +
The above functions do not seem to be referenced anywhere.
> void main_loop_wait(int nonblocking)
> {
> fd_set rfds, wfds, xfds;
> @@ -1334,8 +1405,10 @@ void main_loop_wait(int nonblocking)
> FD_ZERO(&rfds);
> FD_ZERO(&wfds);
> FD_ZERO(&xfds);
> +
> qemu_iohandler_fill(&nfds, &rfds, &wfds, &xfds);
> slirp_select_fill(&nfds, &rfds, &wfds, &xfds);
> + glib_select_fill(&nfds, &rfds, &wfds, &xfds, &tv);
>
> qemu_mutex_unlock_iothread();
> ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv);
> @@ -1343,6 +1416,7 @@ void main_loop_wait(int nonblocking)
>
> qemu_iohandler_poll(&rfds, &wfds, &xfds, ret);
> slirp_select_poll(&rfds, &wfds, &xfds, (ret < 0));
> + glib_select_poll(&rfds, &wfds, &xfds, (ret < 0));
>
> qemu_run_all_timers();
>
> --
> 1.7.4.1
>
>
>
^ permalink raw reply [flat|nested] 7+ messages in thread
* Re: [Qemu-devel] [PATCH] [RFC] Add glib support to main loop
2011-07-27 20:43 ` Blue Swirl
@ 2011-07-27 20:48 ` Anthony Liguori
2011-07-27 21:12 ` Blue Swirl
0 siblings, 1 reply; 7+ messages in thread
From: Anthony Liguori @ 2011-07-27 20:48 UTC (permalink / raw)
To: Blue Swirl; +Cc: Amit Shah, Paolo Bonzini, qemu-devel, Hans de Goede
On 07/27/2011 03:43 PM, Blue Swirl wrote:
> On Wed, Jul 27, 2011 at 3:06 AM, Anthony Liguori<aliguori@us.ibm.com> wrote:
>> This allows GSources to be used to register callback events in QEMU. This is
>> useful as it allows us to take greater advantage of glib and also because it
>> allows us to write code that is more easily testable outside of QEMU since we
>> can make use of glib's main loop in unit tests.
>>
>> All new code should use glib's callback mechanisms for registering fd events
>> which are very well documented at:
>>
>> http://developer.gnome.org/glib/stable/glib-The-Main-Event-Loop.html
>>
>> And:
>>
>> http://developer.gnome.org/gio/stable/
>>
>> Signed-off-by: Anthony Liguori<aliguori@us.ibm.com>
>> ---
>> vl.c | 74 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
>> 1 files changed, 74 insertions(+), 0 deletions(-)
>>
>> diff --git a/vl.c b/vl.c
>> index 4b6688b..19774ac 100644
>> --- a/vl.c
>> +++ b/vl.c
>> @@ -111,6 +111,8 @@ int main(int argc, char **argv)
>> #define main qemu_main
>> #endif /* CONFIG_COCOA */
>>
>> +#include<glib.h>
>> +
>> #include "hw/hw.h"
>> #include "hw/boards.h"
>> #include "hw/usb.h"
>> @@ -1309,6 +1311,75 @@ void qemu_system_vmstop_request(int reason)
>> qemu_notify_event();
>> }
>>
>> +static GPollFD poll_fds[1024 * 2]; /* this is probably overkill */
>> +static int n_poll_fds;
>> +static int max_priority;
>> +
>> +static void glib_select_fill(int *max_fd, fd_set *rfds, fd_set *wfds,
>> + fd_set *xfds, struct timeval *tv)
>> +{
>> + GMainContext *context = g_main_context_default();
>> + int i;
>> + int timeout = 0, cur_timeout;
>> +
>> + g_main_context_prepare(context,&max_priority);
>> +
>> + n_poll_fds = g_main_context_query(context, max_priority,&timeout,
>> + poll_fds, ARRAY_SIZE(poll_fds));
>> + g_assert(n_poll_fds<= ARRAY_SIZE(poll_fds));
>
> The use of g_assert() means that production code should define
> G_DISABLE_ASSERT in addition to NDEBUG. Should we make both default
> for stable versions?
Oh, this is just me being lazy. There's a way to do this without using
the assert. I put the assert there to make sure that I didn't leave a
latent bug.
But in general, I don't think we should ever define NDEBUG.
>> +
>> + for (i = 0; i< n_poll_fds; i++) {
>> + GPollFD *p =&poll_fds[i];
>> +
>> + if ((p->events& G_IO_IN)) {
>> + FD_SET(p->fd, rfds);
>> + *max_fd = MAX(*max_fd, p->fd);
>> + }
>> + if ((p->events& G_IO_OUT)) {
>> + FD_SET(p->fd, wfds);
>> + *max_fd = MAX(*max_fd, p->fd);
>> + }
>> + if ((p->events& G_IO_ERR)) {
>> + FD_SET(p->fd, xfds);
>> + *max_fd = MAX(*max_fd, p->fd);
>> + }
>> + }
>> +
>> + cur_timeout = (tv->tv_sec * 1000) + ((tv->tv_usec + 500) / 1000);
>> + if (timeout>= 0&& timeout< cur_timeout) {
>> + tv->tv_sec = timeout / 1000;
>> + tv->tv_usec = (timeout % 1000) * 1000;
>> + }
>> +}
>> +
>> +static void glib_select_poll(fd_set *rfds, fd_set *wfds, fd_set *xfds,
>> + bool err)
>> +{
>> + GMainContext *context = g_main_context_default();
>> +
>> + if (!err) {
>> + int i;
>> +
>> + for (i = 0; i< n_poll_fds; i++) {
>> + GPollFD *p =&poll_fds[i];
>> +
>> + if ((p->events& G_IO_IN)&& FD_ISSET(p->fd, rfds)) {
>> + p->revents |= G_IO_IN;
>> + }
>> + if ((p->events& G_IO_OUT)&& FD_ISSET(p->fd, wfds)) {
>> + p->revents |= G_IO_OUT;
>> + }
>> + if ((p->events& G_IO_ERR)&& FD_ISSET(p->fd, xfds)) {
>> + p->revents |= G_IO_ERR;
>> + }
>> + }
>> + }
>> +
>> + if (g_main_context_check(context, max_priority, poll_fds, n_poll_fds)) {
>> + g_main_context_dispatch(context);
>> + }
>> +}
>> +
>
> The above functions do not seem to be referenced anywhere.
They are in the code below :-)
>> void main_loop_wait(int nonblocking)
>> {
>> fd_set rfds, wfds, xfds;
>> @@ -1334,8 +1405,10 @@ void main_loop_wait(int nonblocking)
>> FD_ZERO(&rfds);
>> FD_ZERO(&wfds);
>> FD_ZERO(&xfds);
>> +
>> qemu_iohandler_fill(&nfds,&rfds,&wfds,&xfds);
>> slirp_select_fill(&nfds,&rfds,&wfds,&xfds);
>> + glib_select_fill(&nfds,&rfds,&wfds,&xfds,&tv);
>>
>> qemu_mutex_unlock_iothread();
>> ret = select(nfds + 1,&rfds,&wfds,&xfds,&tv);
>> @@ -1343,6 +1416,7 @@ void main_loop_wait(int nonblocking)
>>
>> qemu_iohandler_poll(&rfds,&wfds,&xfds, ret);
>> slirp_select_poll(&rfds,&wfds,&xfds, (ret< 0));
>> + glib_select_poll(&rfds,&wfds,&xfds, (ret< 0));
>>
>> qemu_run_all_timers();
Regards,
Anthony Liguori
>> --
>> 1.7.4.1
>>
>>
>>
^ permalink raw reply [flat|nested] 7+ messages in thread
* Re: [Qemu-devel] [PATCH] [RFC] Add glib support to main loop
2011-07-27 20:48 ` Anthony Liguori
@ 2011-07-27 21:12 ` Blue Swirl
2011-07-27 21:21 ` Stefan Weil
2011-07-27 21:22 ` Anthony Liguori
0 siblings, 2 replies; 7+ messages in thread
From: Blue Swirl @ 2011-07-27 21:12 UTC (permalink / raw)
To: Anthony Liguori; +Cc: Amit Shah, Paolo Bonzini, qemu-devel, Hans de Goede
On Wed, Jul 27, 2011 at 11:48 PM, Anthony Liguori <aliguori@us.ibm.com> wrote:
> On 07/27/2011 03:43 PM, Blue Swirl wrote:
>>
>> On Wed, Jul 27, 2011 at 3:06 AM, Anthony Liguori<aliguori@us.ibm.com>
>> wrote:
>>>
>>> This allows GSources to be used to register callback events in QEMU.
>>> This is
>>> useful as it allows us to take greater advantage of glib and also because
>>> it
>>> allows us to write code that is more easily testable outside of QEMU
>>> since we
>>> can make use of glib's main loop in unit tests.
>>>
>>> All new code should use glib's callback mechanisms for registering fd
>>> events
>>> which are very well documented at:
>>>
>>> http://developer.gnome.org/glib/stable/glib-The-Main-Event-Loop.html
>>>
>>> And:
>>>
>>> http://developer.gnome.org/gio/stable/
>>>
>>> Signed-off-by: Anthony Liguori<aliguori@us.ibm.com>
>>> ---
>>> vl.c | 74
>>> ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
>>> 1 files changed, 74 insertions(+), 0 deletions(-)
>>>
>>> diff --git a/vl.c b/vl.c
>>> index 4b6688b..19774ac 100644
>>> --- a/vl.c
>>> +++ b/vl.c
>>> @@ -111,6 +111,8 @@ int main(int argc, char **argv)
>>> #define main qemu_main
>>> #endif /* CONFIG_COCOA */
>>>
>>> +#include<glib.h>
>>> +
>>> #include "hw/hw.h"
>>> #include "hw/boards.h"
>>> #include "hw/usb.h"
>>> @@ -1309,6 +1311,75 @@ void qemu_system_vmstop_request(int reason)
>>> qemu_notify_event();
>>> }
>>>
>>> +static GPollFD poll_fds[1024 * 2]; /* this is probably overkill */
>>> +static int n_poll_fds;
>>> +static int max_priority;
>>> +
>>> +static void glib_select_fill(int *max_fd, fd_set *rfds, fd_set *wfds,
>>> + fd_set *xfds, struct timeval *tv)
>>> +{
>>> + GMainContext *context = g_main_context_default();
>>> + int i;
>>> + int timeout = 0, cur_timeout;
>>> +
>>> + g_main_context_prepare(context,&max_priority);
>>> +
>>> + n_poll_fds = g_main_context_query(context, max_priority,&timeout,
>>> + poll_fds, ARRAY_SIZE(poll_fds));
>>> + g_assert(n_poll_fds<= ARRAY_SIZE(poll_fds));
>>
>> The use of g_assert() means that production code should define
>> G_DISABLE_ASSERT in addition to NDEBUG. Should we make both default
>> for stable versions?
>
> Oh, this is just me being lazy. There's a way to do this without using the
> assert. I put the assert there to make sure that I didn't leave a latent
> bug.
>
> But in general, I don't think we should ever define NDEBUG.
Why? I think it's normal practice to define NDEBUG (and
G_DISABLE_ASSERT if g_assert() is used) for production builds.
>>> +
>>> + for (i = 0; i< n_poll_fds; i++) {
>>> + GPollFD *p =&poll_fds[i];
>>> +
>>> + if ((p->events& G_IO_IN)) {
>>> + FD_SET(p->fd, rfds);
>>> + *max_fd = MAX(*max_fd, p->fd);
>>> + }
>>> + if ((p->events& G_IO_OUT)) {
>>> + FD_SET(p->fd, wfds);
>>> + *max_fd = MAX(*max_fd, p->fd);
>>> + }
>>> + if ((p->events& G_IO_ERR)) {
>>> + FD_SET(p->fd, xfds);
>>> + *max_fd = MAX(*max_fd, p->fd);
>>> + }
>>> + }
>>> +
>>> + cur_timeout = (tv->tv_sec * 1000) + ((tv->tv_usec + 500) / 1000);
>>> + if (timeout>= 0&& timeout< cur_timeout) {
>>> + tv->tv_sec = timeout / 1000;
>>> + tv->tv_usec = (timeout % 1000) * 1000;
>>> + }
>>> +}
>>> +
>>> +static void glib_select_poll(fd_set *rfds, fd_set *wfds, fd_set *xfds,
>>> + bool err)
>>> +{
>>> + GMainContext *context = g_main_context_default();
>>> +
>>> + if (!err) {
>>> + int i;
>>> +
>>> + for (i = 0; i< n_poll_fds; i++) {
>>> + GPollFD *p =&poll_fds[i];
>>> +
>>> + if ((p->events& G_IO_IN)&& FD_ISSET(p->fd, rfds)) {
>>> + p->revents |= G_IO_IN;
>>> + }
>>> + if ((p->events& G_IO_OUT)&& FD_ISSET(p->fd, wfds)) {
>>> + p->revents |= G_IO_OUT;
>>> + }
>>> + if ((p->events& G_IO_ERR)&& FD_ISSET(p->fd, xfds)) {
>>> + p->revents |= G_IO_ERR;
>>> + }
>>> + }
>>> + }
>>> +
>>> + if (g_main_context_check(context, max_priority, poll_fds,
>>> n_poll_fds)) {
>>> + g_main_context_dispatch(context);
>>> + }
>>> +}
>>> +
>>
>> The above functions do not seem to be referenced anywhere.
>
> They are in the code below :-)
Sorry, internal compiler error.
>>> void main_loop_wait(int nonblocking)
>>> {
>>> fd_set rfds, wfds, xfds;
>>> @@ -1334,8 +1405,10 @@ void main_loop_wait(int nonblocking)
>>> FD_ZERO(&rfds);
>>> FD_ZERO(&wfds);
>>> FD_ZERO(&xfds);
>>> +
>>> qemu_iohandler_fill(&nfds,&rfds,&wfds,&xfds);
>>> slirp_select_fill(&nfds,&rfds,&wfds,&xfds);
>>> + glib_select_fill(&nfds,&rfds,&wfds,&xfds,&tv);
>>>
>>> qemu_mutex_unlock_iothread();
>>> ret = select(nfds + 1,&rfds,&wfds,&xfds,&tv);
>>> @@ -1343,6 +1416,7 @@ void main_loop_wait(int nonblocking)
>>>
>>> qemu_iohandler_poll(&rfds,&wfds,&xfds, ret);
>>> slirp_select_poll(&rfds,&wfds,&xfds, (ret< 0));
>>> + glib_select_poll(&rfds,&wfds,&xfds, (ret< 0));
>>>
>>> qemu_run_all_timers();
>
> Regards,
>
> Anthony Liguori
>
>>> --
>>> 1.7.4.1
>>>
>>>
>>>
>
>
^ permalink raw reply [flat|nested] 7+ messages in thread
* Re: [Qemu-devel] [PATCH] [RFC] Add glib support to main loop
2011-07-27 21:12 ` Blue Swirl
@ 2011-07-27 21:21 ` Stefan Weil
2011-07-27 21:32 ` Anthony Liguori
2011-07-27 21:22 ` Anthony Liguori
1 sibling, 1 reply; 7+ messages in thread
From: Stefan Weil @ 2011-07-27 21:21 UTC (permalink / raw)
To: Blue Swirl
Cc: Amit Shah, Paolo Bonzini, Anthony Liguori, qemu-devel, Hans de Goede
Am 27.07.2011 23:12, schrieb Blue Swirl:
> On Wed, Jul 27, 2011 at 11:48 PM, Anthony Liguori<aliguori@us.ibm.com> wrote:
>
>> On 07/27/2011 03:43 PM, Blue Swirl wrote:
>>
>>> On Wed, Jul 27, 2011 at 3:06 AM, Anthony Liguori<aliguori@us.ibm.com>
>>> wrote:
>>>
>>>> This allows GSources to be used to register callback events in QEMU.
>>>> This is
>>>> useful as it allows us to take greater advantage of glib and also because
>>>> it
>>>> allows us to write code that is more easily testable outside of QEMU
>>>> since we
>>>> can make use of glib's main loop in unit tests.
>>>>
>>>> All new code should use glib's callback mechanisms for registering fd
>>>> events
>>>> which are very well documented at:
>>>>
>>>> http://developer.gnome.org/glib/stable/glib-The-Main-Event-Loop.html
>>>>
>>>> And:
>>>>
>>>> http://developer.gnome.org/gio/stable/
>>>>
>>>> Signed-off-by: Anthony Liguori<aliguori@us.ibm.com>
>>>> ---
>>>> vl.c | 74
>>>> ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
>>>> 1 files changed, 74 insertions(+), 0 deletions(-)
>>>>
>>>> diff --git a/vl.c b/vl.c
>>>> index 4b6688b..19774ac 100644
>>>> --- a/vl.c
>>>> +++ b/vl.c
>>>> @@ -111,6 +111,8 @@ int main(int argc, char **argv)
>>>> #define main qemu_main
>>>> #endif /* CONFIG_COCOA */
>>>>
>>>> +#include<glib.h>
>>>> +
>>>> #include "hw/hw.h"
>>>> #include "hw/boards.h"
>>>> #include "hw/usb.h"
>>>> @@ -1309,6 +1311,75 @@ void qemu_system_vmstop_request(int reason)
>>>> qemu_notify_event();
>>>> }
>>>>
>>>> +static GPollFD poll_fds[1024 * 2]; /* this is probably overkill */
>>>> +static int n_poll_fds;
>>>> +static int max_priority;
>>>> +
>>>> +static void glib_select_fill(int *max_fd, fd_set *rfds, fd_set *wfds,
>>>> + fd_set *xfds, struct timeval *tv)
>>>> +{
>>>> + GMainContext *context = g_main_context_default();
>>>> + int i;
>>>> + int timeout = 0, cur_timeout;
>>>> +
>>>> + g_main_context_prepare(context,&max_priority);
>>>> +
>>>> + n_poll_fds = g_main_context_query(context, max_priority,&timeout,
>>>> + poll_fds, ARRAY_SIZE(poll_fds));
>>>> + g_assert(n_poll_fds<= ARRAY_SIZE(poll_fds));
>>>>
>>> The use of g_assert() means that production code should define
>>> G_DISABLE_ASSERT in addition to NDEBUG. Should we make both default
>>> for stable versions?
>>>
>> Oh, this is just me being lazy. There's a way to do this without using the
>> assert. I put the assert there to make sure that I didn't leave a latent
>> bug.
>>
>> But in general, I don't think we should ever define NDEBUG.
>>
> Why? I think it's normal practice to define NDEBUG (and
> G_DISABLE_ASSERT if g_assert() is used) for production builds.
>
NDEBUG is normally set automatically for production code,
and it disables assertions which is not always good.
Assertions are useful even in production code unless
you are sure that the code is bug free or the assertions
cost to much resources - either memory or execution time.
I don't think this is the case for QEMU, therefore I'd prefer
having assertions in production code, too. This simply
means undefining NDEBUG before including assert.h.
Regards,
Stefan
^ permalink raw reply [flat|nested] 7+ messages in thread
* Re: [Qemu-devel] [PATCH] [RFC] Add glib support to main loop
2011-07-27 21:12 ` Blue Swirl
2011-07-27 21:21 ` Stefan Weil
@ 2011-07-27 21:22 ` Anthony Liguori
1 sibling, 0 replies; 7+ messages in thread
From: Anthony Liguori @ 2011-07-27 21:22 UTC (permalink / raw)
To: Blue Swirl; +Cc: Amit Shah, Paolo Bonzini, qemu-devel, Hans de Goede
On 07/27/2011 04:12 PM, Blue Swirl wrote:
> On Wed, Jul 27, 2011 at 11:48 PM, Anthony Liguori<aliguori@us.ibm.com> wrote:
>> On 07/27/2011 03:43 PM, Blue Swirl wrote:
>>>
>>> On Wed, Jul 27, 2011 at 3:06 AM, Anthony Liguori<aliguori@us.ibm.com>
>>> wrote:
>>>>
>>>> This allows GSources to be used to register callback events in QEMU.
>>>> This is
>>>> useful as it allows us to take greater advantage of glib and also because
>>>> it
>>>> allows us to write code that is more easily testable outside of QEMU
>>>> since we
>>>> can make use of glib's main loop in unit tests.
>>>>
>>>> All new code should use glib's callback mechanisms for registering fd
>>>> events
>>>> which are very well documented at:
>>>>
>>>> http://developer.gnome.org/glib/stable/glib-The-Main-Event-Loop.html
>>>>
>>>> And:
>>>>
>>>> http://developer.gnome.org/gio/stable/
>>>>
>>>> Signed-off-by: Anthony Liguori<aliguori@us.ibm.com>
>>>> ---
>>>> vl.c | 74
>>>> ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
>>>> 1 files changed, 74 insertions(+), 0 deletions(-)
>>>>
>>>> diff --git a/vl.c b/vl.c
>>>> index 4b6688b..19774ac 100644
>>>> --- a/vl.c
>>>> +++ b/vl.c
>>>> @@ -111,6 +111,8 @@ int main(int argc, char **argv)
>>>> #define main qemu_main
>>>> #endif /* CONFIG_COCOA */
>>>>
>>>> +#include<glib.h>
>>>> +
>>>> #include "hw/hw.h"
>>>> #include "hw/boards.h"
>>>> #include "hw/usb.h"
>>>> @@ -1309,6 +1311,75 @@ void qemu_system_vmstop_request(int reason)
>>>> qemu_notify_event();
>>>> }
>>>>
>>>> +static GPollFD poll_fds[1024 * 2]; /* this is probably overkill */
>>>> +static int n_poll_fds;
>>>> +static int max_priority;
>>>> +
>>>> +static void glib_select_fill(int *max_fd, fd_set *rfds, fd_set *wfds,
>>>> + fd_set *xfds, struct timeval *tv)
>>>> +{
>>>> + GMainContext *context = g_main_context_default();
>>>> + int i;
>>>> + int timeout = 0, cur_timeout;
>>>> +
>>>> + g_main_context_prepare(context,&max_priority);
>>>> +
>>>> + n_poll_fds = g_main_context_query(context, max_priority,&timeout,
>>>> + poll_fds, ARRAY_SIZE(poll_fds));
>>>> + g_assert(n_poll_fds<= ARRAY_SIZE(poll_fds));
>>>
>>> The use of g_assert() means that production code should define
>>> G_DISABLE_ASSERT in addition to NDEBUG. Should we make both default
>>> for stable versions?
>>
>> Oh, this is just me being lazy. There's a way to do this without using the
>> assert. I put the assert there to make sure that I didn't leave a latent
>> bug.
>>
>> But in general, I don't think we should ever define NDEBUG.
>
> Why? I think it's normal practice to define NDEBUG (and
> G_DISABLE_ASSERT if g_assert() is used) for production builds.
Heh, I guess this is a stylistic thing.
The theory is that if you do all of your testing with !defined(NDEBUG),
then you wouldn't want to ship something that potentially introduces
different code paths to the end user.
Besides, if an assert would trigger, I'd rather it drop core and have a
predictable error verses an unpredictable behavior.
Regards,
Anthony Liguori
^ permalink raw reply [flat|nested] 7+ messages in thread
* Re: [Qemu-devel] [PATCH] [RFC] Add glib support to main loop
2011-07-27 21:21 ` Stefan Weil
@ 2011-07-27 21:32 ` Anthony Liguori
0 siblings, 0 replies; 7+ messages in thread
From: Anthony Liguori @ 2011-07-27 21:32 UTC (permalink / raw)
To: Stefan Weil
Cc: Blue Swirl, Amit Shah, Hans de Goede, qemu-devel, Paolo Bonzini
On 07/27/2011 04:21 PM, Stefan Weil wrote:
> NDEBUG is normally set automatically for production code,
> and it disables assertions which is not always good.
>
> Assertions are useful even in production code unless
> you are sure that the code is bug free or the assertions
> cost to much resources - either memory or execution time.
>
> I don't think this is the case for QEMU, therefore I'd prefer
> having assertions in production code, too. This simply
> means undefining NDEBUG before including assert.h.
I don't know what constitutes "production builds" but the software that
most people use in production (normal distributions packages) don't
define NDEBUG.
Regards,
Anthony Liguori
>
> Regards,
> Stefan
>
^ permalink raw reply [flat|nested] 7+ messages in thread
end of thread, other threads:[~2011-07-27 21:32 UTC | newest]
Thread overview: 7+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2011-07-27 0:06 [Qemu-devel] [PATCH] [RFC] Add glib support to main loop Anthony Liguori
2011-07-27 20:43 ` Blue Swirl
2011-07-27 20:48 ` Anthony Liguori
2011-07-27 21:12 ` Blue Swirl
2011-07-27 21:21 ` Stefan Weil
2011-07-27 21:32 ` Anthony Liguori
2011-07-27 21:22 ` Anthony Liguori
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.