litl  0.1.9
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 
48 litl_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_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_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_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_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
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
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
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