AuroraMiddleware/gtk2
1
0
Fork 0
forked from AuroraMiddleware/gtk
Code Issues Pull Requests Projects Releases Wiki Activity

Port tracing to the sysprof collector api

Browse Source 
Use the new sysprof collector api to do tracing.
This commit is contained in:
Matthias Clasen 2020-08-19 18:49:34 -04:00
parent a416650f6b
commit d4e069a629
24 changed files with 257 additions and 399 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
config.h.meson
View File

@ -103,7 +103,7 @@
#mesondefine HAVE_SYS_PARAM_H
/* Have the sysprof-capture library */
#mesondefine HAVE_SYSPROF_CAPTURE
#mesondefine HAVE_SYSPROF
/* Define to 1 if you have the <sys/stat.h> header file. */
#mesondefine HAVE_SYS_STAT_H

6
gdk/gdk.c
View File

@ -26,7 +26,6 @@
#include "gdkversionmacros.h"
#include "gdkprofilerprivate.h"
#include "gdkinternals.h"
#include "gdkintl.h"
@ -304,11 +303,6 @@ gdk_pre_parse (void)
g_warning ("GDK_DEBUG set but ignored because GTK isn't built with G_ENABLE_DEBUG");
#endif /* G_ENABLE_DEBUG */
if (g_getenv ("GTK_TRACE_FD"))
gdk_profiler_start (atoi (g_getenv ("GTK_TRACE_FD")));
else if (g_getenv ("GTK_TRACE"))
gdk_profiler_start (-1);
#ifndef G_HAS_CONSTRUCTORS
stash_desktop_startup_notification_id ();
#endif

13
gdk/gdkdrawcontext.c
View File

@ -175,17 +175,13 @@ gdk_draw_context_class_init (GdkDrawContextClass *klass)
g_object_class_install_properties (gobject_class, LAST_PROP, pspecs);
}
#ifdef G_ENABLE_DEBUG
static guint pixels_counter;
#endif
static void
gdk_draw_context_init (GdkDrawContext *self)
{
#ifdef G_ENABLE_DEBUG
if (pixels_counter == 0)
pixels_counter = gdk_profiler_define_int_counter ("frame pixels", "Pixels drawn per frame");
#endif
}
/**
@ -325,7 +321,7 @@ gdk_draw_context_begin_frame (GdkDrawContext *context,
GDK_DRAW_CONTEXT_GET_CLASS (context)->begin_frame (context, priv->frame_region);
}
#ifdef G_ENABLE_DEBUG
#ifdef HAVE_SYSPROF
static gint64
region_get_pixels (cairo_region_t *region)
{
@ -383,12 +379,7 @@ gdk_draw_context_end_frame (GdkDrawContext *context)
GDK_DRAW_CONTEXT_GET_CLASS (context)->end_frame (context, priv->frame_region);
#ifdef G_ENABLE_DEBUG
if (GDK_PROFILER_IS_RUNNING)
gdk_profiler_set_int_counter (pixels_counter,
g_get_monotonic_time (),
region_get_pixels (priv->frame_region));
#endif
gdk_profiler_set_int_counter (pixels_counter, region_get_pixels (priv->frame_region));
g_clear_pointer (&priv->frame_region, cairo_region_destroy);
g_clear_object (&priv->surface->paint_context);

39
gdk/gdkframeclock.c
View File

@ -673,34 +673,37 @@ _gdk_frame_clock_emit_before_paint (GdkFrameClock *frame_clock)
void
_gdk_frame_clock_emit_update (GdkFrameClock *frame_clock)
{
gint64 before = g_get_monotonic_time ();
gint64 before G_GNUC_UNUSED;
before = GDK_PROFILER_CURRENT_TIME;
g_signal_emit (frame_clock, signals[UPDATE], 0);
if (GDK_PROFILER_IS_RUNNING)
gdk_profiler_end_mark (before, "frameclock update", NULL);
gdk_profiler_end_mark (before, "frameclock update", NULL);
}
void
_gdk_frame_clock_emit_layout (GdkFrameClock *frame_clock)
{
gint64 before = g_get_monotonic_time ();
gint64 before G_GNUC_UNUSED;
before = GDK_PROFILER_CURRENT_TIME;
g_signal_emit (frame_clock, signals[LAYOUT], 0);
if (GDK_PROFILER_IS_RUNNING)
gdk_profiler_end_mark (before, "frameclock layout", NULL);
gdk_profiler_end_mark (before, "frameclock layout", NULL);
}
void
_gdk_frame_clock_emit_paint (GdkFrameClock *frame_clock)
{
gint64 before = g_get_monotonic_time ();
gint64 before G_GNUC_UNUSED;
before = GDK_PROFILER_CURRENT_TIME;
g_signal_emit (frame_clock, signals[PAINT], 0);
if (GDK_PROFILER_IS_RUNNING)
gdk_profiler_end_mark (before, "frameclock paint", NULL);
gdk_profiler_end_mark (before, "frameclock paint", NULL);
}
void
@ -715,6 +718,7 @@ _gdk_frame_clock_emit_resume_events (GdkFrameClock *frame_clock)
g_signal_emit (frame_clock, signals[RESUME_EVENTS], 0);
}
#ifdef HAVE_SYSPROF
static gint64
guess_refresh_interval (GdkFrameClock *frame_clock)
{
@ -780,24 +784,25 @@ frame_clock_get_fps (GdkFrameClock *frame_clock)
interval = guess_refresh_interval (frame_clock);
if (interval == 0)
return 0.0;
}
}
return ((double) end_counter - start_counter) * G_USEC_PER_SEC / (end_timestamp - start_timestamp);
}
#endif
void
_gdk_frame_clock_add_timings_to_profiler (GdkFrameClock *clock,
GdkFrameTimings *timings)
{
if (timings->drawn_time != 0)
gdk_profiler_add_mark (timings->drawn_time, 0, "drawn window", NULL);
{
gdk_profiler_add_mark (1000 * timings->drawn_time, 0, "drawn window", NULL);
}
if (timings->presentation_time != 0)
gdk_profiler_add_mark (timings->presentation_time, 0, "presented window", NULL);
if (timings->presentation_time != 0 || timings->drawn_time != 0)
{
gint64 time = timings->presentation_time != 0 ? timings->presentation_time : timings->drawn_time;
gdk_profiler_set_counter (fps_counter, time, frame_clock_get_fps (clock));
gdk_profiler_add_mark (1000 * timings->presentation_time, 0, "presented window", NULL);
}
gdk_profiler_set_counter (fps_counter, frame_clock_get_fps (clock));
}

12
gdk/gdkframeclockidle.c
View File

@ -57,7 +57,7 @@ struct _GdkFrameClockIdlePrivate
for details. */
gint64 sleep_serial;
gint64 freeze_time;
gint64 freeze_time; /* in microseconds */
guint flush_idle_id;
guint paint_idle_id;
@ -400,7 +400,9 @@ gdk_frame_clock_paint_idle (void *data)
GdkFrameClockIdlePrivate *priv = clock_idle->priv;
gboolean skip_to_resume_events;
GdkFrameTimings *timings = NULL;
gint64 before = g_get_monotonic_time ();
gint64 before G_GNUC_UNUSED;
before = GDK_PROFILER_CURRENT_TIME;
priv->paint_idle_id = 0;
priv->in_paint_idle = TRUE;
@ -659,8 +661,7 @@ gdk_frame_clock_paint_idle (void *data)
if (priv->freeze_count == 0)
priv->sleep_serial = get_sleep_serial ();
if (GDK_PROFILER_IS_RUNNING)
gdk_profiler_end_mark (before, "frameclock cycle", NULL);
gdk_profiler_end_mark (before, "frameclock cycle", NULL);
return FALSE;
}
@ -766,8 +767,7 @@ gdk_frame_clock_idle_thaw (GdkFrameClock *clock)
{
if (priv->freeze_time != 0)
{
gdk_profiler_end_mark (priv->freeze_time,
"frameclock frozen", NULL);
gdk_profiler_end_mark (priv->freeze_time * 1000, "frameclock frozen", NULL);
priv->freeze_time = 0;
}
}

