eUgEntOptIc44/gimp
1
1
Fork 0
mirror of https://gitlab.gnome.org/GNOME/gimp.git synced 2025-10-06 01:12:40 +02:00
Code Issues Releases Activity

app: add progressive performance logs

Browse Source 
Add an option to record progressive performance logs.  Progressive
logs contain complete information after each recorded sample, by
writing partial address maps at each sample, containing all new
addresses introduced by the sample.  Furthermore, when recording a
progressive log, the output stream is flushed after each sample.

This allows recording complete logs even in cases where they can't
be properly terminated, such as when GIMP crashes or freezes in the
middle of the log.

Progressive logs are disabled by default, since they potentially
increase the sampling cost.  They can be enabled through a toggle
in the log file-dialog, or through the
GIMP_PERFORMANCE_LOG_PROGRESSIVE environment varaible.
This commit is contained in:
Ell
2020-07-30 00:41:00 +03:00
parent 126002c5c9
commit 146c234350
3 changed files with 110 additions and 33 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
app/actions/dashboard-commands.c
View File

@@ -212,6 +212,20 @@ dashboard_log_record_cmd_callback (GimpAction *action,
G_CALLBACK (gimp_toggle_button_update),
&info->params.backtrace);
toggle = gtk_check_button_new_with_mnemonic (_("Progressi_ve"));
gimp_help_set_help_data (toggle, _("Produce complete log "
"even if not properly terminated"),
NULL);
gtk_box_pack_start (GTK_BOX (hbox), toggle, FALSE, FALSE, 0);
gtk_widget_show (toggle);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle),
info->params.progressive);
g_signal_connect (toggle, "toggled",
G_CALLBACK (gimp_toggle_button_update),
&info->params.progressive);
g_signal_connect (dialog, "response",
G_CALLBACK (dashboard_log_record_response),
dashboard);

128
app/widgets/gimpdashboard.c
View File

