mirror of
https://gitlab.gnome.org/GNOME/glib.git
synced 2024-11-05 08:56:16 +01:00
730 lines
17 KiB
C
730 lines
17 KiB
C
/* 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 int test_length = DEFAULT_TEST_TIME;
|
|
|
|
static GOptionEntry cmd_entries[] = {
|
|
{"verbose", 'v', 0, G_OPTION_ARG_NONE, &verbose,
|
|
"Print extra information", 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 (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;
|
|
}
|