lib/trace-collection.c

   1 /*
   2  * trace-collection.c
   3  *
   4  * Babeltrace Library
   5  *
   6  * Copyright 2012 EfficiOS Inc. and Linux Foundation
   7  *
   8  * Author: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   9  *
  10  * Permission is hereby granted, free of charge, to any person obtaining a copy
  11  * of this software and associated documentation files (the "Software"), to deal
  12  * in the Software without restriction, including without limitation the rights
  13  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  14  * copies of the Software, and to permit persons to whom the Software is
  15  * furnished to do so, subject to the following conditions:
  16  *
  17  * The above copyright notice and this permission notice shall be included in
  18  * all copies or substantial portions of the Software.
  19  *
  20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  21  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  23  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  24  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  25  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  26  * SOFTWARE.
  27  */
  28 #include <babeltrace/babeltrace.h>
  29 #include <babeltrace/format.h>
  30 #include <babeltrace/context.h>
  31 #include <babeltrace/ctf/types.h>
  32 #include <babeltrace/ctf-text/types.h>
  33 #include <babeltrace/trace-collection.h>
  34 #include <babeltrace/ctf-ir/metadata.h> /* for clocks */
  35 #include <babeltrace/clock-internal.h>
  36
  37 #include <inttypes.h>
  38
  39 struct clock_match {
  40         GHashTable *clocks;
  41         struct ctf_clock *clock_match;
  42         struct trace_collection *tc;
  43 };
  44
  45 static void check_clock_match(gpointer key, gpointer value, gpointer user_data)
  46 {
  47         struct clock_match *match = user_data;
  48         struct ctf_clock *clock_a = value, *clock_b;
  49
  50         if (clock_a->absolute) {
  51                 /*
  52                  * Absolute time references, such as NTP, are looked up
  53                  * by clock name.
  54                  */
  55                 clock_b = g_hash_table_lookup(match->clocks,
  56                         (gpointer) (unsigned long) clock_a->name);
  57                 if (clock_b) {
  58                         match->clock_match = clock_b;
  59                         return;
  60                 }
  61         } else if (clock_a->uuid != 0) {
  62                 /*
  63                  * Lookup the the trace clocks into the collection
  64                  * clocks.
  65                  */
  66                 clock_b = g_hash_table_lookup(match->clocks,
  67                         (gpointer) (unsigned long) clock_a->uuid);
  68                 if (clock_b) {
  69                         match->clock_match = clock_b;
  70                         return;
  71                 }
  72         }
  73 }
  74
  75 /*
  76  * Note: if using a frequency different from 1GHz for clock->offset, it
  77  * is recommended to express the seconds in offset_s, otherwise there
  78  * will be a loss of precision caused by the limited size of the double
  79  * mantissa.
  80  */
  81 static
  82 uint64_t clock_offset_ns(struct ctf_clock *clock)
  83 {
  84         return clock->offset_s * 1000000000ULL
  85                         + clock_cycles_to_ns(clock, clock->offset);
  86 }
  87
  88 static void clock_add(gpointer key, gpointer value, gpointer user_data)
  89 {
  90         struct clock_match *clock_match = user_data;
  91         GHashTable *tc_clocks = clock_match->clocks;
  92         struct ctf_clock *t_clock = value;
  93         GQuark v;
  94
  95         if (t_clock->absolute)
  96                 v = t_clock->name;
  97         else
  98                 v = t_clock->uuid;
  99         if (v) {
 100                 struct ctf_clock *tc_clock;
 101
 102                 tc_clock = g_hash_table_lookup(tc_clocks,
 103                                 (gpointer) (unsigned long) v);
 104                 if (!tc_clock) {
 105                         /*
 106                          * For now we only support CTF that has one
 107                          * single clock uuid or name (absolute ref) per
 108                          * trace.
 109                          */
 110                         if (g_hash_table_size(tc_clocks) > 0) {
 111                                 fprintf(stderr, "[error] Only CTF traces with a single clock description are supported by this babeltrace version.\n");
 112                         }
 113                         if (!clock_match->tc->offset_nr) {
 114                                 clock_match->tc->offset_first = clock_offset_ns(t_clock);
 115                                 clock_match->tc->delta_offset_first_sum = 0;
 116                                 clock_match->tc->offset_nr++;
 117                                 clock_match->tc->single_clock_offset_avg =
 118                                         clock_match->tc->offset_first;
 119                         }
 120                         g_hash_table_insert(tc_clocks,
 121                                 (gpointer) (unsigned long) v,
 122                                 value);
 123                 } else if (!t_clock->absolute) {
 124                         int64_t diff_ns;
 125
 126                         /*
 127                          * For non-absolute clocks, check that the
 128                          * offsets match. If not, warn the user that we
 129                          * do an arbitrary choice.
 130                          */
 131                         diff_ns = clock_offset_ns(tc_clock) - clock_offset_ns(t_clock);
 132                         printf_debug("Clock \"%s\" offset between traces has a delta of %" PRIu64 " ns.",
 133                                 g_quark_to_string(tc_clock->name),
 134                                 diff_ns < 0 ? -diff_ns : diff_ns);
 135                         if (diff_ns > 10000 || diff_ns < -10000) {
 136                                 fprintf(stderr, "[warning] Clock \"%s\" offset differs between traces (delta %" PRIu64 " ns). Using average.\n",
 137                                         g_quark_to_string(tc_clock->name),
 138                                         diff_ns < 0 ? -diff_ns : diff_ns);
 139                         }
 140                         /* Compute average */
 141                         clock_match->tc->delta_offset_first_sum +=
 142                                 clock_offset_ns(t_clock) - clock_match->tc->offset_first;
 143                         clock_match->tc->offset_nr++;
 144                         clock_match->tc->single_clock_offset_avg =
 145                                 clock_match->tc->offset_first
 146                                 + (clock_match->tc->delta_offset_first_sum / clock_match->tc->offset_nr);
 147                         /* Time need to use offset average */
 148                         clock_match->tc->clock_use_offset_avg = 1;
 149                 }
 150         }
 151 }
 152
 153 /*
 154  * Whenever we add a trace to the trace collection, check that we can
 155  * correlate this trace with at least one other clock in the trace and
 156  * convert the index from cycles to real time.
 157  */
 158 int trace_collection_add(struct trace_collection *tc,
 159                                 struct trace_descriptor *td)
 160 {
 161         struct ctf_trace *trace;
 162
 163         if (!tc || !td)
 164                 return -EINVAL;
 165
 166         trace = container_of(td, struct ctf_trace, parent);
 167         g_ptr_array_add(tc->array, td);
 168         trace->collection = tc;
 169
 170         if (tc->array->len > 1) {
 171                 struct clock_match clock_match = {
 172                         .clocks = tc->clocks,
 173                         .clock_match = NULL,
 174                         .tc = NULL,
 175                 };
 176
 177                 /*
 178                  * With two or more traces, we need correlation info
 179                  * avalable.
 180                  */
 181                 g_hash_table_foreach(trace->clocks,
 182                                 check_clock_match,
 183                                 &clock_match);
 184                 if (!clock_match.clock_match) {
 185                         fprintf(stderr, "[error] No clocks can be correlated and multiple traces are added to the collection. If you are certain those traces can be correlated, try using \"--clock-force-correlate\".\n");
 186                         goto error;
 187                 }
 188         }
 189
 190         {
 191                 struct clock_match clock_match = {
 192                         .clocks = tc->clocks,
 193                         .clock_match = NULL,
 194                         .tc = tc,
 195                 };
 196
 197                 /*
 198                  * Add each clock from the trace clocks into the trace
 199                  * collection clocks.
 200                  */
 201                 g_hash_table_foreach(trace->clocks,
 202                                 clock_add,
 203                                 &clock_match);
 204         }
 205
 206         return 0;
 207 error:
 208         return -EPERM;
 209 }
 210
 211 int trace_collection_remove(struct trace_collection *tc,
 212                             struct trace_descriptor *td)
 213 {
 214         if (!tc || !td)
 215                 return -EINVAL;
 216
 217         if (g_ptr_array_remove(tc->array, td)) {
 218                 return 0;
 219         } else {
 220                 return -1;
 221         }
 222
 223 }
 224
 225 void init_trace_collection(struct trace_collection *tc)
 226 {
 227         assert(tc);
 228         tc->array = g_ptr_array_new();
 229         tc->clocks = g_hash_table_new(g_direct_hash, g_direct_equal);
 230         tc->single_clock_offset_avg = 0;
 231         tc->offset_first = 0;
 232         tc->delta_offset_first_sum = 0;
 233         tc->offset_nr = 0;
 234 }
 235
 236 /*
 237  * finalize_trace_collection() closes the opened traces for read
 238  * and free the memory allocated for trace collection
 239  */
 240 void finalize_trace_collection(struct trace_collection *tc)
 241 {
 242         assert(tc);
 243         g_ptr_array_free(tc->array, TRUE);
 244         g_hash_table_destroy(tc->clocks);
 245 }