Re: [Qemu-devel] [PATCH v14 07/19] qmp-input: Refactor when list is advanced

[Markus Armbruster]

Eric Blake <address@hidden> writes:

> Refactor the code to advance the QListEntry pointer at the point
> where visit_type_FOO() is called, rather than visit_next_list().
> This will allow a future patch to move the visit of the list head
> into visit_start_list(), and get rid of the 'first' flag.
>
> Signed-off-by: Eric Blake <address@hidden>

After having read the patch, I think the change is from this sequence of
states

           start_list next_list type_ELT ... next_list type_ELT end_list
    entry  NULL       1st elt   1st elt      last elt  last elt gone

where type_ELT() returns (entry ? entry : 1st elt) and next_list() steps
entry

to this one

           start_list next_list type_ELT ... next_list type_ELT end_list
    entry  1st elt    1nd elt   2nd elt      last elt  NULL     gone

where type_ELT() steps entry and returns the old entry, and next_list()
leaves entry alone.  Correct?

Now have a look at the typical generated visit:

    void visit_type_FOOList(Visitor *v, const char *name, FOOList **obj, Error 
**errp)
    {
        Error *err = NULL;
        FOOList *tail;
        size_t size = sizeof(**obj);

        visit_start_list(v, name, (GenericList **)obj, size, &err);
        if (err) {
            goto out;
        }
        for (tail = *obj;
             tail;
             tail = (FOOList *)visit_next_list(v, (GenericList *)tail, size)) {
            visit_type_FOO(v, NULL, &tail->value, &err);
            if (err) {
                break;
            }
        }
        if (visit_end_list(v) && err) {
            qapi_free_FOOList(*obj);
            *obj = NULL;
        }
    out:
        error_propagate(errp, err);
    }

While the loop variable is still stepped in the for's third expression
as it should, the actual stepping below the hood now happens in the loop
body.  I find this mildly confusing.

Perhaps a more natural loop would be

    void visit_type_FOOList(Visitor *v, const char *name, FOOList **obj, Error 
**errp)
    {
        Error *err = NULL;
        GenericList *tail;
        size_t size = sizeof(**obj);

        visit_start_list(v, name, (GenericList **)obj, size, &err);
        if (err) {
            goto out;
        }
        while ((tail = visit_next_list(v, tail, size))) {
            visit_type_FOO(v, NULL, &((FOOList *)tail)->value, &err);
            if (err) {
                break;
            }
        }
        if (visit_end_list(v) && err) {
            qapi_free_FOOList(*obj);
            *obj = NULL;
        }
    out:
        error_propagate(errp, err);
    }

Might also permit de-duplicating the g_malloc0(size), since we now call
next_list() *before* each iteration instead of *between* iterations.

> ---
> v14: no change
> v13: no change
> v12: new patch
> ---
>  qapi/qmp-input-visitor.c | 40 +++++++++++++++++++++-------------------
>  1 file changed, 21 insertions(+), 19 deletions(-)
>
> diff --git a/qapi/qmp-input-visitor.c b/qapi/qmp-input-visitor.c
> index cfaf378..1820360 100644
> --- a/qapi/qmp-input-visitor.c
> +++ b/qapi/qmp-input-visitor.c
> @@ -27,9 +27,10 @@ typedef struct StackObject
>  {
>      QObject *obj; /* Object being visited */
>
> -    /* If obj is list: NULL if list is at head, otherwise tail of list
> -     * still needing visits */
> +    /* If obj is list: tail of list still needing visits */
>      const QListEntry *entry;
> +    /* If obj is list: true if head is not visited yet */
> +    bool first;

Temporary, PATCH 18 will get rid of it.  Good, because the less state,
the happier I am :)