324
gdk/gdkprofiler.c
View File

@ -20,6 +20,8 @@
#include "config.h"
#include "gdkprofilerprivate.h"
#include <sys/types.h>
#include <signal.h>
@ -28,301 +30,133 @@
#endif
#include "gdkversionmacros.h"
#include "gdkprofilerprivate.h"
#include "gdkframeclockprivate.h"
#ifdef HAVE_SYSPROF_CAPTURE
#include <sysprof-capture.h>
static SysprofCaptureWriter *writer = NULL;
static gboolean running = FALSE;
static void
profiler_stop (int s)
{
if (writer)
sysprof_capture_writer_unref (writer);
}
void
gdk_profiler_start (int fd)
{
if (writer)
return;
sysprof_clock_init ();
if (fd == -1)
{
char *filename;
filename = g_strdup_printf ("gtk.%d.syscap", getpid ());
g_print ("Writing profiling data to %s\n", filename);
writer = sysprof_capture_writer_new (filename, 16*1024);
g_free (filename);
}
else if (fd > 2)
writer = sysprof_capture_writer_new_from_fd (fd, 16*1024);
if (writer)
running = TRUE;
atexit (G_CALLBACK (profiler_stop));
signal (SIGTERM, profiler_stop);
}
void
gdk_profiler_stop (void)
{
running = FALSE;
}
gboolean
gdk_profiler_is_running (void)
{
return running;
#ifdef HAVE_SYSPROF
return sysprof_collector_is_active ();
#else
return FALSE;
#endif
}
void
gdk_profiler_add_mark (gint64 start,
guint64 duration,
const char *name,
const char *message)
(gdk_profiler_add_mark) (gint64 begin_time,
gint64 duration,
const char *name,
const char *message)
{
if (!running)
return;
sysprof_capture_writer_add_mark (writer,
start * 1000L,
-1, getpid (),
duration * 1000L,
"gtk", name, message);
}
static void add_markvf (gint64 start,
guint64 duration,
const char *name,
const char *format,
va_list args) G_GNUC_PRINTF(4, 0);
static void
add_markvf (gint64 start,
guint64 duration,
const char *name,
const char *format,
va_list args)
{
char *message;
message = g_strdup_vprintf (format, args);
sysprof_capture_writer_add_mark (writer,
start * 1000L,
-1, getpid (),
duration * 1000L,
"gtk", name, message);
g_free (message);
#ifdef HAVE_SYSPROF
sysprof_collector_mark (begin_time, duration, "gtk", name, message);
#endif
}
void
gdk_profiler_add_markf (gint64 start,
guint64 duration,
const char *name,
const char *format,
...)
(gdk_profiler_end_mark) (gint64 begin_time,
const char *name,
const char *message)
{
#ifdef HAVE_SYSPROF
sysprof_collector_mark (begin_time, GDK_PROFILER_CURRENT_TIME - begin_time, "gtk", name, message);
#endif
}
void
(gdk_profiler_add_markf) (gint64 begin_time,
gint64 duration,
const gchar *name,
const gchar *message_format,
...)
{
#ifdef HAVE_SYSPROF
va_list args;
if (!running)
return;
va_start (args, format);
add_markvf (start, duration, name, format, args);
va_start (args, message_format);
sysprof_collector_mark_vprintf (begin_time, duration, "gtk", name, message_format, args);
va_end (args);
#endif /* HAVE_SYSPROF */
}
void
gdk_profiler_end_mark (gint64 start,
const char *name,
const char *message)
{
if (!running)
return;
sysprof_capture_writer_add_mark (writer,
start * 1000L,
-1, getpid (),
(g_get_monotonic_time () - start) * 1000L,
"gtk", name, message);
}
void
gdk_profiler_end_markf (gint64 start,
const char *name,
const char *format,
...)
(gdk_profiler_end_markf) (gint64 begin_time,
const gchar *name,
const gchar *message_format,
...)
{
#ifdef HAVE_SYSPROF
va_list args;
if (!running)
return;
va_start (args, format);
add_markvf (start, g_get_monotonic_time () - start, name, format, args);
va_start (args, message_format);
sysprof_collector_mark_vprintf (begin_time, GDK_PROFILER_CURRENT_TIME - begin_time, "gtk", name, message_format, args);
va_end (args);
#endif /* HAVE_SYSPROF */
}
static guint
define_counter (const char *name,
const char *description,
int type)
guint
(gdk_profiler_define_counter) (const char *name,
const char *description)
{
#ifdef HAVE_SYSPROF
SysprofCaptureCounter counter;
if (!writer)
return 0;
counter.id = (guint) sysprof_capture_writer_request_counter (writer, 1);
counter.type = type;
counter.value.vdbl = 0;
counter.id = sysprof_collector_request_counters (1);
counter.type = SYSPROF_CAPTURE_COUNTER_DOUBLE;
counter.value.vdbl = 0.0;
g_strlcpy (counter.category, "gtk", sizeof counter.category);
g_strlcpy (counter.name, name, sizeof counter.name);
g_strlcpy (counter.description, description, sizeof counter.name);
sysprof_capture_writer_define_counters (writer,
SYSPROF_CAPTURE_CURRENT_TIME,
-1,
getpid (),
&counter,
1);
sysprof_collector_define_counters (&counter, 1);
return counter.id;
#else
return 0;
#endif
}
guint
gdk_profiler_define_counter (const char *name,
const char *description)
(gdk_profiler_define_int_counter) (const char *name,
const char *description)
{
return define_counter (name, description, SYSPROF_CAPTURE_COUNTER_DOUBLE);
}
#ifdef HAVE_SYSPROF
SysprofCaptureCounter counter;
guint
gdk_profiler_define_int_counter (const char *name,
const char *description)
{
return define_counter (name, description, SYSPROF_CAPTURE_COUNTER_INT64);
counter.id = sysprof_collector_request_counters (1);
counter.type = SYSPROF_CAPTURE_COUNTER_INT64;
counter.value.v64 = 0;
g_strlcpy (counter.category, "gtk", sizeof counter.category);
g_strlcpy (counter.name, name, sizeof counter.name);
g_strlcpy (counter.description, description, sizeof counter.name);
sysprof_collector_define_counters (&counter, 1);
return counter.id;
#else
return 0;
#endif
}
void
gdk_profiler_set_counter (guint id,
gint64 time,
double val)
(gdk_profiler_set_counter) (guint id,
double val)
{
#ifdef HAVE_SYSPROF
SysprofCaptureCounterValue value;
if (!running)
return;
value.vdbl = val;
sysprof_capture_writer_set_counters (writer,
time * 1000L,
-1, getpid (),
&id, &value, 1);
sysprof_collector_set_counters (&id, &value, 1);
#endif
}
void
gdk_profiler_set_int_counter (guint id,
gint64 time,
gint64 val)
(gdk_profiler_set_int_counter) (guint id,
gint64 val)
{
#ifdef HAVE_SYSPROF
SysprofCaptureCounterValue value;
if (!running)
return;
value.v64 = val;
sysprof_capture_writer_set_counters (writer,
time * 1000L,
-1, getpid (),
&id, &value, 1);
sysprof_collector_set_counters (&id, &value, 1);
#endif
}
#else
void
gdk_profiler_start (int fd)
{
}
void
gdk_profiler_stop (void)
{
}
gboolean
gdk_profiler_is_running (void)
{
return FALSE;
}
void
gdk_profiler_add_mark (gint64 start,
guint64 duration,
const char *name,
const char *message)
{
}
void
gdk_profiler_add_markf (gint64 start,
guint64 duration,
const char *name,
const char *format,
...)
{
}
void
gdk_profiler_end_mark (gint64 start,
const char *name,
const char *message)
{
}
void
gdk_profiler_end_markf (gint64 start,
const char *name,
const char *format,
...)
{
}
guint
gdk_profiler_define_counter (const char *name,
const char *description)
{
return 0;
}
void
gdk_profiler_set_counter (guint id,
gint64 time,
double value)
{
}
guint
gdk_profiler_define_int_counter (const char *name,
const char *description)
{
return 0;
}
void
gdk_profiler_set_int_counter (guint id,
gint64 time,
gint64 value)
{
}
#endif /* G_OS_WIN32 */

