--- /dev/null
+/* GObject - GLib Type, Object, Parameter and Signal Library
+ * Copyright (C) 2009 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <math.h>
+#include <string.h>
+#include <glib-object.h>
+#include "testcommon.h"
+
+#define WARM_UP_N_RUNS 50
+#define ESTIMATE_ROUND_TIME_N_RUNS 5
+#define DEFAULT_TEST_TIME 15 /* seconds */
+ /* The time we want each round to take, in seconds, this should
+ * be large enough compared to the timer resolution, but small
+ * enought that the risk of any random slowness will miss the
+ * running window */
+#define TARGET_ROUND_TIME 0.004
+
+static gboolean verbose = FALSE;
+static gboolean init_threads = FALSE;
+static int test_length = DEFAULT_TEST_TIME;
+
+static GOptionEntry cmd_entries[] = {
+ {"verbose", 'v', 0, G_OPTION_ARG_NONE, &verbose,
+ "Print extra information", NULL},
+ {"threads", 't', 0, G_OPTION_ARG_NONE, &init_threads,
+ "Initialize threads", NULL},
+ {"seconds", 's', 0, G_OPTION_ARG_INT, &test_length,
+ "Time to run each test in seconds", NULL},
+ {NULL}
+};
+
+typedef struct _PerformanceTest PerformanceTest;
+struct _PerformanceTest {
+ const char *name;
+ gpointer extra_data;
+
+ gpointer (*setup) (PerformanceTest *test);
+ void (*init) (PerformanceTest *test,
+ gpointer data,
+ double factor);
+ void (*run) (PerformanceTest *test,
+ gpointer data);
+ void (*finish) (PerformanceTest *test,
+ gpointer data);
+ void (*teardown) (PerformanceTest *test,
+ gpointer data);
+ void (*print_result) (PerformanceTest *test,
+ gpointer data,
+ double time);
+};
+
+static void
+run_test (PerformanceTest *test)
+{
+ gpointer data = NULL;
+ guint64 i, num_rounds;
+ double elapsed, min_elapsed, factor;
+ GTimer *timer;
+
+ g_print ("Running test %s\n", test->name);
+
+ /* Set up test */
+ timer = g_timer_new ();
+ data = test->setup (test);
+
+ if (verbose)
+ g_print ("Warming up\n");
+
+ /* Warm up the test by doing a few runs */
+ for (i = 0; i < WARM_UP_N_RUNS; i++)
+ {
+ test->init (test, data, 1.0);
+ test->run (test, data);
+ test->finish (test, data);
+ }
+
+ if (verbose)
+ g_print ("Estimating round time\n");
+
+ /* Estimate time for one run by doing a few test rounds */
+ min_elapsed = 0;
+ for (i = 0; i < ESTIMATE_ROUND_TIME_N_RUNS; i++)
+ {
+ test->init (test, data, 1.0);
+ g_timer_start (timer);
+ test->run (test, data);
+ g_timer_stop (timer);
+ test->finish (test, data);
+
+ elapsed = g_timer_elapsed (timer, NULL);
+ if (i == 0)
+ min_elapsed = elapsed;
+ else
+ min_elapsed = MIN (min_elapsed, elapsed);
+ }
+
+ factor = TARGET_ROUND_TIME / min_elapsed;
+
+ if (verbose)
+ g_print ("Uncorrected round time: %f.4 secs, correction factor %f.2\n", min_elapsed, factor);
+
+ /* Calculate number of rounds needed */
+ num_rounds = (test_length / TARGET_ROUND_TIME) + 1;
+
+ if (verbose)
+ g_print ("Running %"G_GINT64_MODIFIER"d rounds\n", num_rounds);
+
+ /* Run the test */
+ for (i = 0; i < num_rounds; i++)
+ {
+ test->init (test, data, factor);
+ g_timer_start (timer);
+ test->run (test, data);
+ g_timer_stop (timer);
+ test->finish (test, data);
+ elapsed = g_timer_elapsed (timer, NULL);
+
+ if (i == 0)
+ min_elapsed = elapsed;
+ else
+ min_elapsed = MIN (min_elapsed, elapsed);
+ }
+
+ if (verbose)
+ g_print ("Minimum corrected round time: %f secs\n", min_elapsed);
+
+ /* Print the results */
+ test->print_result (test, data, min_elapsed);
+
+ /* Tear down */
+ test->teardown (test, data);
+ g_timer_destroy (timer);
+}
+
+/*************************************************************
+ * Simple object is a very simple small GObject subclass
+ * with no properties, no signals, implementing no interfaces
+ *************************************************************/
+
+#define SIMPLE_TYPE_OBJECT (simple_object_get_type ())
+typedef struct _SimpleObject SimpleObject;
+typedef struct _SimpleObjectClass SimpleObjectClass;
+
+struct _SimpleObject
+{
+ GObject parent_instance;
+ int val;
+};
+
+struct _SimpleObjectClass
+{
+ GObjectClass parent_class;
+};
+
+G_DEFINE_TYPE (SimpleObject, simple_object, G_TYPE_OBJECT);
+
+static void
+simple_object_finalize (GObject *object)
+{
+ G_OBJECT_CLASS (simple_object_parent_class)->finalize (object);
+}
+
+static void
+simple_object_class_init (SimpleObjectClass *class)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (class);
+
+ object_class->finalize = simple_object_finalize;
+}
+
+static void
+simple_object_init (SimpleObject *simple_object)
+{
+ simple_object->val = 42;
+}
+
+typedef struct _TestIfaceClass TestIfaceClass;
+typedef struct _TestIfaceClass TestIface1Class;
+typedef struct _TestIfaceClass TestIface2Class;
+typedef struct _TestIfaceClass TestIface3Class;
+typedef struct _TestIfaceClass TestIface4Class;
+typedef struct _TestIfaceClass TestIface5Class;
+typedef struct _TestIface TestIface;
+
+struct _TestIfaceClass
+{
+ GTypeInterface base_iface;
+ void (*method) (TestIface *obj);
+};
+
+#define TEST_TYPE_IFACE1 (test_iface1_get_type ())
+#define TEST_TYPE_IFACE2 (test_iface2_get_type ())
+#define TEST_TYPE_IFACE3 (test_iface3_get_type ())
+#define TEST_TYPE_IFACE4 (test_iface4_get_type ())
+#define TEST_TYPE_IFACE5 (test_iface5_get_type ())
+
+static DEFINE_IFACE (TestIface1, test_iface1, NULL, NULL)
+static DEFINE_IFACE (TestIface2, test_iface2, NULL, NULL)
+static DEFINE_IFACE (TestIface3, test_iface3, NULL, NULL)
+static DEFINE_IFACE (TestIface4, test_iface4, NULL, NULL)
+static DEFINE_IFACE (TestIface5, test_iface5, NULL, NULL)
+
+/*************************************************************
+ * Complex object is a GObject subclass with a properties,
+ * construct properties, signals and implementing an interface.
+ *************************************************************/
+
+#define COMPLEX_TYPE_OBJECT (complex_object_get_type ())
+typedef struct _ComplexObject ComplexObject;
+typedef struct _ComplexObjectClass ComplexObjectClass;
+
+struct _ComplexObject
+{
+ GObject parent_instance;
+ int val1;
+ int val2;
+};
+
+struct _ComplexObjectClass
+{
+ GObjectClass parent_class;
+
+ void (*signal) (ComplexObject *obj);
+};
+
+static void complex_test_iface_init (gpointer g_iface,
+ gpointer iface_data);
+
+G_DEFINE_TYPE_EXTENDED (ComplexObject, complex_object,
+ G_TYPE_OBJECT, 0,
+ G_IMPLEMENT_INTERFACE (TEST_TYPE_IFACE1,
+ complex_test_iface_init)
+ G_IMPLEMENT_INTERFACE (TEST_TYPE_IFACE2,
+ complex_test_iface_init)
+ G_IMPLEMENT_INTERFACE (TEST_TYPE_IFACE3,
+ complex_test_iface_init)
+ G_IMPLEMENT_INTERFACE (TEST_TYPE_IFACE4,
+ complex_test_iface_init)
+ G_IMPLEMENT_INTERFACE (TEST_TYPE_IFACE5,
+ complex_test_iface_init)
+ );
+
+#define COMPLEX_OBJECT(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), COMPLEX_TYPE_OBJECT, ComplexObject))
+
+enum {
+ PROP_0,
+ PROP_VAL1,
+ PROP_VAL2
+};
+
+enum {
+ COMPLEX_SIGNAL,
+ COMPLEX_LAST_SIGNAL
+};
+
+static guint complex_signals[COMPLEX_LAST_SIGNAL] = { 0 };
+
+static void
+complex_object_finalize (GObject *object)
+{
+ G_OBJECT_CLASS (complex_object_parent_class)->finalize (object);
+}
+
+static void
+complex_object_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ ComplexObject *complex = COMPLEX_OBJECT (object);
+
+ switch (prop_id)
+ {
+ case PROP_VAL1:
+ complex->val1 = g_value_get_int (value);
+ break;
+ case PROP_VAL2:
+ complex->val2 = g_value_get_int (value);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+complex_object_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ ComplexObject *complex = COMPLEX_OBJECT (object);
+
+ switch (prop_id)
+ {
+ case PROP_VAL1:
+ g_value_set_int (value, complex->val1);
+ break;
+ case PROP_VAL2:
+ g_value_set_int (value, complex->val2);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+complex_object_real_signal (ComplexObject *obj)
+{
+}
+
+static void
+complex_object_class_init (ComplexObjectClass *class)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (class);
+
+ object_class->finalize = complex_object_finalize;
+ object_class->set_property = complex_object_set_property;
+ object_class->get_property = complex_object_get_property;
+ class->signal = complex_object_real_signal;
+
+ complex_signals[COMPLEX_SIGNAL] =
+ g_signal_new ("signal",
+ G_TYPE_FROM_CLASS (object_class),
+ G_SIGNAL_RUN_FIRST,
+ G_STRUCT_OFFSET (ComplexObjectClass, signal),
+ NULL, NULL,
+ g_cclosure_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+
+ g_object_class_install_property (object_class,
+ PROP_VAL1,
+ g_param_spec_int ("val1",
+ "val1",
+ "val1",
+ 0,
+ G_MAXINT,
+ 42,
+ G_PARAM_CONSTRUCT | G_PARAM_READWRITE));
+ g_object_class_install_property (object_class,
+ PROP_VAL2,
+ g_param_spec_int ("val2",
+ "val2",
+ "val2",
+ 0,
+ G_MAXINT,
+ 43,
+ G_PARAM_READWRITE));
+
+
+}
+
+static void
+complex_object_iface_method (TestIface *obj)
+{
+ ComplexObject *complex = COMPLEX_OBJECT (obj);
+ complex->val1++;
+}
+
+static void
+complex_test_iface_init (gpointer g_iface,
+ gpointer iface_data)
+{
+ TestIfaceClass *iface = g_iface;
+ iface->method = complex_object_iface_method;
+}
+
+static void
+complex_object_init (ComplexObject *complex_object)
+{
+ complex_object->val2 = 43;
+}
+
+/*************************************************************
+ * Test object construction performance
+ *************************************************************/
+
+#define NUM_OBJECT_TO_CONSTRUCT 10000
+
+struct ConstructionTest {
+ GObject **objects;
+ int n_objects;
+ GType type;
+};
+
+static gpointer
+test_construction_setup (PerformanceTest *test)
+{
+ struct ConstructionTest *data;
+
+ data = g_new0 (struct ConstructionTest, 1);
+ data->type = ((GType (*)())test->extra_data)();
+
+ return data;
+}
+
+static void
+test_construction_init (PerformanceTest *test,
+ gpointer _data,
+ double count_factor)
+{
+ struct ConstructionTest *data = _data;
+ int n;
+
+ n = NUM_OBJECT_TO_CONSTRUCT * count_factor;
+ if (data->n_objects != n)
+ {
+ data->n_objects = n;
+ data->objects = g_new (GObject *, n);
+ }
+}
+
+static void
+test_construction_run (PerformanceTest *test,
+ gpointer _data)
+{
+ struct ConstructionTest *data = _data;
+ GObject **objects = data->objects;
+ GType type = data->type;
+ int i, n_objects;
+
+ n_objects = data->n_objects;
+ for (i = 0; i < n_objects; i++)
+ objects[i] = g_object_new (type, NULL);
+}
+
+static void
+test_construction_finish (PerformanceTest *test,
+ gpointer _data)
+{
+ struct ConstructionTest *data = _data;
+ int i;
+
+ for (i = 0; i < data->n_objects; i++)
+ g_object_unref (data->objects[i]);
+}
+
+static void
+test_construction_teardown (PerformanceTest *test,
+ gpointer _data)
+{
+ struct ConstructionTest *data = _data;
+ g_free (data->objects);
+ g_free (data);
+}
+
+static void
+test_construction_print_result (PerformanceTest *test,
+ gpointer _data,
+ double time)
+{
+ struct ConstructionTest *data = _data;
+
+ g_print ("Number of constructed objects per second: %.0f\n",
+ data->n_objects / time);
+}
+
+/*************************************************************
+ * Test runtime type check performance
+ *************************************************************/
+
+#define NUM_KILO_CHECKS_PER_ROUND 50
+
+struct TypeCheckTest {
+ GObject *object;
+ int n_checks;
+};
+
+static gpointer
+test_type_check_setup (PerformanceTest *test)
+{
+ struct TypeCheckTest *data;
+
+ data = g_new0 (struct TypeCheckTest, 1);
+ data->object = g_object_new (COMPLEX_TYPE_OBJECT, NULL);
+
+ return data;
+}
+
+static void
+test_type_check_init (PerformanceTest *test,
+ gpointer _data,
+ double factor)
+{
+ struct TypeCheckTest *data = _data;
+
+ data->n_checks = factor * NUM_KILO_CHECKS_PER_ROUND;
+}
+
+
+/* Work around g_type_check_instance_is_a being marked "pure",
+ and thus only called once for the loop. */
+gboolean (*my_type_check_instance_is_a) (GTypeInstance *type_instance,
+ GType iface_type) = &g_type_check_instance_is_a;
+
+static void
+test_type_check_run (PerformanceTest *test,
+ gpointer _data)
+{
+ struct TypeCheckTest *data = _data;
+ volatile GObject *object = data->object;
+ volatile GType type, types[5];
+ int i, j;
+
+ types[0] = test_iface1_get_type ();
+ types[1] = test_iface2_get_type ();
+ types[2] = test_iface3_get_type ();
+ types[3] = test_iface4_get_type ();
+ types[4] = test_iface5_get_type ();
+
+ for (i = 0; i < data->n_checks; i++)
+ {
+ type = types[i%5];
+ for (j = 0; j < 1000; j++)
+ {
+ my_type_check_instance_is_a ((GTypeInstance *)object,
+ type);
+ }
+ }
+}
+
+static void
+test_type_check_finish (PerformanceTest *test,
+ gpointer data)
+{
+}
+
+static void
+test_type_check_print_result (PerformanceTest *test,
+ gpointer _data,
+ double time)
+{
+ struct TypeCheckTest *data = _data;
+ g_print ("Million type checks per second: %.2f\n",
+ data->n_checks / (1000*time));
+}
+
+static void
+test_type_check_teardown (PerformanceTest *test,
+ gpointer _data)
+{
+ struct TypeCheckTest *data = _data;
+
+ g_object_unref (data->object);
+ g_free (data);
+}
+
+/*************************************************************
+ * Test signal emissions performance
+ *************************************************************/
+
+#define NUM_EMISSIONS_PER_ROUND 10000
+
+struct EmissionTest {
+ GObject *object;
+ int n_checks;
+};
+static gpointer
+test_emission_setup (PerformanceTest *test)
+{
+ struct EmissionTest *data;
+
+ data = g_new0 (struct EmissionTest, 1);
+ data->object = g_object_new (COMPLEX_TYPE_OBJECT, NULL);
+
+ return data;
+}
+
+static void
+test_emission_init (PerformanceTest *test,
+ gpointer _data,
+ double factor)
+{
+ struct EmissionTest *data = _data;
+
+ data->n_checks = factor * NUM_EMISSIONS_PER_ROUND;
+}
+
+static void
+test_emission_run (PerformanceTest *test,
+ gpointer _data)
+{
+ struct EmissionTest *data = _data;
+ GObject *object = data->object;
+ int i;
+
+ for (i = 0; i < data->n_checks; i++)
+ g_signal_emit (object,
+ complex_signals[COMPLEX_SIGNAL],
+ 0);
+}
+
+static void
+test_emission_finish (PerformanceTest *test,
+ gpointer data)
+{
+}
+
+static void
+test_emission_print_result (PerformanceTest *test,
+ gpointer _data,
+ double time)
+{
+ struct EmissionTest *data = _data;
+
+ g_print ("Emissions per second: %.0f\n",
+ data->n_checks / time);
+}
+
+static void
+test_emission_teardown (PerformanceTest *test,
+ gpointer _data)
+{
+ struct EmissionTest *data = _data;
+
+ g_object_unref (data->object);
+ g_free (data);
+}
+
+
+
+/*************************************************************
+ * Main test code
+ *************************************************************/
+
+static PerformanceTest tests[] = {
+ {
+ "simple-construction",
+ simple_object_get_type,
+ test_construction_setup,
+ test_construction_init,
+ test_construction_run,
+ test_construction_finish,
+ test_construction_teardown,
+ test_construction_print_result
+ },
+ {
+ "complex-construction",
+ complex_object_get_type,
+ test_construction_setup,
+ test_construction_init,
+ test_construction_run,
+ test_construction_finish,
+ test_construction_teardown,
+ test_construction_print_result
+ },
+ {
+ "type-check",
+ NULL,
+ test_type_check_setup,
+ test_type_check_init,
+ test_type_check_run,
+ test_type_check_finish,
+ test_type_check_teardown,
+ test_type_check_print_result
+ },
+ {
+ "emit",
+ NULL,
+ test_emission_setup,
+ test_emission_init,
+ test_emission_run,
+ test_emission_finish,
+ test_emission_teardown,
+ test_emission_print_result
+ }
+};
+
+static PerformanceTest *
+find_test (const char *name)
+{
+ int i;
+ for (i = 0; i < G_N_ELEMENTS (tests); i++)
+ {
+ if (strcmp (tests[i].name, name) == 0)
+ return &tests[i];
+ }
+ return NULL;
+}
+int
+main (int argc,
+ char *argv[])
+{
+ PerformanceTest *test;
+ GOptionContext *context;
+ GError *error = NULL;
+ int i;
+
+ g_type_init ();
+
+ context = g_option_context_new ("GObject performance tests");
+ g_option_context_add_main_entries (context, cmd_entries, NULL);
+ if (!g_option_context_parse (context, &argc, &argv, &error))
+ {
+ g_printerr ("%s: %s\n", argv[0], error->message);
+ return 1;
+ }
+
+ if (init_threads)
+ g_thread_init (NULL);
+
+ if (argc > 1)
+ {
+ for (i = 1; i < argc; i++)
+ {
+ test = find_test (argv[i]);
+ if (test)
+ run_test (test);
+ }
+ }
+ else
+ {
+ for (i = 0; i < G_N_ELEMENTS (tests); i++)
+ run_test (&tests[i]);
+ }
+
+ return 0;
+}