litl  0.1.8
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 
113 
120 
121 /*** Internal-use macros ***/
122 
123 /*
124  * For internal use only
125  * Initializes a pointer for browsing the parameters of an event
126  */
127 #define __LITL_READ_INIT_PTR(evt, _ptr_) \
128  do { \
129  if(LITL_READ_GET_TYPE(evt) == LITL_TYPE_REGULAR) \
130  _ptr_ = &LITL_READ_REGULAR(evt)->param[0]; \
131  else if(LITL_READ_GET_TYPE(evt) == LITL_TYPE_PACKED) \
132  _ptr_ = &(LITL_READ_PACKED(evt))->param[0]; \
133  } while(0)
134 
135 #if DEBUG
136 #define __LITL_CHECK_EVENT_SIZE(evt, _ptr_) \
137  do{ \
138  void* base_ptr; \
139  __LITL_READ_INIT_PTR(evt, base_ptr); \
140  int expected_size=0; \
141  if(LITL_READ_GET_TYPE(evt) == LITL_TYPE_REGULAR){ \
142  expected_size = LITL_READ_REGULAR(evt)->nb_params * sizeof(litl_param_t); \
143  int actual_size= ((char*)_ptr_)-((char*)base_ptr); \
144  if(actual_size != expected_size){ \
145  fprintf(stderr, "[LiTL] Warning: parameters take %d bytes, but %d bytes were read!\n", expected_size, actual_size); \
146  abort(); \
147  } \
148  } else { \
149  expected_size = LITL_READ_PACKED(evt)->size; \
150  int actual_size= ((char*)_ptr_)-((char*)base_ptr); \
151  if(actual_size != expected_size){ \
152  fprintf(stderr, "[LiTL] Warning: parameters take %d bytes, but %d bytes were read!\n", expected_size, actual_size); \
153  abort(); \
154  } \
155  } \
156  }while(0)
157 #else
158 #define __LITL_CHECK_EVENT_SIZE(evt, _ptr_) do { }while(0)
159 #endif
160 
161 /*
162  * For internal use only
163  * Returns the next parameter in an event
164  */
165 #define __LITL_READ_GET_ARG(evt, _ptr_, arg) \
166  do { \
167  if(LITL_READ_GET_TYPE(evt) == LITL_TYPE_REGULAR) \
168  __LITL_READ_GET_ARG_REGULAR(_ptr_, arg); \
169  else \
170  __LITL_READ_GET_ARG_PACKED(_ptr_, arg); \
171  } while(0)
172 
173 /*
174  * For internal use only
175  * Returns the next parameter in a regular event
176  */
177 #define __LITL_READ_GET_ARG_REGULAR(_ptr_, arg) do { \
178  arg = (typeof(arg)) *(litl_param_t*)_ptr_; \
179  (litl_param_t*)_ptr_++; \
180  } while(0)
181 
182 /*
183  * For internal use only
184  * Returns the next parameter in a packed event
185  */
186 #define __LITL_READ_GET_ARG_PACKED(_ptr_, arg) do { \
187  memcpy(&arg, _ptr_, sizeof(arg)); \
188  _ptr_ = ((char*)_ptr_)+sizeof(arg); \
189  } while(0)
190 
191 /*** functions for reading events ***/
192 
199 #define LITL_READ_GET_CUR_EVENT_PER_THREAD(process, thread_index) \
200  (&(process)->threads[(thread_index)]->cur_event)
201 
206 #define LITL_READ_GET_CUR_EVENT(process) \
207  LITL_READ_GET_CUR_EVENT_PER_THREAD(process, (process)->cur_index)
208 
214 #define LITL_READ_GET_TID(read_event) (read_event)->tid
215 
220 #define LITL_READ_GET_TIME(read_event) (read_event)->event->time
221 
226 #define LITL_READ_GET_TYPE(read_event) (read_event)->event->type
227 
232 #define LITL_READ_GET_CODE(read_event) (read_event)->event->code
233 
239 #define LITL_READ_RAW(read_event) (&(read_event)->event->parameters.raw)
240 
245 #define LITL_READ_REGULAR(read_event) (&(read_event)->event->parameters.regular)
246 
251 #define LITL_READ_PACKED(read_event) (&(read_event)->event->parameters.packed)
252 
257 #define LITL_READ_OFFSET(read_event) (&(read_event)->event->parameters.offset)
258 
265 #define litl_read_get_param_1(p_evt, \
266  param1) \
267  do { \
268  void* _ptr_; \
269  __LITL_READ_INIT_PTR(p_evt, _ptr_); \
270  __LITL_READ_GET_ARG(p_evt, _ptr_, param1); \
271  __LITL_CHECK_EVENT_SIZE(p_evt, _ptr_); \
272  } while(0)
273 
281 #define litl_read_get_param_2(p_evt, \
282  param1, \
283  param2) \
284  do { \
285  void* _ptr_; \
286  __LITL_READ_INIT_PTR(p_evt, _ptr_); \
287  __LITL_READ_GET_ARG(p_evt, _ptr_, param1); \
288  __LITL_READ_GET_ARG(p_evt, _ptr_, param2); \
289  __LITL_CHECK_EVENT_SIZE(p_evt, _ptr_); \
290  } while(0)
291 
300 #define litl_read_get_param_3(p_evt, \
301  param1, \
302  param2, \
303  param3) \
304  do { \
305  void* _ptr_; \
306  __LITL_READ_INIT_PTR(p_evt, _ptr_); \
307  __LITL_READ_GET_ARG(p_evt, _ptr_, param1); \
308  __LITL_READ_GET_ARG(p_evt, _ptr_, param2); \
309  __LITL_READ_GET_ARG(p_evt, _ptr_, param3); \
310  __LITL_CHECK_EVENT_SIZE(p_evt, _ptr_); \
311  } while(0)
312 
322 #define litl_read_get_param_4(p_evt, \
323  param1, \
324  param2, \
325  param3, \
326  param4) \
327  do { \
328  void* _ptr_; \
329  __LITL_READ_INIT_PTR(p_evt, _ptr_); \
330  __LITL_READ_GET_ARG(p_evt, _ptr_, param1); \
331  __LITL_READ_GET_ARG(p_evt, _ptr_, param2); \
332  __LITL_READ_GET_ARG(p_evt, _ptr_, param3); \
333  __LITL_READ_GET_ARG(p_evt, _ptr_, param4); \
334  __LITL_CHECK_EVENT_SIZE(p_evt, _ptr_); \
335  } while(0)
336 
347 #define litl_read_get_param_5(p_evt, \
348  param1, \
349  param2, \
350  param3, \
351  param4, \
352  param5) \
353  do { \
354  void* _ptr_; \
355  __LITL_READ_INIT_PTR(p_evt, _ptr_); \
356  __LITL_READ_GET_ARG(p_evt, _ptr_, param1); \
357  __LITL_READ_GET_ARG(p_evt, _ptr_, param2); \
358  __LITL_READ_GET_ARG(p_evt, _ptr_, param3); \
359  __LITL_READ_GET_ARG(p_evt, _ptr_, param4); \
360  __LITL_READ_GET_ARG(p_evt, _ptr_, param5); \
361  __LITL_CHECK_EVENT_SIZE(p_evt, _ptr_); \
362  } while(0)
363 
375 #define litl_read_get_param_6(p_evt, \
376  param1, \
377  param2, \
378  param3, \
379  param4, \
380  param5, \
381  param6) \
382  do { \
383  void* _ptr_; \
384  __LITL_READ_INIT_PTR(p_evt, _ptr_); \
385  __LITL_READ_GET_ARG(p_evt, _ptr_, param1); \
386  __LITL_READ_GET_ARG(p_evt, _ptr_, param2); \
387  __LITL_READ_GET_ARG(p_evt, _ptr_, param3); \
388  __LITL_READ_GET_ARG(p_evt, _ptr_, param4); \
389  __LITL_READ_GET_ARG(p_evt, _ptr_, param5); \
390  __LITL_READ_GET_ARG(p_evt, _ptr_, param6); \
391  __LITL_CHECK_EVENT_SIZE(p_evt, _ptr_); \
392  } while(0)
393 
406 #define litl_read_get_param_7(p_evt, \
407  param1, \
408  param2, \
409  param3, \
410  param4, \
411  param5, \
412  param6, \
413  param7) \
414  do { \
415  void* _ptr_; \
416  __LITL_READ_INIT_PTR(p_evt, _ptr_); \
417  __LITL_READ_GET_ARG(p_evt, _ptr_, param1); \
418  __LITL_READ_GET_ARG(p_evt, _ptr_, param2); \
419  __LITL_READ_GET_ARG(p_evt, _ptr_, param3); \
420  __LITL_READ_GET_ARG(p_evt, _ptr_, param4); \
421  __LITL_READ_GET_ARG(p_evt, _ptr_, param5); \
422  __LITL_READ_GET_ARG(p_evt, _ptr_, param6); \
423  __LITL_READ_GET_ARG(p_evt, _ptr_, param7); \
424  __LITL_CHECK_EVENT_SIZE(p_evt, _ptr_); \
425  } while(0)
426 
440 #define litl_read_get_param_8(p_evt, \
441  param1, \
442  param2, \
443  param3, \
444  param4, \
445  param5, \
446  param6, \
447  param7, \
448  param8) \
449  do { \
450  void* _ptr_; \
451  __LITL_READ_INIT_PTR(p_evt, _ptr_); \
452  __LITL_READ_GET_ARG(p_evt, _ptr_, param1); \
453  __LITL_READ_GET_ARG(p_evt, _ptr_, param2); \
454  __LITL_READ_GET_ARG(p_evt, _ptr_, param3); \
455  __LITL_READ_GET_ARG(p_evt, _ptr_, param4); \
456  __LITL_READ_GET_ARG(p_evt, _ptr_, param5); \
457  __LITL_READ_GET_ARG(p_evt, _ptr_, param6); \
458  __LITL_READ_GET_ARG(p_evt, _ptr_, param7); \
459  __LITL_READ_GET_ARG(p_evt, _ptr_, param8); \
460  __LITL_CHECK_EVENT_SIZE(p_evt, _ptr_); \
461  } while(0)
462 
477 #define litl_read_get_param_9(p_evt, \
478  param1, \
479  param2, \
480  param3, \
481  param4, \
482  param5, \
483  param6, \
484  param7, \
485  param8, \
486  param9) \
487  do { \
488  void* _ptr_; \
489  __LITL_READ_INIT_PTR(p_evt, _ptr_); \
490  __LITL_READ_GET_ARG(p_evt, _ptr_, param1); \
491  __LITL_READ_GET_ARG(p_evt, _ptr_, param2); \
492  __LITL_READ_GET_ARG(p_evt, _ptr_, param3); \
493  __LITL_READ_GET_ARG(p_evt, _ptr_, param4); \
494  __LITL_READ_GET_ARG(p_evt, _ptr_, param5); \
495  __LITL_READ_GET_ARG(p_evt, _ptr_, param6); \
496  __LITL_READ_GET_ARG(p_evt, _ptr_, param7); \
497  __LITL_READ_GET_ARG(p_evt, _ptr_, param8); \
498  __LITL_READ_GET_ARG(p_evt, _ptr_, param9); \
499  __LITL_CHECK_EVENT_SIZE(p_evt, _ptr_); \
500  } while(0)
501 
517 #define litl_read_get_param_10(p_evt, \
518  param1, \
519  param2, \
520  param3, \
521  param4, \
522  param5, \
523  param6, \
524  param7, \
525  param8, \
526  param9, \
527  param10) \
528  do { \
529  void* _ptr_; \
530  __LITL_READ_INIT_PTR(p_evt, _ptr_); \
531  __LITL_READ_GET_ARG(p_evt, _ptr_, param1); \
532  __LITL_READ_GET_ARG(p_evt, _ptr_, param2); \
533  __LITL_READ_GET_ARG(p_evt, _ptr_, param3); \
534  __LITL_READ_GET_ARG(p_evt, _ptr_, param4); \
535  __LITL_READ_GET_ARG(p_evt, _ptr_, param5); \
536  __LITL_READ_GET_ARG(p_evt, _ptr_, param6); \
537  __LITL_READ_GET_ARG(p_evt, _ptr_, param7); \
538  __LITL_READ_GET_ARG(p_evt, _ptr_, param8); \
539  __LITL_READ_GET_ARG(p_evt, _ptr_, param9); \
540  __LITL_READ_GET_ARG(p_evt, _ptr_, param10); \
541  __LITL_CHECK_EVENT_SIZE(p_evt, _ptr_); \
542  } while(0)
543 
544 #endif /* LITL_READ_H_ */
A data structure for reading events from both regular trace files and archives of traces...
Definition: litl_types.h:384
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
void litl_read_reset_process(litl_read_process_t *process)
Resets the trace pointer.
Definition: litl_read.c:300
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
A data structure for reading one event.
Definition: litl_types.h:342
litl_size_t litl_read_get_buffer_size(litl_read_trace_t *trace)
Returns the buffer size.
Definition: litl_read.c:264
A general data structure that corresponds to the header of a trace file.
Definition: litl_types.h:258
A data structure for reading process-specific events.
Definition: litl_types.h:367
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
void litl_read_finalize_trace(litl_read_trace_t *trace)
Closes the trace and frees the allocated memory.
Definition: litl_read.c:451
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_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_types Provides a set of data structures for recording and reading events as well as merging and ...
uint32_t litl_size_t
An auxiliary data type for storing data.
Definition: litl_types.h:145
A general data structure that corresponds to the header of a trace file.
Definition: litl_types.h:247
void litl_read_init_processes(litl_read_trace_t *trace)
Initializes the event reading structure.
Definition: litl_read.c:206
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