100
gdk/gdkprofilerprivate.h
View File

@ -21,52 +21,76 @@
#include "gdk/gdkframeclock.h"
#include "gdk/gdkdisplay.h"
G_BEGIN_DECLS
/* Ensure we included config.h as needed for the below HAVE_SYSPROF_CAPTURE check */
#ifndef GETTEXT_PACKAGE
#error "config.h was not included before gdkprofilerprivate.h."
#endif
/* We make this a macro you use as if (GDK_PROFILER_IS_RUNNING) because that
* way we can ensure all the code is compiled out when not supported, and
* we can add a G_UNLIKELY() for better codegen if it is.
*/
#ifdef HAVE_SYSPROF_CAPTURE
#define GDK_PROFILER_IS_RUNNING G_UNLIKELY (gdk_profiler_is_running ())
#else
#define GDK_PROFILER_IS_RUNNING FALSE
#ifdef HAVE_SYSPROF
#include <sysprof-capture.h>
#endif
G_BEGIN_DECLS
#ifdef HAVE_SYSPROF
#define GDK_PROFILER_IS_RUNNING (gdk_profiler_is_running ())
#define GDK_PROFILER_CURRENT_TIME SYSPROF_CAPTURE_CURRENT_TIME
#else
#define GDK_PROFILER_IS_RUNNING 0
#define GDK_PROFILER_CURRENT_TIME 0
#endif
void gdk_profiler_start (int fd);
void gdk_profiler_stop (void);
gboolean gdk_profiler_is_running (void);
void gdk_profiler_add_mark (gint64 start,
guint64 duration,
const char *name,
const char *message);
void gdk_profiler_add_markf (gint64 start,
guint64 duration,
const char *name,
const char *format,
...) G_GNUC_PRINTF (4, 5);
void gdk_profiler_end_mark (gint64 start,
const char *name,
const char *message);
void gdk_profiler_end_markf (gint64 start,
const char *name,
const char *format,
...) G_GNUC_PRINTF (3, 4);
guint gdk_profiler_define_counter (const char *name,
const char *description);
void gdk_profiler_set_counter (guint id,
gint64 time,
double value);
guint gdk_profiler_define_int_counter (const char *name,
const char *description);
void gdk_profiler_set_int_counter (guint id,
gint64 time,
gint64 value);
/* Note: Times and durations are in nanoseconds;
* g_get_monotonic_time(), and GdkFrameClock times
* are in microseconds, so multiply by 1000.
*/
void gdk_profiler_add_mark (gint64 begin_time,
gint64 duration,
const gchar *name,
const gchar *message);
void gdk_profiler_add_markf (gint64 begin_time,
gint64 duration,
const gchar *name,
const gchar *message_format,
...) G_GNUC_PRINTF (4, 5);
void gdk_profiler_end_mark (gint64 begin_time,
const gchar *name,
const gchar *message);
void gdk_profiler_end_markf (gint64 begin_time,
const gchar *name,
const gchar *message_format,
...) G_GNUC_PRINTF (3, 4);
guint gdk_profiler_define_counter (const char *name,
const char *description);
guint gdk_profiler_define_int_counter (const char *name,
const char *description);
void gdk_profiler_set_counter (guint id,
double value);
void gdk_profiler_set_int_counter (guint id,
gint64 value);
#ifndef HAVE_SYSPROF
#define gdk_profiler_add_mark(b, d, n, m)
#define gdk_profiler_end_mark(b, n, m)
/* Optimise the whole call out */
#if defined(G_HAVE_ISO_VARARGS)
#define gdk_profiler_add_markf(b, d, n, m, ...)
#define gdk_profiler_end_markf(b, n, m, ...)
#elif defined(G_HAVE_GNUC_VARARGS)
#define gdk_profiler_add_markf(b, d, n, m...)
#define gdk_profiler_end_markf(b, n, m...)
#else
/* no varargs macro support; the call will have to be optimised out by the compiler */
#endif
#define gdk_profiler_define_counter(n, d) 0
#define gdk_profiler_define_int_counter(n, d) 0
#define gdk_profiler_set_counter(i, v)
#define gdk_profiler_set_int_counter(i, v)
#endif
G_END_DECLS

