Jiri Olsa | 5f86b80 | 2014-08-01 13:02:58 -0300 | [diff] [blame] | 1 | #include <linux/list.h> |
Jiri Olsa | cee3ab9 | 2014-07-11 14:49:54 +0200 | [diff] [blame] | 2 | #include <linux/compiler.h> |
Alexander Yarygin | 54bf53b | 2014-10-03 18:40:11 +0400 | [diff] [blame] | 3 | #include <linux/string.h> |
Jiri Olsa | 5f86b80 | 2014-08-01 13:02:58 -0300 | [diff] [blame] | 4 | #include "ordered-events.h" |
| 5 | #include "evlist.h" |
| 6 | #include "session.h" |
| 7 | #include "asm/bug.h" |
| 8 | #include "debug.h" |
| 9 | |
Jiri Olsa | cee3ab9 | 2014-07-11 14:49:54 +0200 | [diff] [blame] | 10 | #define pr_N(n, fmt, ...) \ |
| 11 | eprintf(n, debug_ordered_events, fmt, ##__VA_ARGS__) |
| 12 | |
| 13 | #define pr(fmt, ...) pr_N(1, pr_fmt(fmt), ##__VA_ARGS__) |
| 14 | |
Jiri Olsa | 5f86b80 | 2014-08-01 13:02:58 -0300 | [diff] [blame] | 15 | static void queue_event(struct ordered_events *oe, struct ordered_event *new) |
| 16 | { |
| 17 | struct ordered_event *last = oe->last; |
| 18 | u64 timestamp = new->timestamp; |
| 19 | struct list_head *p; |
| 20 | |
| 21 | ++oe->nr_events; |
| 22 | oe->last = new; |
| 23 | |
Jiri Olsa | cee3ab9 | 2014-07-11 14:49:54 +0200 | [diff] [blame] | 24 | pr_oe_time2(timestamp, "queue_event nr_events %u\n", oe->nr_events); |
| 25 | |
Jiri Olsa | 5f86b80 | 2014-08-01 13:02:58 -0300 | [diff] [blame] | 26 | if (!last) { |
| 27 | list_add(&new->list, &oe->events); |
| 28 | oe->max_timestamp = timestamp; |
| 29 | return; |
| 30 | } |
| 31 | |
| 32 | /* |
| 33 | * last event might point to some random place in the list as it's |
| 34 | * the last queued event. We expect that the new event is close to |
| 35 | * this. |
| 36 | */ |
| 37 | if (last->timestamp <= timestamp) { |
| 38 | while (last->timestamp <= timestamp) { |
| 39 | p = last->list.next; |
| 40 | if (p == &oe->events) { |
| 41 | list_add_tail(&new->list, &oe->events); |
| 42 | oe->max_timestamp = timestamp; |
| 43 | return; |
| 44 | } |
| 45 | last = list_entry(p, struct ordered_event, list); |
| 46 | } |
| 47 | list_add_tail(&new->list, &last->list); |
| 48 | } else { |
| 49 | while (last->timestamp > timestamp) { |
| 50 | p = last->list.prev; |
| 51 | if (p == &oe->events) { |
| 52 | list_add(&new->list, &oe->events); |
| 53 | return; |
| 54 | } |
| 55 | last = list_entry(p, struct ordered_event, list); |
| 56 | } |
| 57 | list_add(&new->list, &last->list); |
| 58 | } |
| 59 | } |
| 60 | |
Alexander Yarygin | 54bf53b | 2014-10-03 18:40:11 +0400 | [diff] [blame] | 61 | static union perf_event *__dup_event(struct ordered_events *oe, |
| 62 | union perf_event *event) |
| 63 | { |
| 64 | union perf_event *new_event = NULL; |
| 65 | |
| 66 | if (oe->cur_alloc_size < oe->max_alloc_size) { |
| 67 | new_event = memdup(event, event->header.size); |
| 68 | if (new_event) |
| 69 | oe->cur_alloc_size += event->header.size; |
| 70 | } |
| 71 | |
| 72 | return new_event; |
| 73 | } |
| 74 | |
| 75 | static union perf_event *dup_event(struct ordered_events *oe, |
| 76 | union perf_event *event) |
| 77 | { |
| 78 | return oe->copy_on_queue ? __dup_event(oe, event) : event; |
| 79 | } |
| 80 | |
| 81 | static void free_dup_event(struct ordered_events *oe, union perf_event *event) |
| 82 | { |
| 83 | if (oe->copy_on_queue) { |
| 84 | oe->cur_alloc_size -= event->header.size; |
| 85 | free(event); |
| 86 | } |
| 87 | } |
| 88 | |
Jiri Olsa | 5f86b80 | 2014-08-01 13:02:58 -0300 | [diff] [blame] | 89 | #define MAX_SAMPLE_BUFFER (64 * 1024 / sizeof(struct ordered_event)) |
Alexander Yarygin | 54bf53b | 2014-10-03 18:40:11 +0400 | [diff] [blame] | 90 | static struct ordered_event *alloc_event(struct ordered_events *oe, |
| 91 | union perf_event *event) |
Jiri Olsa | 5f86b80 | 2014-08-01 13:02:58 -0300 | [diff] [blame] | 92 | { |
| 93 | struct list_head *cache = &oe->cache; |
| 94 | struct ordered_event *new = NULL; |
Alexander Yarygin | 54bf53b | 2014-10-03 18:40:11 +0400 | [diff] [blame] | 95 | union perf_event *new_event; |
| 96 | |
| 97 | new_event = dup_event(oe, event); |
| 98 | if (!new_event) |
| 99 | return NULL; |
Jiri Olsa | 5f86b80 | 2014-08-01 13:02:58 -0300 | [diff] [blame] | 100 | |
| 101 | if (!list_empty(cache)) { |
| 102 | new = list_entry(cache->next, struct ordered_event, list); |
| 103 | list_del(&new->list); |
| 104 | } else if (oe->buffer) { |
| 105 | new = oe->buffer + oe->buffer_idx; |
| 106 | if (++oe->buffer_idx == MAX_SAMPLE_BUFFER) |
| 107 | oe->buffer = NULL; |
| 108 | } else if (oe->cur_alloc_size < oe->max_alloc_size) { |
| 109 | size_t size = MAX_SAMPLE_BUFFER * sizeof(*new); |
| 110 | |
| 111 | oe->buffer = malloc(size); |
Alexander Yarygin | 54bf53b | 2014-10-03 18:40:11 +0400 | [diff] [blame] | 112 | if (!oe->buffer) { |
| 113 | free_dup_event(oe, new_event); |
Jiri Olsa | 5f86b80 | 2014-08-01 13:02:58 -0300 | [diff] [blame] | 114 | return NULL; |
Alexander Yarygin | 54bf53b | 2014-10-03 18:40:11 +0400 | [diff] [blame] | 115 | } |
Jiri Olsa | 5f86b80 | 2014-08-01 13:02:58 -0300 | [diff] [blame] | 116 | |
Jiri Olsa | cee3ab9 | 2014-07-11 14:49:54 +0200 | [diff] [blame] | 117 | pr("alloc size %" PRIu64 "B (+%zu), max %" PRIu64 "B\n", |
| 118 | oe->cur_alloc_size, size, oe->max_alloc_size); |
| 119 | |
Jiri Olsa | 5f86b80 | 2014-08-01 13:02:58 -0300 | [diff] [blame] | 120 | oe->cur_alloc_size += size; |
| 121 | list_add(&oe->buffer->list, &oe->to_free); |
| 122 | |
| 123 | /* First entry is abused to maintain the to_free list. */ |
| 124 | oe->buffer_idx = 2; |
| 125 | new = oe->buffer + 1; |
Jiri Olsa | cee3ab9 | 2014-07-11 14:49:54 +0200 | [diff] [blame] | 126 | } else { |
| 127 | pr("allocation limit reached %" PRIu64 "B\n", oe->max_alloc_size); |
Jiri Olsa | 5f86b80 | 2014-08-01 13:02:58 -0300 | [diff] [blame] | 128 | } |
| 129 | |
Alexander Yarygin | 54bf53b | 2014-10-03 18:40:11 +0400 | [diff] [blame] | 130 | new->event = new_event; |
Jiri Olsa | 5f86b80 | 2014-08-01 13:02:58 -0300 | [diff] [blame] | 131 | return new; |
| 132 | } |
| 133 | |
Arnaldo Carvalho de Melo | 4a6b362 | 2015-03-03 13:02:24 -0300 | [diff] [blame^] | 134 | static struct ordered_event * |
| 135 | ordered_events__new_event(struct ordered_events *oe, u64 timestamp, |
Alexander Yarygin | 54bf53b | 2014-10-03 18:40:11 +0400 | [diff] [blame] | 136 | union perf_event *event) |
Jiri Olsa | 5f86b80 | 2014-08-01 13:02:58 -0300 | [diff] [blame] | 137 | { |
| 138 | struct ordered_event *new; |
| 139 | |
Alexander Yarygin | 54bf53b | 2014-10-03 18:40:11 +0400 | [diff] [blame] | 140 | new = alloc_event(oe, event); |
Jiri Olsa | 5f86b80 | 2014-08-01 13:02:58 -0300 | [diff] [blame] | 141 | if (new) { |
| 142 | new->timestamp = timestamp; |
| 143 | queue_event(oe, new); |
| 144 | } |
| 145 | |
| 146 | return new; |
| 147 | } |
| 148 | |
| 149 | void ordered_events__delete(struct ordered_events *oe, struct ordered_event *event) |
| 150 | { |
Jiri Olsa | fa4e5c6 | 2014-06-15 19:46:08 +0200 | [diff] [blame] | 151 | list_move(&event->list, &oe->cache); |
Jiri Olsa | 5f86b80 | 2014-08-01 13:02:58 -0300 | [diff] [blame] | 152 | oe->nr_events--; |
Alexander Yarygin | 54bf53b | 2014-10-03 18:40:11 +0400 | [diff] [blame] | 153 | free_dup_event(oe, event->event); |
Jiri Olsa | 5f86b80 | 2014-08-01 13:02:58 -0300 | [diff] [blame] | 154 | } |
| 155 | |
Arnaldo Carvalho de Melo | 4a6b362 | 2015-03-03 13:02:24 -0300 | [diff] [blame^] | 156 | int ordered_events__queue(struct ordered_events *oe, union perf_event *event, |
| 157 | struct perf_sample *sample, u64 file_offset) |
| 158 | { |
| 159 | u64 timestamp = sample->time; |
| 160 | struct ordered_event *oevent; |
| 161 | |
| 162 | if (!timestamp || timestamp == ~0ULL) |
| 163 | return -ETIME; |
| 164 | |
| 165 | if (timestamp < oe->last_flush) { |
| 166 | pr_oe_time(timestamp, "out of order event\n"); |
| 167 | pr_oe_time(oe->last_flush, "last flush, last_flush_type %d\n", |
| 168 | oe->last_flush_type); |
| 169 | |
| 170 | oe->evlist->stats.nr_unordered_events++; |
| 171 | } |
| 172 | |
| 173 | oevent = ordered_events__new_event(oe, timestamp, event); |
| 174 | if (!oevent) { |
| 175 | ordered_events__flush(oe, OE_FLUSH__HALF); |
| 176 | oevent = ordered_events__new_event(oe, timestamp, event); |
| 177 | } |
| 178 | |
| 179 | if (!oevent) |
| 180 | return -ENOMEM; |
| 181 | |
| 182 | oevent->file_offset = file_offset; |
| 183 | return 0; |
| 184 | } |
| 185 | |
Arnaldo Carvalho de Melo | b7b61cb | 2015-03-03 11:58:45 -0300 | [diff] [blame] | 186 | static int __ordered_events__flush(struct ordered_events *oe) |
Jiri Olsa | 5f86b80 | 2014-08-01 13:02:58 -0300 | [diff] [blame] | 187 | { |
Jiri Olsa | 5f86b80 | 2014-08-01 13:02:58 -0300 | [diff] [blame] | 188 | struct list_head *head = &oe->events; |
| 189 | struct ordered_event *tmp, *iter; |
| 190 | struct perf_sample sample; |
| 191 | u64 limit = oe->next_flush; |
| 192 | u64 last_ts = oe->last ? oe->last->timestamp : 0ULL; |
| 193 | bool show_progress = limit == ULLONG_MAX; |
| 194 | struct ui_progress prog; |
| 195 | int ret; |
| 196 | |
Arnaldo Carvalho de Melo | 2808368 | 2015-02-22 13:52:47 -0800 | [diff] [blame] | 197 | if (!limit) |
Jiri Olsa | 5f86b80 | 2014-08-01 13:02:58 -0300 | [diff] [blame] | 198 | return 0; |
| 199 | |
| 200 | if (show_progress) |
| 201 | ui_progress__init(&prog, oe->nr_events, "Processing time ordered events..."); |
| 202 | |
| 203 | list_for_each_entry_safe(iter, tmp, head, list) { |
| 204 | if (session_done()) |
| 205 | return 0; |
| 206 | |
| 207 | if (iter->timestamp > limit) |
| 208 | break; |
| 209 | |
Arnaldo Carvalho de Melo | b7b61cb | 2015-03-03 11:58:45 -0300 | [diff] [blame] | 210 | ret = perf_evlist__parse_sample(oe->evlist, iter->event, &sample); |
Jiri Olsa | 5f86b80 | 2014-08-01 13:02:58 -0300 | [diff] [blame] | 211 | if (ret) |
| 212 | pr_err("Can't parse sample, err = %d\n", ret); |
| 213 | else { |
Arnaldo Carvalho de Melo | d10eb1e | 2015-03-03 12:20:38 -0300 | [diff] [blame] | 214 | ret = oe->deliver(oe, iter, &sample); |
Jiri Olsa | 5f86b80 | 2014-08-01 13:02:58 -0300 | [diff] [blame] | 215 | if (ret) |
| 216 | return ret; |
| 217 | } |
| 218 | |
| 219 | ordered_events__delete(oe, iter); |
| 220 | oe->last_flush = iter->timestamp; |
| 221 | |
| 222 | if (show_progress) |
| 223 | ui_progress__update(&prog, 1); |
| 224 | } |
| 225 | |
| 226 | if (list_empty(head)) |
| 227 | oe->last = NULL; |
| 228 | else if (last_ts <= limit) |
| 229 | oe->last = list_entry(head->prev, struct ordered_event, list); |
| 230 | |
| 231 | return 0; |
| 232 | } |
| 233 | |
Arnaldo Carvalho de Melo | b7b61cb | 2015-03-03 11:58:45 -0300 | [diff] [blame] | 234 | int ordered_events__flush(struct ordered_events *oe, enum oe_flush how) |
Jiri Olsa | 5f86b80 | 2014-08-01 13:02:58 -0300 | [diff] [blame] | 235 | { |
Jiri Olsa | cee3ab9 | 2014-07-11 14:49:54 +0200 | [diff] [blame] | 236 | static const char * const str[] = { |
Jiri Olsa | b0a4520 | 2014-06-12 09:50:11 +0200 | [diff] [blame] | 237 | "NONE", |
Jiri Olsa | cee3ab9 | 2014-07-11 14:49:54 +0200 | [diff] [blame] | 238 | "FINAL", |
| 239 | "ROUND", |
| 240 | "HALF ", |
| 241 | }; |
Jiri Olsa | 5f86b80 | 2014-08-01 13:02:58 -0300 | [diff] [blame] | 242 | int err; |
| 243 | |
Arnaldo Carvalho de Melo | 2808368 | 2015-02-22 13:52:47 -0800 | [diff] [blame] | 244 | if (oe->nr_events == 0) |
| 245 | return 0; |
| 246 | |
Jiri Olsa | 5f86b80 | 2014-08-01 13:02:58 -0300 | [diff] [blame] | 247 | switch (how) { |
| 248 | case OE_FLUSH__FINAL: |
| 249 | oe->next_flush = ULLONG_MAX; |
| 250 | break; |
| 251 | |
| 252 | case OE_FLUSH__HALF: |
| 253 | { |
| 254 | struct ordered_event *first, *last; |
| 255 | struct list_head *head = &oe->events; |
| 256 | |
| 257 | first = list_entry(head->next, struct ordered_event, list); |
| 258 | last = oe->last; |
| 259 | |
| 260 | /* Warn if we are called before any event got allocated. */ |
| 261 | if (WARN_ONCE(!last || list_empty(head), "empty queue")) |
| 262 | return 0; |
| 263 | |
| 264 | oe->next_flush = first->timestamp; |
| 265 | oe->next_flush += (last->timestamp - first->timestamp) / 2; |
| 266 | break; |
| 267 | } |
| 268 | |
| 269 | case OE_FLUSH__ROUND: |
Jiri Olsa | b0a4520 | 2014-06-12 09:50:11 +0200 | [diff] [blame] | 270 | case OE_FLUSH__NONE: |
Jiri Olsa | 5f86b80 | 2014-08-01 13:02:58 -0300 | [diff] [blame] | 271 | default: |
| 272 | break; |
| 273 | }; |
| 274 | |
Jiri Olsa | cee3ab9 | 2014-07-11 14:49:54 +0200 | [diff] [blame] | 275 | pr_oe_time(oe->next_flush, "next_flush - ordered_events__flush PRE %s, nr_events %u\n", |
| 276 | str[how], oe->nr_events); |
| 277 | pr_oe_time(oe->max_timestamp, "max_timestamp\n"); |
| 278 | |
Arnaldo Carvalho de Melo | b7b61cb | 2015-03-03 11:58:45 -0300 | [diff] [blame] | 279 | err = __ordered_events__flush(oe); |
Jiri Olsa | 5f86b80 | 2014-08-01 13:02:58 -0300 | [diff] [blame] | 280 | |
| 281 | if (!err) { |
| 282 | if (how == OE_FLUSH__ROUND) |
| 283 | oe->next_flush = oe->max_timestamp; |
Jiri Olsa | b0a4520 | 2014-06-12 09:50:11 +0200 | [diff] [blame] | 284 | |
| 285 | oe->last_flush_type = how; |
Jiri Olsa | 5f86b80 | 2014-08-01 13:02:58 -0300 | [diff] [blame] | 286 | } |
| 287 | |
Jiri Olsa | cee3ab9 | 2014-07-11 14:49:54 +0200 | [diff] [blame] | 288 | pr_oe_time(oe->next_flush, "next_flush - ordered_events__flush POST %s, nr_events %u\n", |
| 289 | str[how], oe->nr_events); |
| 290 | pr_oe_time(oe->last_flush, "last_flush\n"); |
| 291 | |
Jiri Olsa | 5f86b80 | 2014-08-01 13:02:58 -0300 | [diff] [blame] | 292 | return err; |
| 293 | } |
Jiri Olsa | 36522f5 | 2014-06-10 22:47:40 +0200 | [diff] [blame] | 294 | |
Arnaldo Carvalho de Melo | b7b61cb | 2015-03-03 11:58:45 -0300 | [diff] [blame] | 295 | void ordered_events__init(struct ordered_events *oe, struct machines *machines, |
Arnaldo Carvalho de Melo | d10eb1e | 2015-03-03 12:20:38 -0300 | [diff] [blame] | 296 | struct perf_evlist *evlist, struct perf_tool *tool, |
| 297 | ordered_events__deliver_t deliver) |
Jiri Olsa | 36522f5 | 2014-06-10 22:47:40 +0200 | [diff] [blame] | 298 | { |
| 299 | INIT_LIST_HEAD(&oe->events); |
| 300 | INIT_LIST_HEAD(&oe->cache); |
| 301 | INIT_LIST_HEAD(&oe->to_free); |
| 302 | oe->max_alloc_size = (u64) -1; |
| 303 | oe->cur_alloc_size = 0; |
Arnaldo Carvalho de Melo | b7b61cb | 2015-03-03 11:58:45 -0300 | [diff] [blame] | 304 | oe->evlist = evlist; |
| 305 | oe->machines = machines; |
| 306 | oe->tool = tool; |
Arnaldo Carvalho de Melo | d10eb1e | 2015-03-03 12:20:38 -0300 | [diff] [blame] | 307 | oe->deliver = deliver; |
Jiri Olsa | 36522f5 | 2014-06-10 22:47:40 +0200 | [diff] [blame] | 308 | } |
Jiri Olsa | adc56ed | 2014-06-10 22:50:03 +0200 | [diff] [blame] | 309 | |
| 310 | void ordered_events__free(struct ordered_events *oe) |
| 311 | { |
| 312 | while (!list_empty(&oe->to_free)) { |
| 313 | struct ordered_event *event; |
| 314 | |
| 315 | event = list_entry(oe->to_free.next, struct ordered_event, list); |
| 316 | list_del(&event->list); |
Alexander Yarygin | 54bf53b | 2014-10-03 18:40:11 +0400 | [diff] [blame] | 317 | free_dup_event(oe, event->event); |
Jiri Olsa | adc56ed | 2014-06-10 22:50:03 +0200 | [diff] [blame] | 318 | free(event); |
| 319 | } |
| 320 | } |