Commit | Line | Data |
---|---|---|
6cba487f MD |
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. | |
c462e188 MD |
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. | |
6cba487f MD |
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 */ | |
75d9ab4b | 35 | #include <babeltrace/clock-internal.h> |
6cba487f MD |
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 | ||
50052405 | 50 | if (clock_a->absolute) { |
6cba487f | 51 | /* |
50052405 MD |
52 | * Absolute time references, such as NTP, are looked up |
53 | * by clock name. | |
6cba487f MD |
54 | */ |
55 | clock_b = g_hash_table_lookup(match->clocks, | |
5b44aff2 | 56 | GUINT_TO_POINTER(clock_a->name)); |
6cba487f MD |
57 | if (clock_b) { |
58 | match->clock_match = clock_b; | |
59 | return; | |
60 | } | |
50052405 | 61 | } else if (clock_a->uuid != 0) { |
6cba487f | 62 | /* |
50052405 MD |
63 | * Lookup the the trace clocks into the collection |
64 | * clocks. | |
6cba487f MD |
65 | */ |
66 | clock_b = g_hash_table_lookup(match->clocks, | |
5b44aff2 | 67 | GUINT_TO_POINTER(clock_a->uuid)); |
6cba487f MD |
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, | |
5b44aff2 | 90 | GUINT_TO_POINTER(v)); |
6cba487f MD |
91 | if (!tc_clock) { |
92 | /* | |
50052405 MD |
93 | * For now we only support CTF that has one |
94 | * single clock uuid or name (absolute ref) per | |
95 | * trace. | |
6cba487f MD |
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) { | |
75d9ab4b | 101 | clock_match->tc->offset_first = clock_offset_ns(t_clock); |
6cba487f MD |
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, | |
5b44aff2 | 108 | GUINT_TO_POINTER(v), |
6cba487f | 109 | value); |
50052405 | 110 | } else if (!t_clock->absolute) { |
6cba487f MD |
111 | int64_t diff_ns; |
112 | ||
113 | /* | |
50052405 MD |
114 | * For non-absolute clocks, check that the |
115 | * offsets match. If not, warn the user that we | |
116 | * do an arbitrary choice. | |
6cba487f | 117 | */ |
75d9ab4b | 118 | diff_ns = clock_offset_ns(tc_clock) - clock_offset_ns(t_clock); |
6cba487f MD |
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); | |
75d9ab4b | 122 | if (diff_ns > 10000 || diff_ns < -10000) { |
6cba487f MD |
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 += | |
75d9ab4b | 129 | clock_offset_ns(t_clock) - clock_match->tc->offset_first; |
6cba487f MD |
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); | |
50052405 MD |
134 | /* Time need to use offset average */ |
135 | clock_match->tc->clock_use_offset_avg = 1; | |
6cba487f MD |
136 | } |
137 | } | |
138 | } | |
139 | ||
140 | /* | |
141 | * Whenever we add a trace to the trace collection, check that we can | |
03798a93 JD |
142 | * correlate this trace with at least one other clock in the trace and |
143 | * convert the index from cycles to real time. | |
6cba487f | 144 | */ |
2552c374 | 145 | int bt_trace_collection_add(struct trace_collection *tc, |
7ec78969 | 146 | struct bt_trace_descriptor *trace) |
6cba487f | 147 | { |
7ec78969 | 148 | if (!tc || !trace) |
7f89ddce MD |
149 | return -EINVAL; |
150 | ||
34d99418 JD |
151 | if (!trace->clocks) |
152 | return 0; | |
153 | ||
6cba487f MD |
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) { | |
17d37c4d | 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"); |
6cba487f MD |
170 | goto error; |
171 | } | |
172 | } | |
173 | ||
7ec78969 MD |
174 | g_ptr_array_add(tc->array, trace); |
175 | trace->collection = tc; | |
391a4294 | 176 | |
6cba487f MD |
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 | } | |
03798a93 | 192 | |
6cba487f MD |
193 | return 0; |
194 | error: | |
195 | return -EPERM; | |
196 | } | |
197 | ||
2552c374 | 198 | int bt_trace_collection_remove(struct trace_collection *tc, |
1b8455b7 | 199 | struct bt_trace_descriptor *td) |
6cba487f | 200 | { |
7f89ddce MD |
201 | if (!tc || !td) |
202 | return -EINVAL; | |
203 | ||
6cba487f MD |
204 | if (g_ptr_array_remove(tc->array, td)) { |
205 | return 0; | |
206 | } else { | |
207 | return -1; | |
208 | } | |
209 | ||
210 | } | |
211 | ||
2552c374 | 212 | void bt_init_trace_collection(struct trace_collection *tc) |
6cba487f | 213 | { |
7f89ddce | 214 | assert(tc); |
6cba487f MD |
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 | /* | |
2552c374 | 224 | * bt_finalize_trace_collection() closes the opened traces for read |
6cba487f MD |
225 | * and free the memory allocated for trace collection |
226 | */ | |
2552c374 | 227 | void bt_finalize_trace_collection(struct trace_collection *tc) |
6cba487f | 228 | { |
7f89ddce | 229 | assert(tc); |
6cba487f MD |
230 | g_ptr_array_free(tc->array, TRUE); |
231 | g_hash_table_destroy(tc->clocks); | |
232 | } |