12
gdk/gdksurface.c
View File

@ -2679,11 +2679,12 @@ check_autohide (GdkEvent *event)
return FALSE;
}
static void
static inline void
add_event_mark (GdkEvent *event,
gint64 time,
guint64 duration)
gint64 end_time)
{
#ifdef HAVE_SYSPROF
char *message = NULL;
const char *kind;
GEnumClass *class;
@ -2772,15 +2773,16 @@ add_event_mark (GdkEvent *event,
break;
}
gdk_profiler_add_mark (time, duration, "event", message ? message : kind);
gdk_profiler_add_mark (time, end_time - time, "event", message ? message : kind);
g_free (message);
#endif
}
gboolean
gdk_surface_handle_event (GdkEvent *event)
{
gint64 begin_time = g_get_monotonic_time ();
gint64 begin_time = GDK_PROFILER_CURRENT_TIME;
gboolean handled = FALSE;
if (check_autohide (event))
@ -2801,7 +2803,7 @@ gdk_surface_handle_event (GdkEvent *event)
}
if (GDK_PROFILER_IS_RUNNING)
add_event_mark (event, begin_time, g_get_monotonic_time () - begin_time);
add_event_mark (event, begin_time, GDK_PROFILER_CURRENT_TIME);
return handled;
}

7
gdk/wayland/gdkdisplay-wayland.c
View File

