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 static void clock_add(gpointer key, gpointer value, gpointer user_data)
  76 {
  77         struct clock_match *clock_match = user_data;
  78         GHashTable *tc_clocks = clock_match->clocks;
  79         struct ctf_clock *t_clock = value;
  80         GQuark v;
  81
  82         if (t_clock->absolute)
  83                 v = t_clock->name;
  84         else
  85                 v = t_clock->uuid;
  86         if (v) {
  87                 struct ctf_clock *tc_clock;
  88
  89                 tc_clock = g_hash_table_lookup(tc_clocks,
  90                                 (gpointer) (unsigned long) v);
  91                 if (!tc_clock) {
  92                         /*
  93                          * For now we only support CTF that has one
  94                          * single clock uuid or name (absolute ref) per
  95                          * trace.
  96                          */
  97                         if (g_hash_table_size(tc_clocks) > 0) {
  98                                 fprintf(stderr, "[error] Only CTF traces with a single clock description are supported by this babeltrace version.\n");
  99                         }
 100                         if (!clock_match->tc->offset_nr) {
 101                                 clock_match->tc->offset_first = clock_offset_ns(t_clock);
 102                                 clock_match->tc->delta_offset_first_sum = 0;
 103                                 clock_match->tc->offset_nr++;
 104                                 clock_match->tc->single_clock_offset_avg =
 105                                         clock_match->tc->offset_first;
 106                         }
 107                         g_hash_table_insert(tc_clocks,
 108                                 (gpointer) (unsigned long) v,
 109                                 value);
 110                 } else if (!t_clock->absolute) {
 111                         int64_t diff_ns;
 112
 113                         /*
 114                          * For non-absolute clocks, check that the
 115                          * offsets match. If not, warn the user that we
 116                          * do an arbitrary choice.
 117                          */
 118                         diff_ns = clock_offset_ns(tc_clock) - clock_offset_ns(t_clock);
 119                         printf_debug("Clock \"%s\" offset between traces has a delta of %" PRIu64 " ns.",
 120                                 g_quark_to_string(tc_clock->name),
 121                                 diff_ns < 0 ? -diff_ns : diff_ns);
 122                         if (diff_ns > 10000 || diff_ns < -10000) {
 123                                 fprintf(stderr, "[warning] Clock \"%s\" offset differs between traces (delta %" PRIu64 " ns). Using average.\n",
 124                                         g_quark_to_string(tc_clock->name),
 125                                         diff_ns < 0 ? -diff_ns : diff_ns);
 126                         }
 127                         /* Compute average */
 128                         clock_match->tc->delta_offset_first_sum +=
 129                                 clock_offset_ns(t_clock) - clock_match->tc->offset_first;
 130                         clock_match->tc->offset_nr++;
 131                         clock_match->tc->single_clock_offset_avg =
 132                                 clock_match->tc->offset_first
 133                                 + (clock_match->tc->delta_offset_first_sum / clock_match->tc->offset_nr);
 134                         /* Time need to use offset average */
 135                         clock_match->tc->clock_use_offset_avg = 1;
 136                 }
 137         }
 138 }
 139
 140 /*
 141  * Whenever we add a trace to the trace collection, check that we can
 142  * correlate this trace with at least one other clock in the trace and
 143  * convert the index from cycles to real time.
 144  */
 145 int bt_trace_collection_add(struct trace_collection *tc,
 146                         struct bt_trace_descriptor *trace)
 147 {
 148         if (!tc || !trace)
 149                 return -EINVAL;
 150
 151         if (!trace->clocks)
 152                 return 0;
 153
 154         if (tc->array->len > 1) {
 155                 struct clock_match clock_match = {
 156                         .clocks = tc->clocks,
 157                         .clock_match = NULL,
 158                         .tc = NULL,
 159                 };
 160
 161                 /*
 162                  * With two or more traces, we need correlation info
 163                  * avalable.
 164                  */
 165                 g_hash_table_foreach(trace->clocks,
 166                                 check_clock_match,
 167                                 &clock_match);
 168                 if (!clock_match.clock_match) {
 169                         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");
 170                         goto error;
 171                 }
 172         }
 173
 174         g_ptr_array_add(tc->array, trace);
 175         trace->collection = tc;
 176
 177         {
 178                 struct clock_match clock_match = {
 179                         .clocks = tc->clocks,
 180                         .clock_match = NULL,
 181                         .tc = tc,
 182                 };
 183
 184                 /*
 185                  * Add each clock from the trace clocks into the trace
 186                  * collection clocks.
 187                  */
 188                 g_hash_table_foreach(trace->clocks,
 189                                 clock_add,
 190                                 &clock_match);
 191         }
 192
 193         return 0;
 194 error:
 195         return -EPERM;
 196 }
 197
 198 int bt_trace_collection_remove(struct trace_collection *tc,
 199                             struct bt_trace_descriptor *td)
 200 {
 201         if (!tc || !td)
 202                 return -EINVAL;
 203
 204         if (g_ptr_array_remove(tc->array, td)) {
 205                 return 0;
 206         } else {
 207                 return -1;
 208         }
 209
 210 }
 211
 212 void bt_init_trace_collection(struct trace_collection *tc)
 213 {
 214         assert(tc);
 215         tc->array = g_ptr_array_new();
 216         tc->clocks = g_hash_table_new(g_direct_hash, g_direct_equal);
 217         tc->single_clock_offset_avg = 0;
 218         tc->offset_first = 0;
 219         tc->delta_offset_first_sum = 0;
 220         tc->offset_nr = 0;
 221 }
 222
 223 /*
 224  * bt_finalize_trace_collection() closes the opened traces for read
 225  * and free the memory allocated for trace collection
 226  */
 227 void bt_finalize_trace_collection(struct trace_collection *tc)
 228 {
 229         assert(tc);
 230         g_ptr_array_free(tc->array, TRUE);
 231         g_hash_table_destroy(tc->clocks);
 232 }