Re: [Qemu-devel] [PATCH v4 6/7] qom: replace object property list with GHashTable

["Andreas Färber" <afaerber@suse.de>]

Am 13.10.2015 um 14:37 schrieb Daniel P. Berrange:
> From: Pavel Fedin <p.fedin@samsung.com>
> 
> ARM GICv3 systems with large number of CPUs create lots of IRQ pins. Since
> every pin is represented as a property, number of these properties becomes
> very large. Every property add first makes sure there's no duplicates.
> Traversing the list becomes very slow, therefore qemu initialization takes
> significant time (several seconds for e. g. 16 CPUs).
> 
> This patch replaces list with GHashTable, making lookup very fast. The only
> drawback is that object_child_foreach() and object_child_foreach_recursive()
> cannot modify their objects during traversal, since GHashTableIter does not
> have modify-safe version. However, the code seems not to modify objects via
> these functions.

"modify objects" seems a little misleading here; from what I see only
adding or removing properties (including child<>s) is forbidden, right?
Modifying one ObjectProperty or its value should still be okay.

I believe that limitation is fine.

> 
> Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
> Signed-off-by: Pavel Fedin <p.fedin@samsung.com>
> ---
>  include/qom/object.h | 10 ++++--
>  qom/object.c         | 98 ++++++++++++++++++++++++++++++----------------------
>  2 files changed, 64 insertions(+), 44 deletions(-)
[...]
> diff --git a/qom/object.c b/qom/object.c
> index 7dace59..dd01652 100644
> --- a/qom/object.c
> +++ b/qom/object.c
> @@ -68,7 +68,7 @@ struct TypeImpl
>  };
>  
>  struct ObjectPropertyIterator {
> -    ObjectProperty *next;
> +    GHashTableIter iter;
>  };
>  
>  static Type type_interface;
> @@ -330,6 +330,16 @@ static void object_post_init_with_type(Object *obj, TypeImpl *ti)
>      }
>  }
>  
> +static void property_free(gpointer data)

Bikeshed: We might call this object_property_free() unless there's a
precedence for property_...?