>
>      GHashTable *h; /* If obj is dict: remaining keys needing visits */
>  } StackObject;
> @@ -77,7 +78,12 @@ static QObject *qmp_input_get_object(QmpInputVisitor *qiv,
       /* If we are in the middle of a list, then return the next element
>       * of the list.  */
>      if (tos->entry) {

Before the patch, the condition matches the comment: tos->entry implies
this is a list and we're not at its head.

After the patch, the condition only implies it's a list, but ...

>          assert(qobject_type(qobj) == QTYPE_QLIST);
> -        return qlist_entry_obj(tos->entry);
> +        assert(!tos->first);

... you assert that "not at its head" can't happen.  Why is that the
case?

> +        qobj = qlist_entry_obj(tos->entry);
> +        if (consume) {
> +            tos->entry = qlist_next(tos->entry);
> +        }
> +        return qobj;

The remainder of the hunk adds the qlist_next() call moved from
qmp_input_next_list(), as advertized by the commit message.  Good.

>      }
>
>      /* Otherwise, we are at the root of the visit or the start of a
> @@ -91,7 +97,8 @@ static void qdict_add_key(const char *key, QObject *obj, 
> void *opaque)
>      g_hash_table_insert(h, (gpointer) key, NULL);
>  }
>
> -static void qmp_input_push(QmpInputVisitor *qiv, QObject *obj, Error **errp)
> +static void qmp_input_push(QmpInputVisitor *qiv, QObject *obj,
> +                           const QListEntry *entry, Error **errp)
>  {
>      GHashTable *h;
>      StackObject *tos = &qiv->stack[qiv->nb_stack];
> @@ -103,7 +110,8 @@ static void qmp_input_push(QmpInputVisitor *qiv, QObject 
> *obj, Error **errp)
>      }
>
>      tos->obj = obj;
> -    tos->entry = NULL;
> +    tos->entry = entry;
> +    tos->first = true;
>      tos->h = NULL;
>
>      if (qiv->strict && qobject_type(obj) == QTYPE_QDICT) {

Here, you change the initial state.  Not explicitly advertized in the
commit message, unlike the change to qlist_next().  I guess that's okay,
but perhaps my ramblings give you ideas on improving the commit message.

I wonder whether we really need the new argument.  Could we do something
like

       if (qobject_type(obj) == QTYPE_QLIST) {
           tos->entry = qlist_first(qobject_to_qlist(obj));
           tos->first = true;
       }

?

> @@ -153,7 +161,7 @@ static void qmp_input_start_struct(Visitor *v, const char 
> *name, void **obj,
>          return;
>      }
>
> -    qmp_input_push(qiv, qobj, &err);
> +    qmp_input_push(qiv, qobj, NULL, &err);

Since @qobj is a dictionary, the StackObject's entry will be unused, so
pass null.  Okay.

>      if (err) {
>          error_propagate(errp, err);
>          return;
> @@ -175,6 +183,7 @@ static void qmp_input_start_list(Visitor *v, const char 
> *name, Error **errp)
>  {
>      QmpInputVisitor *qiv = to_qiv(v);
>      QObject *qobj = qmp_input_get_object(qiv, name, true);
> +    const QListEntry *entry;
>
>      if (!qobj || qobject_type(qobj) != QTYPE_QLIST) {
>          error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
> @@ -182,7 +191,8 @@ static void qmp_input_start_list(Visitor *v, const char 
> *name, Error **errp)
>          return;
>      }
>
> -    qmp_input_push(qiv, qobj, errp);
> +    entry = qlist_first(qobject_to_qlist(qobj));
> +    qmp_input_push(qiv, qobj, entry, errp);

@qobj is a list, the StackObject's entry must be initialized to its
first member, so pass that.

>  }
>
>  static GenericList *qmp_input_next_list(Visitor *v, GenericList **list,
> @@ -191,23 +201,15 @@ static GenericList *qmp_input_next_list(Visitor *v, 
> GenericList **list,
>      QmpInputVisitor *qiv = to_qiv(v);
>      GenericList *entry;
>      StackObject *so = &qiv->stack[qiv->nb_stack - 1];
> -    bool first;
>
> -    if (so->entry == NULL) {
> -        so->entry = qlist_first(qobject_to_qlist(so->obj));
> -        first = true;
> -    } else {
> -        so->entry = qlist_next(so->entry);
> -        first = false;
> -    }
> -
> -    if (so->entry == NULL) {
> +    if (!so->entry) {
>          return NULL;
>      }
>
>      entry = g_malloc0(size);
> -    if (first) {
> +    if (so->first) {
>          *list = entry;
> +        so->first = false;
>      } else {
>          (*list)->next = entry;
>      }

Here, you drop the qlist_next() call.  It moves to
qmp_input_get_object().  Good.

> @@ -382,7 +384,7 @@ QmpInputVisitor *qmp_input_visitor_new(QObject *obj)
>      v->visitor.type_any = qmp_input_type_any;
>      v->visitor.optional = qmp_input_optional;
>
> -    qmp_input_push(v, obj, NULL);
> +    qmp_input_push(v, obj, NULL, NULL);

@obj is the root of the visit.  Can it be a list?

If yes, then StackObject's entry is not its first element.  Why is that
correct?

>      qobject_incref(obj);
>
>      return v;