litl 0.1.9
Loading...
Searching...
No Matches
litl_read.h
Go to the documentation of this file.
1/* -*- c-file-style: "GNU" -*- */
2/*
3 * Copyright © Télécom SudParis.
4 * See COPYING in top-level directory.
5 */
6
7#ifndef LITL_READ_H_
8#define LITL_READ_H_
9
21#include "litl_types.h"
22
48litl_read_trace_t* litl_read_open_trace(const char* filename);
49
56
64
72 litl_read_process_t* process);
73
81 const litl_size_t buf_size);
82
90
97
105 litl_read_process_t* process);
106
107
116 litl_read_process_t* process,
117 litl_read_thread_t* thread);
124
131
132/*** Internal-use macros ***/
133
134/*
135 * For internal use only
136 * Initializes a pointer for browsing the parameters of an event
137 */
138#define __LITL_READ_INIT_PTR(evt, _ptr_) \
139 do { \
140 if(LITL_READ_GET_TYPE(evt) == LITL_TYPE_REGULAR) \
141 _ptr_ = &LITL_READ_REGULAR(evt)->param[0]; \
142 else if(LITL_READ_GET_TYPE(evt) == LITL_TYPE_PACKED) \
143 _ptr_ = &(LITL_READ_PACKED(evt))->param[0]; \
144 } while(0)
145
146#if DEBUG
147#define __LITL_CHECK_EVENT_SIZE(evt, _ptr_) \
148 do{ \
149 void* base_ptr; \
150 __LITL_READ_INIT_PTR(evt, base_ptr); \
151 int expected_size=0; \
152 if(LITL_READ_GET_TYPE(evt) == LITL_TYPE_REGULAR){ \
153 expected_size = LITL_READ_REGULAR(evt)->nb_params * sizeof(litl_param_t); \
154 int actual_size= ((char*)_ptr_)-((char*)base_ptr); \
155 if(actual_size != expected_size){ \
156 fprintf(stderr, "[LiTL] Warning: parameters take %d bytes, but %d bytes were read!\n", expected_size, actual_size); \
157 abort(); \
158 } \
159 } else { \
160 expected_size = LITL_READ_PACKED(evt)->size; \
161 int actual_size= ((char*)_ptr_)-((char*)base_ptr); \
162 if(actual_size != expected_size){ \
163 fprintf(stderr, "[LiTL] Warning: parameters take %d bytes, but %d bytes were read!\n", expected_size, actual_size); \
164 abort(); \
165 } \
166 } \
167 }while(0)
168#else
169#define __LITL_CHECK_EVENT_SIZE(evt, _ptr_) do { }while(0)
170#endif
171
172/*
173 * For internal use only
174 * Returns the next parameter in an event
175 */
176#define __LITL_READ_GET_ARG(evt, _ptr_, arg) \
177 do { \
178 if(LITL_READ_GET_TYPE(evt) == LITL_TYPE_REGULAR) \
179 __LITL_READ_GET_ARG_REGULAR(_ptr_, arg); \
180 else \
181 __LITL_READ_GET_ARG_PACKED(_ptr_, arg); \
182 } while(0)
183
184/*
185 * For internal use only
186 * Returns the next parameter in a regular event
187 */
188#define __LITL_READ_GET_ARG_REGULAR(_ptr_, arg) do { \
189 arg = (typeof(arg)) *(litl_param_t*)_ptr_; \
190 (litl_param_t*)_ptr_++; \
191 } while(0)
192
193/*
194 * For internal use only
195 * Returns the next parameter in a packed event
196 */
197#define __LITL_READ_GET_ARG_PACKED(_ptr_, arg) do { \
198 memcpy(&arg, _ptr_, sizeof(arg)); \
199 _ptr_ = ((char*)_ptr_)+sizeof(arg); \
200 } while(0)
201
202/*** functions for reading events ***/
203
210#define LITL_READ_GET_CUR_EVENT_PER_THREAD(process, thread_index) \
211 (&(process)->threads[(thread_index)]->cur_event)
217#define LITL_READ_GET_CUR_EVENT(process) \
218 LITL_READ_GET_CUR_EVENT_PER_THREAD(process, (process)->cur_index)
219
225#define LITL_READ_GET_TID(read_event) (read_event)->tid
231#define LITL_READ_GET_TIME(read_event) (read_event)->event->time
237#define LITL_READ_GET_TYPE(read_event) (read_event)->event->type
243#define LITL_READ_GET_CODE(read_event) (read_event)->event->code
244
250#define LITL_READ_RAW(read_event) (&(read_event)->event->parameters.raw)
256#define LITL_READ_REGULAR(read_event) (&(read_event)->event->parameters.regular)
262#define LITL_READ_PACKED(read_event) (&(read_event)->event->parameters.packed)
268#define LITL_READ_OFFSET(read_event) (&(read_event)->event->parameters.offset)
269
276#define litl_read_get_param_1(p_evt, \
277 param1) \
278 do { \
279 void* _ptr_; \
280 __LITL_READ_INIT_PTR(p_evt, _ptr_); \
281 __LITL_READ_GET_ARG(p_evt, _ptr_, param1); \
282 __LITL_CHECK_EVENT_SIZE(p_evt, _ptr_); \
283 } while(0)
284
292#define litl_read_get_param_2(p_evt, \
293 param1, \
294 param2) \
295 do { \
296 void* _ptr_; \
297 __LITL_READ_INIT_PTR(p_evt, _ptr_); \
298 __LITL_READ_GET_ARG(p_evt, _ptr_, param1); \
299 __LITL_READ_GET_ARG(p_evt, _ptr_, param2); \
300 __LITL_CHECK_EVENT_SIZE(p_evt, _ptr_); \
301 } while(0)
302
311#define litl_read_get_param_3(p_evt, \
312 param1, \
313 param2, \
314 param3) \
315 do { \
316 void* _ptr_; \
317 __LITL_READ_INIT_PTR(p_evt, _ptr_); \
318 __LITL_READ_GET_ARG(p_evt, _ptr_, param1); \
319 __LITL_READ_GET_ARG(p_evt, _ptr_, param2); \
320 __LITL_READ_GET_ARG(p_evt, _ptr_, param3); \
321 __LITL_CHECK_EVENT_SIZE(p_evt, _ptr_); \
322 } while(0)
323
333#define litl_read_get_param_4(p_evt, \
334 param1, \
335 param2, \
336 param3, \
337 param4) \
338 do { \
339 void* _ptr_; \
340 __LITL_READ_INIT_PTR(p_evt, _ptr_); \
341 __LITL_READ_GET_ARG(p_evt, _ptr_, param1); \
342 __LITL_READ_GET_ARG(p_evt, _ptr_, param2); \
343 __LITL_READ_GET_ARG(p_evt, _ptr_, param3); \
344 __LITL_READ_GET_ARG(p_evt, _ptr_, param4); \
345 __LITL_CHECK_EVENT_SIZE(p_evt, _ptr_); \
346 } while(0)
347
358#define litl_read_get_param_5(p_evt, \
359 param1, \
360 param2, \
361 param3, \
362 param4, \
363 param5) \
364 do { \
365 void* _ptr_; \
366 __LITL_READ_INIT_PTR(p_evt, _ptr_); \
367 __LITL_READ_GET_ARG(p_evt, _ptr_, param1); \
368 __LITL_READ_GET_ARG(p_evt, _ptr_, param2); \
369 __LITL_READ_GET_ARG(p_evt, _ptr_, param3); \
370 __LITL_READ_GET_ARG(p_evt, _ptr_, param4); \
371 __LITL_READ_GET_ARG(p_evt, _ptr_, param5); \
372 __LITL_CHECK_EVENT_SIZE(p_evt, _ptr_); \
373 } while(0)
374
386#define litl_read_get_param_6(p_evt, \
387 param1, \
388 param2, \
389 param3, \
390 param4, \
391 param5, \
392 param6) \
393 do { \
394 void* _ptr_; \
395 __LITL_READ_INIT_PTR(p_evt, _ptr_); \
396 __LITL_READ_GET_ARG(p_evt, _ptr_, param1); \
397 __LITL_READ_GET_ARG(p_evt, _ptr_, param2); \
398 __LITL_READ_GET_ARG(p_evt, _ptr_, param3); \
399 __LITL_READ_GET_ARG(p_evt, _ptr_, param4); \
400 __LITL_READ_GET_ARG(p_evt, _ptr_, param5); \
401 __LITL_READ_GET_ARG(p_evt, _ptr_, param6); \
402 __LITL_CHECK_EVENT_SIZE(p_evt, _ptr_); \
403 } while(0)
404
417#define litl_read_get_param_7(p_evt, \
418 param1, \
419 param2, \
420 param3, \
421 param4, \
422 param5, \
423 param6, \
424 param7) \
425 do { \
426 void* _ptr_; \
427 __LITL_READ_INIT_PTR(p_evt, _ptr_); \
428 __LITL_READ_GET_ARG(p_evt, _ptr_, param1); \
429 __LITL_READ_GET_ARG(p_evt, _ptr_, param2); \
430 __LITL_READ_GET_ARG(p_evt, _ptr_, param3); \
431 __LITL_READ_GET_ARG(p_evt, _ptr_, param4); \
432 __LITL_READ_GET_ARG(p_evt, _ptr_, param5); \
433 __LITL_READ_GET_ARG(p_evt, _ptr_, param6); \
434 __LITL_READ_GET_ARG(p_evt, _ptr_, param7); \
435 __LITL_CHECK_EVENT_SIZE(p_evt, _ptr_); \
436 } while(0)
437
451#define litl_read_get_param_8(p_evt, \
452 param1, \
453 param2, \
454 param3, \
455 param4, \
456 param5, \
457 param6, \
458 param7, \
459 param8) \
460 do { \
461 void* _ptr_; \
462 __LITL_READ_INIT_PTR(p_evt, _ptr_); \
463 __LITL_READ_GET_ARG(p_evt, _ptr_, param1); \
464 __LITL_READ_GET_ARG(p_evt, _ptr_, param2); \
465 __LITL_READ_GET_ARG(p_evt, _ptr_, param3); \
466 __LITL_READ_GET_ARG(p_evt, _ptr_, param4); \
467 __LITL_READ_GET_ARG(p_evt, _ptr_, param5); \
468 __LITL_READ_GET_ARG(p_evt, _ptr_, param6); \
469 __LITL_READ_GET_ARG(p_evt, _ptr_, param7); \
470 __LITL_READ_GET_ARG(p_evt, _ptr_, param8); \
471 __LITL_CHECK_EVENT_SIZE(p_evt, _ptr_); \
472 } while(0)
473
488#define litl_read_get_param_9(p_evt, \
489 param1, \
490 param2, \
491 param3, \
492 param4, \
493 param5, \
494 param6, \
495 param7, \
496 param8, \
497 param9) \
498 do { \
499 void* _ptr_; \
500 __LITL_READ_INIT_PTR(p_evt, _ptr_); \
501 __LITL_READ_GET_ARG(p_evt, _ptr_, param1); \
502 __LITL_READ_GET_ARG(p_evt, _ptr_, param2); \
503 __LITL_READ_GET_ARG(p_evt, _ptr_, param3); \
504 __LITL_READ_GET_ARG(p_evt, _ptr_, param4); \
505 __LITL_READ_GET_ARG(p_evt, _ptr_, param5); \
506 __LITL_READ_GET_ARG(p_evt, _ptr_, param6); \
507 __LITL_READ_GET_ARG(p_evt, _ptr_, param7); \
508 __LITL_READ_GET_ARG(p_evt, _ptr_, param8); \
509 __LITL_READ_GET_ARG(p_evt, _ptr_, param9); \
510 __LITL_CHECK_EVENT_SIZE(p_evt, _ptr_); \
511 } while(0)
512
528#define litl_read_get_param_10(p_evt, \
529 param1, \
530 param2, \
531 param3, \
532 param4, \
533 param5, \
534 param6, \
535 param7, \
536 param8, \
537 param9, \
538 param10) \
539 do { \
540 void* _ptr_; \
541 __LITL_READ_INIT_PTR(p_evt, _ptr_); \
542 __LITL_READ_GET_ARG(p_evt, _ptr_, param1); \
543 __LITL_READ_GET_ARG(p_evt, _ptr_, param2); \
544 __LITL_READ_GET_ARG(p_evt, _ptr_, param3); \
545 __LITL_READ_GET_ARG(p_evt, _ptr_, param4); \
546 __LITL_READ_GET_ARG(p_evt, _ptr_, param5); \
547 __LITL_READ_GET_ARG(p_evt, _ptr_, param6); \
548 __LITL_READ_GET_ARG(p_evt, _ptr_, param7); \
549 __LITL_READ_GET_ARG(p_evt, _ptr_, param8); \
550 __LITL_READ_GET_ARG(p_evt, _ptr_, param9); \
551 __LITL_READ_GET_ARG(p_evt, _ptr_, param10); \
552 __LITL_CHECK_EVENT_SIZE(p_evt, _ptr_); \
553 } while(0)
554
555#endif /* LITL_READ_H_ */
litl_read_trace_t * litl_read_open_trace(const char *filename)
Opens a trace and reads the first portion of data (trace header) to the buffer.
Definition litl_read.c:187
litl_size_t litl_read_get_buffer_size(litl_read_trace_t *trace)
Returns the buffer size.
Definition litl_read.c:264
void litl_read_set_buffer_size(litl_read_trace_t *trace, const litl_size_t buf_size)
Sets the buffer size.
Definition litl_read.c:253
litl_process_header_t * litl_read_get_process_header(litl_read_process_t *process)
Returns a pointer to the process header.
Definition litl_read.c:245
litl_general_header_t * litl_read_get_trace_header(litl_read_trace_t *trace)
Returns a pointer to the trace header.
Definition litl_read.c:238
void litl_read_init_processes(litl_read_trace_t *trace)
Initializes the event reading structure.
Definition litl_read.c:206
void litl_read_reset_process(litl_read_process_t *process)
Resets the trace pointer.
Definition litl_read.c:296
void litl_read_finalize_trace(litl_read_trace_t *trace)
Closes the trace and frees the allocated memory.
Definition litl_read.c:451
litl_read_event_t * litl_read_next_event(litl_read_trace_t *trace)
Reads the next event from a trace file.
Definition litl_read.c:432
litl_read_event_t * litl_read_next_process_event(litl_read_trace_t *trace, litl_read_process_t *process)
Reads the next event from a trace.
Definition litl_read.c:393
litl_read_event_t * litl_read_next_thread_event(litl_read_trace_t *trace, litl_read_process_t *process, litl_read_thread_t *thread)
Reads the next event from a trace.
Definition litl_read.c:383
uint32_t litl_size_t
An auxiliary data type for storing data.
Definition litl_types.h:147
litl_types Provides a set of data structures for recording and reading events as well as merging and ...
A general data structure that corresponds to the header of a trace file.
Definition litl_types.h:249
A general data structure that corresponds to the header of a trace file.
Definition litl_types.h:260
A data structure for reading one event.
Definition litl_types.h:345
A data structure for reading process-specific events.
Definition litl_types.h:370
A data structure for reading thread-specific events.
Definition litl_types.h:354
A data structure for reading events from both regular trace files and archives of traces.
Definition litl_types.h:387