@ -1109,7 +1109,9 @@ _gdk_wayland_display_load_cursor_theme (GdkWaylandDisplay *display_wayland)
guint size;
const char *name;
GValue v = G_VALUE_INIT;
gint64 before = g_get_monotonic_time ();
gint64 before G_GNUC_UNUSED;
before = GDK_PROFILER_CURRENT_TIME;
g_assert (display_wayland);
g_assert (display_wayland->shm);
@ -1130,8 +1132,7 @@ _gdk_wayland_display_load_cursor_theme (GdkWaylandDisplay *display_wayland)
gdk_wayland_display_set_cursor_theme (GDK_DISPLAY (display_wayland), name, size);
g_value_unset (&v);
if (GDK_PROFILER_IS_RUNNING)
gdk_profiler_end_mark (before, "wayland", "load cursor theme");
gdk_profiler_end_mark (before, "wayland", "load cursor theme");
}

2
gdk/wayland/gdkglcontext-wayland.c
View File

@ -239,7 +239,7 @@ gdk_wayland_gl_context_end_frame (GdkDrawContext *draw_context,
gdk_wayland_surface_sync (surface);
gdk_wayland_surface_request_frame (surface);
gdk_profiler_add_mark (g_get_monotonic_time (), 0, "wayland", "swap buffers");
gdk_profiler_add_mark (GDK_PROFILER_CURRENT_TIME, 0, "wayland", "swap buffers");
if (display_wayland->have_egl_swap_buffers_with_damage)
{
int i, j, n_rects = cairo_region_num_rectangles (painted);

8
gdk/wayland/gdksurface-wayland.c
View File

@ -504,7 +504,7 @@ frame_callback (void *data,
GdkFrameClock *clock = gdk_surface_get_frame_clock (surface);
GdkFrameTimings *timings;
gdk_profiler_add_mark (g_get_monotonic_time (), 0, "wayland", "frame event");
gdk_profiler_add_mark (GDK_PROFILER_CURRENT_TIME, 0, "wayland", "frame event");
GDK_DISPLAY_NOTE (GDK_DISPLAY (display_wayland), EVENTS, g_message ("frame %p", surface));
wl_callback_destroy (callback);
@ -640,7 +640,7 @@ on_frame_clock_after_paint (GdkFrameClock *clock,
* before we need to stage any changes, then we can take it back and
* use it again.
*/
gdk_profiler_add_mark (g_get_monotonic_time (), 0, "wayland", "surface commit");
gdk_profiler_add_mark (GDK_PROFILER_CURRENT_TIME, 0, "wayland", "surface commit");
wl_surface_commit (impl->display_server.wl_surface);
impl->pending_commit = FALSE;
@ -1801,7 +1801,7 @@ gdk_wayland_surface_create_xdg_toplevel (GdkSurface *surface)
maybe_set_gtk_surface_dbus_properties (surface);
maybe_set_gtk_surface_modal (surface);
gdk_profiler_add_mark (g_get_monotonic_time (), 0, "wayland", "surface commit");
gdk_profiler_add_mark (GDK_PROFILER_CURRENT_TIME, 0, "wayland", "surface commit");
wl_surface_commit (impl->display_server.wl_surface);
}
@ -2558,7 +2558,7 @@ gdk_wayland_surface_create_xdg_popup (GdkSurface *surface,
}
}
gdk_profiler_add_mark (g_get_monotonic_time (), 0, "wayland", "surface commit");
gdk_profiler_add_mark (GDK_PROFILER_CURRENT_TIME, 0, "wayland", "surface commit");
wl_surface_commit (impl->display_server.wl_surface);
if (GDK_IS_POPUP (surface))

3
gdk/x11/gdkdisplay-x11.c
View File

@ -842,8 +842,7 @@ gdk_x11_display_translate_event (GdkEventTranslator *translator,
_gdk_x11_surface_grab_check_unmap (surface, xevent->xany.serial);
if (GDK_PROFILER_IS_RUNNING)
gdk_profiler_add_markf (g_get_monotonic_time (), 0, "unmapped window", "0x%lx", GDK_SURFACE_XID (surface));
gdk_profiler_add_markf (GDK_PROFILER_CURRENT_TIME, 0, "unmapped window", "0x%lx", GDK_SURFACE_XID (surface));
}
break;

13
gsk/gl/gskglrenderer.c
View File

@ -3069,8 +3069,9 @@ gsk_gl_renderer_realize (GskRenderer *renderer,
GError **error)
{
GskGLRenderer *self = GSK_GL_RENDERER (renderer);
gint64 before = g_get_monotonic_time ();
gint64 before G_GNUC_UNUSED;
before = GDK_PROFILER_CURRENT_TIME;
/* If we didn't get a GdkGLContext before realization, try creating
* one now, for our exclusive use.
*/
@ -3101,8 +3102,7 @@ gsk_gl_renderer_realize (GskRenderer *renderer,
self->icon_cache = get_icon_cache_for_display (gdk_surface_get_display (surface), self->atlases);
gsk_gl_shadow_cache_init (&self->shadow_cache);
if (GDK_PROFILER_IS_RUNNING)
gdk_profiler_end_mark (before, "gl renderer realize", NULL);
gdk_profiler_end_mark (before, "gl renderer realize", NULL);
return TRUE;
}
@ -3685,7 +3685,8 @@ gsk_gl_renderer_do_render (GskRenderer *renderer,
graphene_matrix_t projection;
#ifdef G_ENABLE_DEBUG
GskProfiler *profiler;
gint64 gpu_time, cpu_time, start_time;
gint64 gpu_time, cpu_time;
gint64 start_time G_GNUC_UNUSED;
#endif
GPtrArray *removed;
@ -3804,9 +3805,7 @@ gsk_gl_renderer_do_render (GskRenderer *renderer,
gsk_profiler_push_samples (profiler);
if (GDK_PROFILER_IS_RUNNING)
gdk_profiler_add_mark (start_time, cpu_time, "GL render", "");
gdk_profiler_add_mark (start_time * 1000, cpu_time * 1000, "GL render", "");
#endif
}

7
gsk/vulkan/gskvulkanrenderer.c
View File

@ -174,7 +174,8 @@ gsk_vulkan_renderer_render_texture (GskRenderer *renderer,
GdkTexture *texture;
#ifdef G_ENABLE_DEBUG
GskProfiler *profiler;
gint64 cpu_time, start_time;
gint64 cpu_time;
gint64 start_time G_GNUC_UNUSED;
#endif
#ifdef G_ENABLE_DEBUG
@ -213,12 +214,10 @@ gsk_vulkan_renderer_render_texture (GskRenderer *renderer,
if (GDK_PROFILER_IS_RUNNING)
{
gdk_profiler_add_mark (start_time, cpu_time, "render", "");
gdk_profiler_add_mark (start_time * 1000, cpu_time * 1000, "render", "");
gdk_profiler_set_int_counter (texture_pixels_counter,
start_time + cpu_time,
gsk_profiler_counter_get (profiler, self->profile_counters.texture_pixels));
gdk_profiler_set_int_counter (fallback_pixels_counter,
start_time + cpu_time,
gsk_profiler_counter_get (profiler, self->profile_counters.fallback_pixels));
}
#endif

14
gtk/gtkapplication.c
View File

@ -252,25 +252,25 @@ gtk_application_startup (GApplication *g_application)
{
GtkApplication *application = GTK_APPLICATION (g_application);
GtkApplicationPrivate *priv = gtk_application_get_instance_private (application);
gint64 before = g_get_monotonic_time ();
gint64 before2;
gint64 before G_GNUC_UNUSED;
gint64 before2 G_GNUC_UNUSED;
before = GDK_PROFILER_CURRENT_TIME;
G_APPLICATION_CLASS (gtk_application_parent_class)->startup (g_application);
gtk_action_muxer_insert (priv->muxer, "app", G_ACTION_GROUP (application));
before2 = g_get_monotonic_time ();
before2 = GDK_PROFILER_CURRENT_TIME;
gtk_init ();
if (GDK_PROFILER_IS_RUNNING)
gdk_profiler_end_mark (before2, "gtk init", NULL);
gdk_profiler_end_mark (before2, "gtk init", NULL);
priv->impl = gtk_application_impl_new (application, gdk_display_get_default ());
gtk_application_impl_startup (priv->impl, priv->register_session);
gtk_application_load_resources (application);
if (GDK_PROFILER_IS_RUNNING)
gdk_profiler_end_mark (before, "gtk application startup", NULL);
gdk_profiler_end_mark (before, "gtk application startup", NULL);
}
static void

10
gtk/gtkbuilderparser.c
View File

@ -2168,7 +2168,7 @@ _gtk_builder_parser_parse_buffer (GtkBuilder *builder,
const char * domain;
ParserData data;
GSList *l;
gint64 before = g_get_monotonic_time ();
gint64 before = GDK_PROFILER_CURRENT_TIME;
/* Store the original domain so that interface domain attribute can be
* applied for the builder and the original domain can be restored after
@ -2246,8 +2246,10 @@ _gtk_builder_parser_parse_buffer (GtkBuilder *builder,
if (GDK_PROFILER_IS_RUNNING)
{
guint64 after = g_get_monotonic_time ();
if (after - before > 500)
gdk_profiler_add_mark (before, after - before, "builder load", filename);
guint64 after = GDK_PROFILER_CURRENT_TIME;
if (after - before > 500000) /* half a millisecond */
{
gdk_profiler_add_mark (before, after - before, "builder load", filename);
}
}
}

11
gtk/gtkcssnode.c
View File

@ -1364,7 +1364,9 @@ gtk_css_node_validate (GtkCssNode *cssnode)
{
GtkCountingBloomFilter filter = GTK_COUNTING_BLOOM_FILTER_INIT;
gint64 timestamp;
gint64 before = g_get_monotonic_time ();
gint64 before G_GNUC_UNUSED;
before = GDK_PROFILER_CURRENT_TIME;
g_assert (cssnode->parent == NULL);
@ -1374,10 +1376,9 @@ gtk_css_node_validate (GtkCssNode *cssnode)
if (GDK_PROFILER_IS_RUNNING)
{
gint64 after = g_get_monotonic_time ();
gdk_profiler_add_mark (before, (after - before), "css validation", "");
gdk_profiler_set_int_counter (invalidated_nodes_counter, after, invalidated_nodes);
gdk_profiler_set_int_counter (created_styles_counter, after, created_styles);
gdk_profiler_end_mark (before, "css validation", "");
gdk_profiler_set_int_counter (invalidated_nodes_counter, invalidated_nodes);
gdk_profiler_set_int_counter (created_styles_counter, created_styles);
invalidated_nodes = 0;
created_styles = 0;
}

11
gtk/gtkcssprovider.c
View File

@ -978,7 +978,9 @@ gtk_css_provider_postprocess (GtkCssProvider *css_provider)
GtkCssProviderPrivate *priv = gtk_css_provider_get_instance_private (css_provider);
GtkCssSelectorTreeBuilder *builder;
guint i;
gint64 before = g_get_monotonic_time ();
gint64 before G_GNUC_UNUSED;
before = GDK_PROFILER_CURRENT_TIME;
g_array_sort (priv->rulesets, gtk_css_provider_compare_rule);
@ -1010,8 +1012,7 @@ gtk_css_provider_postprocess (GtkCssProvider *css_provider)
}
#endif
if (GDK_PROFILER_IS_RUNNING)
gdk_profiler_end_mark (before, "create selector tree", NULL);
gdk_profiler_end_mark (before, "create selector tree", NULL);
}
static void
@ -1020,7 +1021,9 @@ gtk_css_provider_load_internal (GtkCssProvider *self,
GFile *file,
GBytes *bytes)
{
gint64 before = g_get_monotonic_time ();
gint64 before G_GNUC_UNUSED;
before = GDK_PROFILER_CURRENT_TIME;
if (bytes == NULL)
{

14
gtk/gtkemojichooser.c
View File

@ -571,9 +571,9 @@ populate_emoji_chooser (gpointer data)
{
GtkEmojiChooser *chooser = data;
GVariant *item;
guint64 start, now;
gint64 start, now;
start = g_get_monotonic_time ();
start = GDK_PROFILER_CURRENT_TIME;
if (!chooser->data)
{
@ -614,11 +614,10 @@ populate_emoji_chooser (gpointer data)
add_emoji (chooser->box, FALSE, item, 0, chooser);
g_variant_unref (item);
now = g_get_monotonic_time ();
if (now > start + 8000)
now = GDK_PROFILER_CURRENT_TIME;
if (now > start + 2000000) /* 2 ms */
{
if (GDK_PROFILER_IS_RUNNING)
gdk_profiler_add_mark (start, (now - start), "emojichooser", "populate");
gdk_profiler_add_mark (start, (now - start), "emojichooser", "populate");
return G_SOURCE_CONTINUE;
}
}
@ -628,8 +627,7 @@ populate_emoji_chooser (gpointer data)
chooser->box = NULL;
chooser->populate_idle = 0;
if (GDK_PROFILER_IS_RUNNING)
gdk_profiler_end_mark (start, "emojichooser", "populate (finish)");
gdk_profiler_end_mark (start, "emojichooser", "populate (finish)");
return G_SOURCE_REMOVE;
}

20
gtk/gtkicontheme.c
View File

@ -2070,16 +2070,16 @@ ensure_valid_themes (GtkIconTheme *self,
if (!self->themes_valid)
{
gint64 before;
gint64 before G_GNUC_UNUSED;
if (non_blocking)
return FALSE;
before = g_get_monotonic_time ();
before = GDK_PROFILER_CURRENT_TIME;
load_themes (self);
if (GDK_PROFILER_IS_RUNNING)
gdk_profiler_end_mark (before, "icon theme load", self->current_theme);
gdk_profiler_end_mark (before, "icon theme load", self->current_theme);
if (was_valid)
queue_theme_changed (self);
@ -3720,7 +3720,7 @@ icon_ensure_texture__locked (GtkIconPaintable *icon,
if (icon->texture)
return;
before = g_get_monotonic_time ();
before = GDK_PROFILER_CURRENT_TIME;
/* This is the natural pixel size for the requested icon size + scale in this directory.
* We precalculate this so we can use it as a rasterization size for svgs.
@ -3825,11 +3825,13 @@ icon_ensure_texture__locked (GtkIconPaintable *icon,
if (GDK_PROFILER_IS_RUNNING)
{
guint64 end = g_get_monotonic_time ();
gint64 end = GDK_PROFILER_CURRENT_TIME;
/* Don't report quick (< 0.5 msec) parses */
if (end - before > 500 || !in_thread)
gdk_profiler_add_markf (before, (end - before), in_thread ? "icon load (thread)" : "icon load" ,
"%s size %d@%d", icon->filename, icon->desired_size, icon->desired_scale);
if (end - before > 500000 || !in_thread)
{
gdk_profiler_add_markf (before, (end - before), in_thread ? "icon load (thread)" : "icon load" ,
"%s size %d@%d", icon->filename, icon->desired_size, icon->desired_scale);
}
}
}

7
gtk/gtkimcontextsimple.c
View File

@ -247,15 +247,16 @@ init_compose_table_thread_cb (GTask *task,
gpointer task_data,
GCancellable *cancellable)
{
guint64 before = g_get_monotonic_time ();
gint64 before G_GNUC_UNUSED;
before = GDK_PROFILER_CURRENT_TIME;
if (g_task_return_error_if_cancelled (task))
return;
gtk_im_context_simple_init_compose_table ();
if (GDK_PROFILER_IS_RUNNING)
gdk_profiler_end_mark (before, "im compose table load (thread)", NULL);
gdk_profiler_end_mark (before, "im compose table load (thread)", NULL);
}
static void

12
gtk/gtkwidget.c
View File

@ -10951,8 +10951,11 @@ gtk_widget_render (GtkWidget *widget,
GskRenderer *renderer;
GskRenderNode *root;
double x, y;
gint64 before_snapshot = g_get_monotonic_time ();
gint64 before_render = 0;
gint64 before_snapshot G_GNUC_UNUSED;
gint64 before_render G_GNUC_UNUSED;
before_snapshot = GDK_PROFILER_CURRENT_TIME;
before_render = 0;
if (!GTK_IS_NATIVE (widget))
return;
@ -10969,7 +10972,7 @@ gtk_widget_render (GtkWidget *widget,
if (GDK_PROFILER_IS_RUNNING)
{
before_render = g_get_monotonic_time ();
before_render = GDK_PROFILER_CURRENT_TIME;
gdk_profiler_add_mark (before_snapshot, (before_render - before_snapshot), "widget snapshot", "");
}
@ -10985,8 +10988,7 @@ gtk_widget_render (GtkWidget *widget,
gsk_render_node_unref (root);
if (GDK_PROFILER_IS_RUNNING)
gdk_profiler_end_mark (before_render, "widget render", "");
gdk_profiler_end_mark (before_render, "widget render", "");
}
}

7
gtk/gtkwindow.c
View File

@ -1873,15 +1873,16 @@ static void
gtk_window_native_check_resize (GtkNative *native)
{
GtkWidget *widget = GTK_WIDGET (native);
gint64 before = g_get_monotonic_time ();
gint64 before G_GNUC_UNUSED;
before = GDK_PROFILER_CURRENT_TIME;
if (!_gtk_widget_get_alloc_needed (widget))
gtk_widget_ensure_allocate (widget);
else if (gtk_widget_get_visible (widget))
gtk_window_move_resize (GTK_WINDOW (native));
if (GDK_PROFILER_IS_RUNNING)
gdk_profiler_end_mark (before, "size allocation", "");
gdk_profiler_end_mark (before, "size allocation", "");
}
static void

2
meson.build
View File

@ -718,7 +718,7 @@ if profiler_enabled
fallback: ['sysprof', 'libsysprof_capture_dep'],
)
if profiler_dep.found()
cdata.set('HAVE_SYSPROF_CAPTURE', profiler_dep.found())
cdata.set('HAVE_SYSPROF', profiler_dep.found())
else
error('Profiler support not found, but was explicitly requested.')
endif