plugins/tracers/gstrusage.c

   1 /* GStreamer
   2  * Copyright (C) 2013 Stefan Sauer <ensonic@users.sf.net>
   3  *
   4  * gstrusage.c: tracing module that logs resource usage stats
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Library General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Library General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Library General Public
  17  * License along with this library; if not, write to the
  18  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  19  * Boston, MA 02110-1301, USA.
  20  */
  21 /**
  22  * SECTION:gstrusage
  23  * @short_description: log resource usage stats
  24  *
  25  * A tracing module that take rusage() snapshots and logs them.
  26  */
  27
  28 #ifdef HAVE_CONFIG_H
  29 #  include "config.h"
  30 #endif
  31
  32 #include <unistd.h>
  33 #include "gstrusage.h"
  34
  35 #ifdef HAVE_SYS_RESOURCE_H
  36 #ifndef __USE_GNU
  37 # define __USE_GNU              /* RUSAGE_THREAD */
  38 #endif
  39 #include <sys/resource.h>
  40 #endif
  41
  42 GST_DEBUG_CATEGORY_STATIC (gst_rusage_debug);
  43 #define GST_CAT_DEFAULT gst_rusage_debug
  44
  45 G_LOCK_DEFINE (_proc);
  46
  47 #define _do_init \
  48     GST_DEBUG_CATEGORY_INIT (gst_rusage_debug, "rusage", 0, "rusage tracer");
  49 #define gst_rusage_tracer_parent_class parent_class
  50 G_DEFINE_TYPE_WITH_CODE (GstRUsageTracer, gst_rusage_tracer, GST_TYPE_TRACER,
  51     _do_init);
  52
  53 /* remember x measurements per self->window */
  54 #define WINDOW_SUBDIV 100
  55
  56 /* number of cpus to scale cpu-usage in threads */
  57 static glong num_cpus = 1;
  58
  59 static GstTracerRecord *tr_proc, *tr_thread;
  60
  61 typedef struct
  62 {
  63   /* time spend in this thread */
  64   GstClockTime tthread;
  65   GstTraceValues *tvs_thread;
  66 } GstThreadStats;
  67
  68 /* data helper */
  69
  70 static void
  71 free_trace_value (gpointer data)
  72 {
  73   g_slice_free (GstTraceValue, data);
  74 }
  75
  76 static GstTraceValues *
  77 make_trace_values (GstClockTime window)
  78 {
  79   GstTraceValues *self = g_slice_new0 (GstTraceValues);
  80   self->window = window;
  81   g_queue_init (&self->values);
  82   return self;
  83 }
  84
  85 static void
  86 free_trace_values (GstTraceValues * self)
  87 {
  88   g_queue_free_full (&self->values, free_trace_value);
  89   g_slice_free (GstTraceValues, self);
  90 }
  91
  92 static gboolean
  93 update_trace_value (GstTraceValues * self, GstClockTime nts,
  94     GstClockTime nval, GstClockTime * dts, GstClockTime * dval)
  95 {
  96   GstTraceValue *lv;
  97   GstClockTimeDiff dt;
  98   GstClockTime window = self->window;
  99   GQueue *q = &self->values;
 100   GList *node = q->tail;
 101   gboolean ret = FALSE;
 102
 103
 104   /* search from the tail of the queue for a good GstTraceValue */
 105   while (node) {
 106     lv = node->data;
 107     dt = GST_CLOCK_DIFF (lv->ts, nts);
 108     if (dt < window) {
 109       break;
 110     } else {
 111       node = g_list_previous (node);
 112     }
 113   }
 114
 115   if (node) {
 116     /* calculate the windowed value */
 117     *dts = dt;
 118     *dval = GST_CLOCK_DIFF (lv->val, nval);
 119
 120     /* drop all older measurements */
 121     while (q->tail != node) {
 122       free_trace_value (g_queue_pop_tail (q));
 123     }
 124     ret = TRUE;
 125   } else {
 126     *dts = nts;
 127     *dval = nval;
 128   }
 129
 130   /* don't push too many data items */
 131   lv = q->head ? q->head->data : NULL;
 132   if (!lv || (GST_CLOCK_DIFF (lv->ts, nts) > (window / WINDOW_SUBDIV))) {
 133     /* push the new measurement */
 134     lv = g_slice_new0 (GstTraceValue);
 135     lv->ts = nts;
 136     lv->val = nval;
 137     g_queue_push_head (q, lv);
 138   }
 139   return ret;
 140 }
 141
 142
 143 static void
 144 free_thread_stats (gpointer data)
 145 {
 146   free_trace_values (((GstThreadStats *) data)->tvs_thread);
 147   g_slice_free (GstThreadStats, data);
 148 }
 149
 150 static void
 151 do_stats (GstTracer * obj, guint64 ts)
 152 {
 153   GstRUsageTracer *self = GST_RUSAGE_TRACER_CAST (obj);
 154   GstThreadStats *stats;
 155   gpointer thread_id = g_thread_self ();
 156   guint avg_cpuload, cur_cpuload;
 157   struct rusage ru;
 158   GstClockTime tproc = G_GUINT64_CONSTANT (0);
 159   GstClockTime tthread = G_GUINT64_CONSTANT (0);
 160   GstClockTime dts, dtproc;
 161
 162 #ifdef HAVE_CLOCK_GETTIME
 163   {
 164     struct timespec now;
 165
 166     if (!clock_gettime (CLOCK_PROCESS_CPUTIME_ID, &now)) {
 167       tproc = GST_TIMESPEC_TO_TIME (now);
 168     } else {
 169       GST_WARNING_OBJECT (obj,
 170           "clock_gettime (CLOCK_PROCESS_CPUTIME_ID,...) failed: %s",
 171           g_strerror (errno));
 172       getrusage (RUSAGE_SELF, &ru);
 173       tproc =
 174           GST_TIMEVAL_TO_TIME (ru.ru_utime) + GST_TIMEVAL_TO_TIME (ru.ru_stime);
 175     }
 176
 177     /* cpu time per thread */
 178     if (!clock_gettime (CLOCK_THREAD_CPUTIME_ID, &now)) {
 179       tthread = GST_TIMESPEC_TO_TIME (now);
 180     } else {
 181       GST_WARNING_OBJECT (obj,
 182           "clock_gettime (CLOCK_THREAD_CPUTIME_ID,...) failed: %s",
 183           g_strerror (errno));
 184 #ifdef RUSAGE_THREAD
 185       getrusage (RUSAGE_THREAD, &ru);
 186       tthread =
 187           GST_TIMEVAL_TO_TIME (ru.ru_utime) + GST_TIMEVAL_TO_TIME (ru.ru_stime);
 188 #endif
 189     }
 190   }
 191 #else
 192   getrusage (RUSAGE_SELF, &ru);
 193   tproc = GST_TIMEVAL_TO_TIME (ru.ru_utime) + GST_TIMEVAL_TO_TIME (ru.ru_stime);
 194 #ifdef RUSAGE_THREAD
 195   getrusage (RUSAGE_THREAD, &ru);
 196   tthread =
 197       GST_TIMEVAL_TO_TIME (ru.ru_utime) + GST_TIMEVAL_TO_TIME (ru.ru_stime);
 198 #endif
 199 #endif
 200   /* get stats record for current thread */
 201   if (!(stats = g_hash_table_lookup (self->threads, thread_id))) {
 202     stats = g_slice_new0 (GstThreadStats);
 203     stats->tvs_thread = make_trace_values (GST_SECOND);
 204     g_hash_table_insert (self->threads, thread_id, stats);
 205   }
 206   stats->tthread = tthread;
 207
 208   /* Calibrate ts for the process and main thread. For tthread[main] and tproc
 209    * the time is larger than ts, as our base-ts is taken after the process has
 210    * started.
 211    */
 212   if (G_UNLIKELY (thread_id == self->main_thread_id)) {
 213     self->main_thread_id = NULL;
 214     /* when the registry gets updated, the tproc is less than the debug time ? */
 215     /* TODO(ensonic): we still see cases where tproc overtakes ts, especially
 216      * when with sync=false, can this be due to multiple cores in use? */
 217     if (tproc > ts) {
 218       self->tproc_base = tproc - ts;
 219       GST_DEBUG ("rusage: calibrating by %" G_GUINT64_FORMAT ", thread: %"
 220           G_GUINT64_FORMAT ", proc: %" G_GUINT64_FORMAT,
 221           self->tproc_base, stats->tthread, tproc);
 222       stats->tthread -= self->tproc_base;
 223     }
 224   }
 225   /* we always need to correct proc time */
 226   tproc -= self->tproc_base;
 227
 228   /* FIXME: how can we take cpu-frequency scaling into account?
 229    * - looking at /sys/devices/system/cpu/cpu0/cpufreq/
 230    *   scale_factor=scaling_max_freq/scaling_cur_freq
 231    * - as a workaround we can switch it via /sys/devices/system/cpu/cpu0/cpufreq/scaling_governor
 232    *   cpufreq-selector -g performance
 233    *   cpufreq-selector -g ondemand
 234    */
 235   /* *INDENT-OFF* */
 236   avg_cpuload = (guint) gst_util_uint64_scale (stats->tthread,
 237       G_GINT64_CONSTANT (1000), ts);
 238   update_trace_value (stats->tvs_thread, ts, stats->tthread, &dts, &dtproc);
 239   cur_cpuload = (guint) gst_util_uint64_scale (dtproc,
 240       G_GINT64_CONSTANT (1000), dts);
 241   gst_tracer_record_log (tr_thread, (guint64)thread_id, ts,
 242       MIN (avg_cpuload, 1000), MIN (cur_cpuload, 1000), stats->tthread);
 243
 244   avg_cpuload = (guint) gst_util_uint64_scale (tproc / num_cpus,
 245       G_GINT64_CONSTANT (1000), ts);
 246   G_LOCK (_proc);
 247   update_trace_value (self->tvs_proc, ts, tproc, &dts, &dtproc);
 248   G_UNLOCK (_proc);
 249   cur_cpuload = (guint) gst_util_uint64_scale (dtproc / num_cpus,
 250       G_GINT64_CONSTANT (1000), dts);
 251   gst_tracer_record_log (tr_proc, ts, MIN (avg_cpuload, 1000),
 252       MIN (cur_cpuload, 1000), tproc);
 253   /* *INDENT-ON* */
 254 }
 255
 256 /* tracer class */
 257
 258 static void
 259 gst_rusage_tracer_finalize (GObject * obj)
 260 {
 261   GstRUsageTracer *self = GST_RUSAGE_TRACER (obj);
 262
 263   g_hash_table_destroy (self->threads);
 264   free_trace_values (self->tvs_proc);
 265
 266   G_OBJECT_CLASS (parent_class)->finalize (obj);
 267 }
 268
 269 static void
 270 gst_rusage_tracer_class_init (GstRUsageTracerClass * klass)
 271 {
 272   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 273
 274   gobject_class->finalize = gst_rusage_tracer_finalize;
 275
 276   if ((num_cpus = sysconf (_SC_NPROCESSORS_ONLN)) == -1) {
 277     GST_WARNING ("failed to get number of cpus online");
 278     if ((num_cpus = sysconf (_SC_NPROCESSORS_CONF)) == -1) {
 279       GST_WARNING ("failed to get number of cpus, assuming 1");
 280       num_cpus = 1;
 281     }
 282   }
 283   GST_DEBUG ("rusage: num_cpus=%ld", num_cpus);
 284
 285   /* announce trace formats */
 286   /* *INDENT-OFF* */
 287   tr_thread = gst_tracer_record_new (gst_structure_new ("thread-rusage.class",
 288       "thread-id", GST_TYPE_STRUCTURE, gst_structure_new ("scope",
 289           "type", G_TYPE_GTYPE, G_TYPE_UINT64,
 290           "related-to", GST_TYPE_TRACER_VALUE_SCOPE, GST_TRACER_VALUE_SCOPE_THREAD,
 291           NULL),
 292       "ts", GST_TYPE_STRUCTURE, gst_structure_new ("value",
 293           "type", G_TYPE_GTYPE, G_TYPE_UINT64,
 294           "description", G_TYPE_STRING, "event ts",
 295           NULL),
 296       "average-cpuload", GST_TYPE_STRUCTURE, gst_structure_new ("value",
 297           "type", G_TYPE_GTYPE, G_TYPE_UINT,
 298           "description", G_TYPE_STRING, "average cpu usage per thread in ‰",
 299           "flags", G_TYPE_STRING, "aggregated",  /* TODO: use gflags */
 300           "min", G_TYPE_UINT, 0,
 301           "max", G_TYPE_UINT, 1000,
 302           NULL),
 303       "current-cpuload", GST_TYPE_STRUCTURE, gst_structure_new ("value",
 304           "type", G_TYPE_GTYPE, G_TYPE_UINT,
 305           "description", G_TYPE_STRING, "current cpu usage per thread in ‰",
 306           "flags", G_TYPE_STRING, "windowed",  /* TODO: use gflags */
 307           "min", G_TYPE_UINT, 0,
 308           "max", G_TYPE_UINT, 1000,
 309           NULL),
 310       "time", GST_TYPE_STRUCTURE, gst_structure_new ("value",
 311           "type", G_TYPE_GTYPE, G_TYPE_UINT64,
 312           "description", G_TYPE_STRING, "time spent in thread in ns",
 313           "flags", G_TYPE_STRING, "aggregated",  /* TODO: use gflags */
 314           "min", G_TYPE_UINT64, G_GUINT64_CONSTANT (0),
 315           "max", G_TYPE_UINT64, G_MAXUINT64,
 316           NULL),
 317       NULL));
 318   tr_proc = gst_tracer_record_new (gst_structure_new ("proc-rusage.class",
 319       "thread-id", GST_TYPE_STRUCTURE, gst_structure_new ("scope",
 320           "type", G_TYPE_GTYPE, G_TYPE_UINT64,
 321           "related-to", GST_TYPE_TRACER_VALUE_SCOPE, GST_TRACER_VALUE_SCOPE_PROCESS,
 322           NULL),
 323       "ts", GST_TYPE_STRUCTURE, gst_structure_new ("value",
 324           "type", G_TYPE_GTYPE, G_TYPE_UINT64,
 325           "description", G_TYPE_STRING, "event ts",
 326           NULL),
 327       "average-cpuload", GST_TYPE_STRUCTURE, gst_structure_new ("value",
 328           "type", G_TYPE_GTYPE, G_TYPE_UINT,
 329           "description", G_TYPE_STRING, "average cpu usage per process in ‰",
 330           "flags", G_TYPE_STRING, "aggregated",  /* TODO: use gflags */
 331           "min", G_TYPE_UINT, 0,
 332           "max", G_TYPE_UINT, 1000,
 333           NULL),
 334       "current-cpuload", GST_TYPE_STRUCTURE, gst_structure_new ("value",
 335           "type", G_TYPE_GTYPE, G_TYPE_UINT,
 336           "description", G_TYPE_STRING, "current cpu usage per process in ‰",
 337           "flags", G_TYPE_STRING, "windowed",  /* TODO: use gflags */
 338           "min", G_TYPE_UINT, 0,
 339           "max", G_TYPE_UINT, 1000,
 340           NULL),
 341       "time", GST_TYPE_STRUCTURE, gst_structure_new ("value",
 342           "type", G_TYPE_GTYPE, G_TYPE_UINT64,
 343           "description", G_TYPE_STRING, "time spent in process in ns",
 344           "flags", G_TYPE_STRING, "aggregated",  /* TODO: use gflags */
 345           "min", G_TYPE_UINT64, G_GUINT64_CONSTANT (0),
 346           "max", G_TYPE_UINT64, G_MAXUINT64,
 347           NULL),
 348       NULL));
 349   /* *INDENT-ON* */
 350 }
 351
 352 static void
 353 gst_rusage_tracer_init (GstRUsageTracer * self)
 354 {
 355   GstTracer *tracer = GST_TRACER (self);
 356
 357   gst_tracing_register_hook (tracer, NULL, G_CALLBACK (do_stats));
 358
 359   self->threads = g_hash_table_new_full (NULL, NULL, NULL, free_thread_stats);
 360   self->tvs_proc = make_trace_values (GST_SECOND);
 361   self->main_thread_id = g_thread_self ();
 362
 363   GST_DEBUG ("rusage: main thread=%p", self->main_thread_id);
 364 }