litl  0.1.1
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros Groups
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 \
132  _ptr_ = &LITL_READ_PACKED(evt)->param[0]; \
133  } while(0)
134 
135 /*
136  * For internal use only
137  * Returns the next parameter in an event
138  */
139 #define __LITL_READ_GET_ARG(evt, _ptr_, arg) \
140  do { \
141  if(LITL_READ_GET_TYPE(evt) == LITL_TYPE_REGULAR) \
142  __LITL_READ_GET_ARG_REGULAR(_ptr_, arg); \
143  else \
144  __LITL_READ_GET_ARG_PACKED(_ptr_, arg); \
145  } while(0)
146 
147 /*
148  * For internal use only
149  * Returns the next parameter in a regular event
150  */
151 #define __LITL_READ_GET_ARG_REGULAR(_ptr_, arg) do { \
152  arg = (typeof(arg)) *(litl_param_t*)_ptr_; \
153  (litl_param_t*)_ptr_++; \
154  } while(0)
155 
156 /*
157  * For internal use only
158  * Returns the next parameter in a packed event
159  */
160 #define __LITL_READ_GET_ARG_PACKED(_ptr_, arg) do { \
161  memcpy(&arg, _ptr_, sizeof(arg)); \
162  _ptr_ = ((char*)_ptr_)+sizeof(arg); \
163  } while(0)
164 
165 /*** functions for reading events ***/
166 
173 #define LITL_READ_GET_CUR_EVENT_PER_THREAD(process, thread_index) \
174  (&(process)->threads[(thread_index)]->cur_event)
175 
180 #define LITL_READ_GET_CUR_EVENT(process) \
181  LITL_READ_GET_CUR_EVENT_PER_THREAD(process, (process)->cur_index)
182 
188 #define LITL_READ_GET_TID(read_event) (read_event)->tid
189 
194 #define LITL_READ_GET_TIME(read_event) (read_event)->event->time
195 
200 #define LITL_READ_GET_TYPE(read_event) (read_event)->event->type
201 
206 #define LITL_READ_GET_CODE(read_event) (read_event)->event->code
207 
213 #define LITL_READ_RAW(read_event) (&(read_event)->event->parameters.raw)
214 
219 #define LITL_READ_REGULAR(read_event) (&(read_event)->event->parameters.regular)
220 
225 #define LITL_READ_PACKED(read_event) (&(read_event)->event->parameters.packed)
226 
231 #define LITL_READ_OFFSET(read_event) (&(read_event)->event->parameters.offset)
232 
239 #define litl_read_get_param_1(p_evt, \
240  param1) \
241  do { \
242  void* _ptr_; \
243  __LITL_READ_INIT_PTR(p_evt, _ptr_); \
244  __LITL_READ_GET_ARG(p_evt, _ptr_, param1); \
245  } while(0)
246 
254 #define litl_read_get_param_2(p_evt, \
255  param1, \
256  param2) \
257  do { \
258  void* _ptr_; \
259  __LITL_READ_INIT_PTR(p_evt, _ptr_); \
260  __LITL_READ_GET_ARG(p_evt, _ptr_, param1); \
261  __LITL_READ_GET_ARG(p_evt, _ptr_, param2); \
262  } while(0)
263 
272 #define litl_read_get_param_3(p_evt, \
273  param1, \
274  param2, \
275  param3) \
276  do { \
277  void* _ptr_; \
278  __LITL_READ_INIT_PTR(p_evt, _ptr_); \
279  __LITL_READ_GET_ARG(p_evt, _ptr_, param1); \
280  __LITL_READ_GET_ARG(p_evt, _ptr_, param2); \
281  __LITL_READ_GET_ARG(p_evt, _ptr_, param3); \
282  } while(0)
283 
293 #define litl_read_get_param_4(p_evt, \
294  param1, \
295  param2, \
296  param3, \
297  param4) \
298  do { \
299  void* _ptr_; \
300  __LITL_READ_INIT_PTR(p_evt, _ptr_); \
301  __LITL_READ_GET_ARG(p_evt, _ptr_, param1); \
302  __LITL_READ_GET_ARG(p_evt, _ptr_, param2); \
303  __LITL_READ_GET_ARG(p_evt, _ptr_, param3); \
304  __LITL_READ_GET_ARG(p_evt, _ptr_, param4); \
305  } while(0)
306 
317 #define litl_read_get_param_5(p_evt, \
318  param1, \
319  param2, \
320  param3, \
321  param4, \
322  param5) \
323  do { \
324  void* _ptr_; \
325  __LITL_READ_INIT_PTR(p_evt, _ptr_); \
326  __LITL_READ_GET_ARG(p_evt, _ptr_, param1); \
327  __LITL_READ_GET_ARG(p_evt, _ptr_, param2); \
328  __LITL_READ_GET_ARG(p_evt, _ptr_, param3); \
329  __LITL_READ_GET_ARG(p_evt, _ptr_, param4); \
330  __LITL_READ_GET_ARG(p_evt, _ptr_, param5); \
331  } while(0)
332 
344 #define litl_read_get_param_6(p_evt, \
345  param1, \
346  param2, \
347  param3, \
348  param4, \
349  param5, \
350  param6) \
351  do { \
352  void* _ptr_; \
353  __LITL_READ_INIT_PTR(p_evt, _ptr_); \
354  __LITL_READ_GET_ARG(p_evt, _ptr_, param1); \
355  __LITL_READ_GET_ARG(p_evt, _ptr_, param2); \
356  __LITL_READ_GET_ARG(p_evt, _ptr_, param3); \
357  __LITL_READ_GET_ARG(p_evt, _ptr_, param4); \
358  __LITL_READ_GET_ARG(p_evt, _ptr_, param5); \
359  __LITL_READ_GET_ARG(p_evt, _ptr_, param6); \
360  } while(0)
361 
374 #define litl_read_get_param_7(p_evt, \
375  param1, \
376  param2, \
377  param3, \
378  param4, \
379  param5, \
380  param6, \
381  param7) \
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_READ_GET_ARG(p_evt, _ptr_, param7); \
392  } while(0)
393 
407 #define litl_read_get_param_8(p_evt, \
408  param1, \
409  param2, \
410  param3, \
411  param4, \
412  param5, \
413  param6, \
414  param7, \
415  param8) \
416  do { \
417  void* _ptr_; \
418  __LITL_READ_INIT_PTR(p_evt, _ptr_); \
419  __LITL_READ_GET_ARG(p_evt, _ptr_, param1); \
420  __LITL_READ_GET_ARG(p_evt, _ptr_, param2); \
421  __LITL_READ_GET_ARG(p_evt, _ptr_, param3); \
422  __LITL_READ_GET_ARG(p_evt, _ptr_, param4); \
423  __LITL_READ_GET_ARG(p_evt, _ptr_, param5); \
424  __LITL_READ_GET_ARG(p_evt, _ptr_, param6); \
425  __LITL_READ_GET_ARG(p_evt, _ptr_, param7); \
426  __LITL_READ_GET_ARG(p_evt, _ptr_, param8); \
427  } while(0)
428 
443 #define litl_read_get_param_9(p_evt, \
444  param1, \
445  param2, \
446  param3, \
447  param4, \
448  param5, \
449  param6, \
450  param7, \
451  param8, \
452  param9) \
453  do { \
454  void* _ptr_; \
455  __LITL_READ_INIT_PTR(p_evt, _ptr_); \
456  __LITL_READ_GET_ARG(p_evt, _ptr_, param1); \
457  __LITL_READ_GET_ARG(p_evt, _ptr_, param2); \
458  __LITL_READ_GET_ARG(p_evt, _ptr_, param3); \
459  __LITL_READ_GET_ARG(p_evt, _ptr_, param4); \
460  __LITL_READ_GET_ARG(p_evt, _ptr_, param5); \
461  __LITL_READ_GET_ARG(p_evt, _ptr_, param6); \
462  __LITL_READ_GET_ARG(p_evt, _ptr_, param7); \
463  __LITL_READ_GET_ARG(p_evt, _ptr_, param8); \
464  __LITL_READ_GET_ARG(p_evt, _ptr_, param9); \
465  } while(0)
466 
482 #define litl_read_get_param_10(p_evt, \
483  param1, \
484  param2, \
485  param3, \
486  param4, \
487  param5, \
488  param6, \
489  param7, \
490  param8, \
491  param9, \
492  param10) \
493  do { \
494  void* _ptr_; \
495  __LITL_READ_INIT_PTR(p_evt, _ptr_); \
496  __LITL_READ_GET_ARG(p_evt, _ptr_, param1); \
497  __LITL_READ_GET_ARG(p_evt, _ptr_, param2); \
498  __LITL_READ_GET_ARG(p_evt, _ptr_, param3); \
499  __LITL_READ_GET_ARG(p_evt, _ptr_, param4); \
500  __LITL_READ_GET_ARG(p_evt, _ptr_, param5); \
501  __LITL_READ_GET_ARG(p_evt, _ptr_, param6); \
502  __LITL_READ_GET_ARG(p_evt, _ptr_, param7); \
503  __LITL_READ_GET_ARG(p_evt, _ptr_, param8); \
504  __LITL_READ_GET_ARG(p_evt, _ptr_, param9); \
505  __LITL_READ_GET_ARG(p_evt, _ptr_, param10); \
506  } while(0)
507 
508 #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:385
void litl_read_finalize_trace(litl_read_trace_t *trace)
Closes the trace and frees the allocated memory.
Definition: litl_read.c:443
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:424
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