> +{
> +    ObjectProperty *prop = data;
> +
> +    g_free(prop->name);
> +    g_free(prop->type);
> +    g_free(prop->description);
> +    g_free(prop);
> +}
> +
>  void object_initialize_with_type(void *data, size_t size, TypeImpl *type)
>  {
>      Object *obj = data;
[...]
> @@ -363,29 +374,35 @@ static inline bool object_property_is_child(ObjectProperty *prop)
>  
>  static void object_property_del_all(Object *obj)
>  {
> -    while (!QTAILQ_EMPTY(&obj->properties)) {
> -        ObjectProperty *prop = QTAILQ_FIRST(&obj->properties);
> -
> -        QTAILQ_REMOVE(&obj->properties, prop, node);
> +    ObjectProperty *prop;
> +    GHashTableIter iter;
> +    gpointer key, value;
>  
> +    g_hash_table_iter_init(&iter, obj->properties);
> +    while (g_hash_table_iter_next(&iter, &key, &value)) {
> +        prop = value;
>          if (prop->release) {
>              prop->release(obj, prop->name, prop->opaque);
>          }

Why is this not in property_free(), too? Is there a timing difference?

> -
> -        g_free(prop->name);
> -        g_free(prop->type);
> -        g_free(prop->description);
> -        g_free(prop);
>      }
> +
> +    g_hash_table_unref(obj->properties);
>  }
>  
>  static void object_property_del_child(Object *obj, Object *child, Error **errp)
>  {
>      ObjectProperty *prop;
> +    GHashTableIter iter;
> +    gpointer key, value;
>  
> -    QTAILQ_FOREACH(prop, &obj->properties, node) {
> +    g_hash_table_iter_init(&iter, obj->properties);
> +    while (g_hash_table_iter_next(&iter, &key, &value)) {
> +        prop = value;
>          if (object_property_is_child(prop) && prop->opaque == child) {
> -            object_property_del(obj, prop->name, errp);
> +            if (prop->release) {
> +                prop->release(obj, prop->name, prop->opaque);
> +            }

Ditto?

> +            g_hash_table_iter_remove(&iter);
>              break;
>          }
>      }
[...]
> @@ -924,7 +940,7 @@ ObjectProperty *object_property_find(Object *obj, const char *name,
>  ObjectPropertyIterator *object_property_iter_init(Object *obj)
>  {
>      ObjectPropertyIterator *ret = g_new0(ObjectPropertyIterator, 1);
> -    ret->next = QTAILQ_FIRST(&obj->properties);
> +    g_hash_table_iter_init(&ret->iter, obj->properties);
>      return ret;
>  }
>  

Is it intentional that our iterator pattern differs?

> @@ -940,31 +956,27 @@ void object_property_iter_free(ObjectPropertyIterator *iter)
>  
>  ObjectProperty *object_property_iter_next(ObjectPropertyIterator *iter)
>  {
> -    ObjectProperty *ret = iter->next;
> -    if (ret) {
> -        iter->next = QTAILQ_NEXT(iter->next, node);
> +    gpointer key, val;
> +    if (!g_hash_table_iter_next(&iter->iter, &key, &val)) {
> +        return NULL;
>      }
> -    return ret;
> +    return val;
>  }
>  
>  
>  void object_property_del(Object *obj, const char *name, Error **errp)
>  {
> -    ObjectProperty *prop = object_property_find(obj, name, errp);
> -    if (prop == NULL) {
> +    ObjectProperty *prop = g_hash_table_lookup(obj->properties, name);
> +
> +    if (!prop) {
> +        error_setg(errp, "Property '.%s' not found", name);

Is this a behavioral change?

>          return;
>      }
>  
>      if (prop->release) {
>          prop->release(obj, name, prop->opaque);
>      }

property_free()?

> -
> -    QTAILQ_REMOVE(&obj->properties, prop, node);
> -
> -    g_free(prop->name);
> -    g_free(prop->type);
> -    g_free(prop->description);
> -    g_free(prop);
> +    g_hash_table_remove(obj->properties, name);
>  }
>  
>  void object_property_get(Object *obj, Visitor *v, const char *name,
> @@ -1484,11 +1496,13 @@ void object_property_add_const_link(Object *obj, const char *name,
>  gchar *object_get_canonical_path_component(Object *obj)
>  {
>      ObjectProperty *prop = NULL;
> +    GHashTableIter iter;
>  
>      g_assert(obj);
>      g_assert(obj->parent != NULL);
>  
> -    QTAILQ_FOREACH(prop, &obj->parent->properties, node) {
> +    g_hash_table_iter_init(&iter, obj->parent->properties);
> +    while (g_hash_table_iter_next(&iter, NULL, (gpointer *)&prop)) {

Is this cast needed?

>          if (!object_property_is_child(prop)) {
>              continue;
>          }
> @@ -1572,11 +1586,13 @@ static Object *object_resolve_partial_path(Object *parent,
>                                                bool *ambiguous)
>  {
>      Object *obj;
> +    GHashTableIter iter;
>      ObjectProperty *prop;
>  
>      obj = object_resolve_abs_path(parent, parts, typename, 0);
>  
> -    QTAILQ_FOREACH(prop, &parent->properties, node) {
> +    g_hash_table_iter_init(&iter, parent->properties);
> +    while (g_hash_table_iter_next(&iter, NULL, (gpointer *)&prop)) {

Ditto?

>          Object *found;
>  
>          if (!object_property_is_child(prop)) {

Otherwise looks very good, but third pair of eyes appreciated (Markus?).

Regards,
Andreas

-- 
SUSE Linux GmbH, Maxfeldstr. 5, 90409 Nürnberg, Germany
GF: Felix Imendörffer, Jane Smithard, Graham Norton; HRB 21284 (AG Nürnberg)