@@ -98,6 +98,7 @@
#define LOG_SAMPLE_FREQUENCY_MAX 1000 /* samples per second */
#define LOG_DEFAULT_SAMPLE_FREQUENCY 10 /* samples per second */
#define LOG_DEFAULT_BACKTRACE TRUE
#define LOG_DEFAULT_PROGRESSIVE FALSE
typedef enum
@@ -433,7 +434,11 @@ static void gimp_dashboard_log_sample (GimpDashboard
static void gimp_dashboard_log_update_highlight (GimpDashboard *dashboard);
static void gimp_dashboard_log_update_n_markers (GimpDashboard *dashboard);
static void gimp_dashboard_log_write_address_map (GimpAsync *async,
static void gimp_dashboard_log_write_address_map (GimpDashboard *dashboard,
guintptr *addresses,
gint n_addresses,
GimpAsync *async);
static void gimp_dashboard_log_write_global_address_map (GimpAsync *async,
GimpDashboard *dashboard);
static gboolean gimp_dashboard_field_use_meter_underlay (Group group,
@@ -3526,6 +3531,7 @@ gimp_dashboard_log_sample (GimpDashboard *dashboard,
{
GimpDashboardPrivate *priv = dashboard->priv;
GimpBacktrace *backtrace = NULL;
GArray *addresses = NULL;
gboolean empty = TRUE;
Variable variable;
@@ -3844,7 +3850,18 @@ gimp_dashboard_log_sample (GimpDashboard *dashboard,
"<frame address=\"0x%llx\" />\n",
(unsigned long long) address);
g_hash_table_add (priv->log_addresses, (gpointer) address);
if (g_hash_table_add (priv->log_addresses,
(gpointer) address) &&
priv->log_params.progressive)
{
if (! addresses)
{
addresses = g_array_new (FALSE, FALSE,
sizeof (guintptr));
}
g_array_append_val (addresses, address);
}
}
gimp_dashboard_log_printf (dashboard,
@@ -3887,6 +3904,19 @@ gimp_dashboard_log_sample (GimpDashboard *dashboard,
"</sample>\n");
}
if (addresses)
{
gimp_dashboard_log_write_address_map (dashboard,
(guintptr *) addresses->data,
addresses->len,
NULL);
g_array_free (addresses, TRUE);
}
if (priv->log_params.progressive)
g_output_stream_flush (priv->log_output, NULL, NULL);
#undef NONEMPTY
priv->log_n_samples++;
@@ -3934,34 +3964,17 @@ gimp_dashboard_log_compare_addresses (gconstpointer a1,
}
static void
gimp_dashboard_log_write_address_map (GimpAsync *async,
GimpDashboard *dashboard)
gimp_dashboard_log_write_address_map (GimpDashboard *dashboard,
guintptr *addresses,
gint n_addresses,
GimpAsync *async)
{
GimpDashboardPrivate *priv = dashboard->priv;
GimpBacktraceAddressInfo infos[2];
guintptr *addresses;
gint n_addresses;
GList *iter;
gint i;
gint n;
n_addresses = g_hash_table_size (priv->log_addresses);
GimpBacktraceAddressInfo infos[2];
gint i;
gint n;
if (n_addresses == 0)
{
gimp_async_finish (async, NULL);
return;
}
addresses = g_new (guintptr, n_addresses);
for (iter = g_hash_table_get_keys (priv->log_addresses), i = 0;
iter;
iter = g_list_next (iter), i++)
{
addresses[i] = (guintptr) iter->data;
}
return;
qsort (addresses, n_addresses, sizeof (guintptr),
gimp_dashboard_log_compare_addresses);
@@ -3977,7 +3990,7 @@ gimp_dashboard_log_write_address_map (GimpAsync *async,
GimpBacktraceAddressInfo *info = &infos[n % 2];
const GimpBacktraceAddressInfo *prev_info = &infos[(n + 1) % 2];
if (gimp_async_is_canceled (async))
if (async && gimp_async_is_canceled (async))
break;
if (gimp_backtrace_get_address_info (addresses[i], info))
@@ -4114,11 +4127,41 @@ gimp_dashboard_log_write_address_map (GimpAsync *async,
}
}
g_free (addresses);
gimp_dashboard_log_printf (dashboard,
"\n"
"</address-map>\n");
}
static void
gimp_dashboard_log_write_global_address_map (GimpAsync *async,
GimpDashboard *dashboard)
{
GimpDashboardPrivate *priv = dashboard->priv;
gint n_addresses;
n_addresses = g_hash_table_size (priv->log_addresses);
if (n_addresses > 0)
{
guintptr *addresses;
GList *iter;
gint i;
addresses = g_new (guintptr, n_addresses);
for (iter = g_hash_table_get_keys (priv->log_addresses), i = 0;
iter;
iter = g_list_next (iter), i++)
{
addresses[i] = (guintptr) iter->data;
}
gimp_dashboard_log_write_address_map (dashboard,
addresses, n_addresses,
async);
g_free (addresses);
}
gimp_async_finish (async, NULL);
}
@@ -4306,12 +4349,27 @@ gimp_dashboard_log_start_recording (GimpDashboard *dashboard,
atoi (g_getenv ("GIMP_PERFORMANCE_LOG_BACKTRACE")) ? 1 : 0;
}
if (g_getenv ("GIMP_PERFORMANCE_LOG_PROGRESSIVE"))
{
priv->log_params.progressive =
atoi (g_getenv ("GIMP_PERFORMANCE_LOG_BACKTRACE")) ? 1 : 0;
}
priv->log_params.sample_frequency = CLAMP (priv->log_params.sample_frequency,
LOG_SAMPLE_FREQUENCY_MIN,
LOG_SAMPLE_FREQUENCY_MAX);
g_mutex_lock (&priv->mutex);
if (priv->log_params.progressive &&
g_file_query_exists (file, NULL) &&
! g_file_delete (file, NULL, error))
{
g_mutex_unlock (&priv->mutex);
return FALSE;
}
priv->log_output = G_OUTPUT_STREAM (g_file_replace (file,
NULL, FALSE, G_FILE_CREATE_NONE, NULL,
error));
@@ -4345,9 +4403,11 @@ gimp_dashboard_log_start_recording (GimpDashboard *dashboard,
"<params>\n"
"<sample-frequency>%d</sample-frequency>\n"
"<backtrace>%d</backtrace>\n"
"<progressive>%d</progressive>\n"
"</params>\n",
priv->log_params.sample_frequency,
has_backtrace);
has_backtrace,
priv->log_params.progressive);
gimp_dashboard_log_printf (dashboard,
"\n"
@@ -4555,12 +4615,13 @@ gimp_dashboard_log_stop_recording (GimpDashboard *dashboard,
"</samples>\n");
if (g_hash_table_size (priv->log_addresses) > 0)
if (! priv->log_params.progressive &&
g_hash_table_size (priv->log_addresses) > 0)
{
GimpAsync *async;
async = gimp_parallel_run_async_independent (
(GimpRunAsyncFunc) gimp_dashboard_log_write_address_map,
(GimpRunAsyncFunc) gimp_dashboard_log_write_global_address_map,
dashboard);
gimp_wait (priv->gimp, GIMP_WAITABLE (async),
@@ -4634,6 +4695,7 @@ gimp_dashboard_log_get_default_params (GimpDashboard *dashboard)
{
.sample_frequency = LOG_DEFAULT_SAMPLE_FREQUENCY,
.backtrace = LOG_DEFAULT_BACKTRACE,
.progressive = LOG_DEFAULT_PROGRESSIVE
};
g_return_val_if_fail (GIMP_IS_DASHBOARD (dashboard), NULL);

1
app/widgets/gimpdashboard.h
View File

@@ -29,6 +29,7 @@ struct _GimpDashboardLogParams
{
gint sample_frequency;
gboolean backtrace;
gboolean progressive;
};