litl  0.1.9
litl_write.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 
18 #ifndef LITL_WRITE_H_
19 #define LITL_WRITE_H_
20 
21 #include "litl_types.h"
22 
54 litl_write_trace_t* litl_write_init_trace(const uint32_t buf_size);
55 
62 
69 
76 
83 
89 
96 
103 
110 
117 void litl_write_set_filename(litl_write_trace_t* trace, char* filename);
118 
119 /*** Regular events ***/
120 
129 
139  litl_param_t param1);
140 
151  litl_param_t param1, litl_param_t param2);
152 
164  litl_param_t param1, litl_param_t param2,
165  litl_param_t param3);
166 
179  litl_param_t param1, litl_param_t param2,
180  litl_param_t param3, litl_param_t param4);
181 
195  litl_param_t param1, litl_param_t param2,
196  litl_param_t param3, litl_param_t param4,
197  litl_param_t param5);
198 
213  litl_param_t param1, litl_param_t param2,
214  litl_param_t param3, litl_param_t param4,
215  litl_param_t param5, litl_param_t param6);
216 
232  litl_param_t param1, litl_param_t param2,
233  litl_param_t param3, litl_param_t param4,
234  litl_param_t param5, litl_param_t param6,
235  litl_param_t param7);
236 
253  litl_param_t param1, litl_param_t param2,
254  litl_param_t param3, litl_param_t param4,
255  litl_param_t param5, litl_param_t param6,
256  litl_param_t param7, litl_param_t param8);
257 
275  litl_param_t param1, litl_param_t param2,
276  litl_param_t param3, litl_param_t param4,
277  litl_param_t param5, litl_param_t param6,
278  litl_param_t param7, litl_param_t param8,
279  litl_param_t param9);
280 
299  litl_param_t param1, litl_param_t param2,
300  litl_param_t param3, litl_param_t param4,
301  litl_param_t param5, litl_param_t param6,
302  litl_param_t param7, litl_param_t param8,
303  litl_param_t param9, litl_param_t param10);
304 
305 /*** Raw events ***/
306 
317  litl_size_t size, litl_data_t data[]);
318 
319 /*** Internal-use macros ***/
320 
331  litl_code_t code, int size);
332 
339 #define __LITL_WRITE_ADD_ARG(ptr, param) do { \
340  typeof(param) _param = param; \
341  memcpy(ptr, &_param, sizeof(_param)); \
342  ptr = ((char*) ptr)+sizeof(_param); \
343  } while(0)
344 
345 /*** Packed events ***/
346 
353 #define litl_write_probe_pack_0(trace, \
354  code, \
355  retval) do { \
356  int total_size = 0; \
357  litl_t* p_evt = __litl_write_get_event(trace, \
358  LITL_TYPE_PACKED, \
359  code, total_size); \
360  retval = p_evt; \
361  } while(0)
362 
370 #define litl_write_probe_pack_1(trace, \
371  code, \
372  param1, \
373  retval) \
374  do { \
375  int total_size = sizeof(param1); \
376  litl_t* p_evt = __litl_write_get_event(trace, \
377  LITL_TYPE_PACKED, \
378  code, \
379  total_size); \
380  if(p_evt){ \
381  void* _ptr_ = &p_evt->parameters.packed.param[0]; \
382  __LITL_WRITE_ADD_ARG(_ptr_, param1); \
383  } \
384  retval = p_evt; \
385  } while(0)
386 
395 #define litl_write_probe_pack_2(trace, \
396  code, \
397  param1, \
398  param2, \
399  retval) \
400  do { \
401  int total_size = sizeof(param1) + sizeof(param2); \
402  litl_t* p_evt = __litl_write_get_event(trace, \
403  LITL_TYPE_PACKED, \
404  code, \
405  total_size); \
406  if(p_evt){ \
407  void* _ptr_ = &p_evt->parameters.packed.param[0]; \
408  __LITL_WRITE_ADD_ARG(_ptr_, param1); \
409  __LITL_WRITE_ADD_ARG(_ptr_, param2); \
410  } \
411  retval = p_evt; \
412  } while(0)
413 
423 #define litl_write_probe_pack_3(trace, \
424  code, \
425  param1, \
426  param2, \
427  param3, \
428  retval) do { \
429  int total_size = sizeof(param1) + sizeof(param2) + \
430  sizeof(param3); \
431  litl_t* p_evt = __litl_write_get_event(trace, \
432  LITL_TYPE_PACKED, \
433  code, \
434  total_size); \
435  if(p_evt){ \
436  void* _ptr_ = &p_evt->parameters.packed.param[0]; \
437  __LITL_WRITE_ADD_ARG(_ptr_, param1); \
438  __LITL_WRITE_ADD_ARG(_ptr_, param2); \
439  __LITL_WRITE_ADD_ARG(_ptr_, param3); \
440  } \
441  retval = p_evt; \
442  } while(0)
443 
454 #define litl_write_probe_pack_4(trace, \
455  code, \
456  param1, \
457  param2, \
458  param3, \
459  param4, \
460  retval) do { \
461  int total_size = sizeof(param1) + sizeof(param2) + \
462  sizeof(param3) + sizeof(param4); \
463  litl_t* p_evt = __litl_write_get_event(trace, \
464  LITL_TYPE_PACKED, \
465  code, \
466  total_size); \
467  if(p_evt){ \
468  void* _ptr_ = &p_evt->parameters.packed.param[0]; \
469  __LITL_WRITE_ADD_ARG(_ptr_, param1); \
470  __LITL_WRITE_ADD_ARG(_ptr_, param2); \
471  __LITL_WRITE_ADD_ARG(_ptr_, param3); \
472  __LITL_WRITE_ADD_ARG(_ptr_, param4); \
473  } \
474  retval = p_evt; \
475  } while(0)
476 
488 #define litl_write_probe_pack_5(trace, \
489  code, \
490  param1, \
491  param2, \
492  param3, \
493  param4, \
494  param5, \
495  retval) do { \
496  int total_size = sizeof(param1) + sizeof(param2) + \
497  sizeof(param3) + sizeof(param4) +sizeof(param5); \
498  litl_t* p_evt = __litl_write_get_event(trace, \
499  LITL_TYPE_PACKED, \
500  code, \
501  total_size); \
502  if(p_evt){ \
503  void* _ptr_ = &p_evt->parameters.packed.param[0]; \
504  __LITL_WRITE_ADD_ARG(_ptr_, param1); \
505  __LITL_WRITE_ADD_ARG(_ptr_, param2); \
506  __LITL_WRITE_ADD_ARG(_ptr_, param3); \
507  __LITL_WRITE_ADD_ARG(_ptr_, param4); \
508  __LITL_WRITE_ADD_ARG(_ptr_, param5); \
509  } \
510  retval = p_evt; \
511  } while(0)
512 
525 #define litl_write_probe_pack_6(trace, \
526  code, \
527  param1, \
528  param2, \
529  param3, \
530  param4, \
531  param5, \
532  param6, \
533  retval) do { \
534  int total_size = sizeof(param1) + sizeof(param2) + \
535  sizeof(param3) + sizeof(param4) + sizeof(param5) + sizeof(param6); \
536  litl_t* p_evt = __litl_write_get_event(trace, \
537  LITL_TYPE_PACKED, \
538  code, \
539  total_size); \
540  if(p_evt){ \
541  void* _ptr_ = &p_evt->parameters.packed.param[0]; \
542  __LITL_WRITE_ADD_ARG(_ptr_, param1); \
543  __LITL_WRITE_ADD_ARG(_ptr_, param2); \
544  __LITL_WRITE_ADD_ARG(_ptr_, param3); \
545  __LITL_WRITE_ADD_ARG(_ptr_, param4); \
546  __LITL_WRITE_ADD_ARG(_ptr_, param5); \
547  __LITL_WRITE_ADD_ARG(_ptr_, param6); \
548  } \
549  retval = p_evt; \
550  } while(0)
551 
565 #define litl_write_probe_pack_7(trace, \
566  code, \
567  param1, \
568  param2, \
569  param3, \
570  param4, \
571  param5, \
572  param6, \
573  param7, \
574  retval) do { \
575  int total_size = sizeof(param1) + sizeof(param2) + \
576  sizeof(param3) + sizeof(param4) + sizeof(param5) + sizeof(param6) \
577  + sizeof(param7); \
578  litl_t* p_evt = __litl_write_get_event(trace, \
579  LITL_TYPE_PACKED, \
580  code, \
581  total_size); \
582  if(p_evt){ \
583  void* _ptr_ = &p_evt->parameters.packed.param[0]; \
584  __LITL_WRITE_ADD_ARG(_ptr_, param1); \
585  __LITL_WRITE_ADD_ARG(_ptr_, param2); \
586  __LITL_WRITE_ADD_ARG(_ptr_, param3); \
587  __LITL_WRITE_ADD_ARG(_ptr_, param4); \
588  __LITL_WRITE_ADD_ARG(_ptr_, param5); \
589  __LITL_WRITE_ADD_ARG(_ptr_, param6); \
590  __LITL_WRITE_ADD_ARG(_ptr_, param7); \
591  } \
592  retval = p_evt; \
593  } while(0)
594 
609 #define litl_write_probe_pack_8(trace, \
610  code, \
611  param1, \
612  param2, \
613  param3, \
614  param4, \
615  param5, \
616  param6, \
617  param7, \
618  param8, \
619  retval) do { \
620  int total_size = sizeof(param1) + sizeof(param2) + \
621  sizeof(param3) + sizeof(param4) + sizeof(param5) + sizeof(param6) \
622  + sizeof(param7) + sizeof(param8); \
623  litl_t* p_evt = __litl_write_get_event(trace, \
624  LITL_TYPE_PACKED, \
625  code, \
626  total_size); \
627  if(p_evt){ \
628  void* _ptr_ = &p_evt->parameters.packed.param[0]; \
629  __LITL_WRITE_ADD_ARG(_ptr_, param1); \
630  __LITL_WRITE_ADD_ARG(_ptr_, param2); \
631  __LITL_WRITE_ADD_ARG(_ptr_, param3); \
632  __LITL_WRITE_ADD_ARG(_ptr_, param4); \
633  __LITL_WRITE_ADD_ARG(_ptr_, param5); \
634  __LITL_WRITE_ADD_ARG(_ptr_, param6); \
635  __LITL_WRITE_ADD_ARG(_ptr_, param7); \
636  __LITL_WRITE_ADD_ARG(_ptr_, param8); \
637  } \
638  retval = p_evt; \
639  } while(0)
640 
641 
657 #define litl_write_probe_pack_9(trace, \
658  code, \
659  param1, \
660  param2, \
661  param3, \
662  param4, \
663  param5, \
664  param6, \
665  param7, \
666  param8, \
667  param9, \
668  retval) do { \
669  int total_size = sizeof(param1) + sizeof(param2) + \
670  sizeof(param3) + sizeof(param4) + sizeof(param5) + sizeof(param6) \
671  + sizeof(param7) + sizeof(param8) + sizeof(param9); \
672  litl_t* p_evt = __litl_write_get_event(trace, \
673  LITL_TYPE_PACKED, \
674  code, \
675  total_size); \
676  if(p_evt){ \
677  void* _ptr_ = &p_evt->parameters.packed.param[0]; \
678  __LITL_WRITE_ADD_ARG(_ptr_, param1); \
679  __LITL_WRITE_ADD_ARG(_ptr_, param2); \
680  __LITL_WRITE_ADD_ARG(_ptr_, param3); \
681  __LITL_WRITE_ADD_ARG(_ptr_, param4); \
682  __LITL_WRITE_ADD_ARG(_ptr_, param5); \
683  __LITL_WRITE_ADD_ARG(_ptr_, param6); \
684  __LITL_WRITE_ADD_ARG(_ptr_, param7); \
685  __LITL_WRITE_ADD_ARG(_ptr_, param8); \
686  __LITL_WRITE_ADD_ARG(_ptr_, param9); \
687  } \
688  retval = p_evt; \
689  } while(0)
690 
707 #define litl_write_probe_pack_10(trace, \
708  code, \
709  param1, \
710  param2, \
711  param3, \
712  param4, \
713  param5, \
714  param6, \
715  param7, \
716  param8, \
717  param9, \
718  param10, \
719  retval) do { \
720  int total_size = sizeof(param1) + sizeof(param2) + \
721  sizeof(param3) + sizeof(param4) + sizeof(param5) + sizeof(param6) + \
722  sizeof(param7) + sizeof(param8) + sizeof(param9) + sizeof(param10); \
723  litl_t* p_evt = __litl_write_get_event(trace, \
724  LITL_TYPE_PACKED, \
725  code, \
726  total_size); \
727  if(p_evt){ \
728  void* _ptr_ = &p_evt->parameters.packed.param[0]; \
729  __LITL_WRITE_ADD_ARG(_ptr_, param1); \
730  __LITL_WRITE_ADD_ARG(_ptr_, param2); \
731  __LITL_WRITE_ADD_ARG(_ptr_, param3); \
732  __LITL_WRITE_ADD_ARG(_ptr_, param4); \
733  __LITL_WRITE_ADD_ARG(_ptr_, param5); \
734  __LITL_WRITE_ADD_ARG(_ptr_, param6); \
735  __LITL_WRITE_ADD_ARG(_ptr_, param7); \
736  __LITL_WRITE_ADD_ARG(_ptr_, param8); \
737  __LITL_WRITE_ADD_ARG(_ptr_, param9); \
738  __LITL_WRITE_ADD_ARG(_ptr_, param10); \
739  } \
740  retval = p_evt; \
741  } while(0)
742 
749 
750 #endif /* LITL_WRITE_H_ */
uint64_t litl_param_t
A data type for the non-optimized storage of parameters.
Definition: litl_types.h:124
litl_type_t
The enumeration of event types.
Definition: litl_types.h:180
uint8_t litl_data_t
A data type for the optimized storage of parameters.
Definition: litl_types.h:157
uint32_t litl_size_t
An auxiliary data type for storing data.
Definition: litl_types.h:147
uint32_t litl_code_t
A data type for storing events codes.
Definition: litl_types.h:142
void litl_write_tid_recording_on(litl_write_trace_t *trace)
Enable recording tid.
Definition: litl_write.c:213
void litl_write_pause_recording(litl_write_trace_t *trace)
Pauses the event recording.
Definition: litl_write.c:227
void litl_write_buffer_flush_on(litl_write_trace_t *trace)
Enable buffer flush. By default, it is disabled.
Definition: litl_write.c:185
void litl_write_finalize_trace(litl_write_trace_t *trace)
Finalizes the trace.
Definition: litl_write.c:897
void litl_write_tid_recording_off(litl_write_trace_t *trace)
Disable recording tid. By default, it is enabled.
Definition: litl_write.c:220
void litl_write_resume_recording(litl_write_trace_t *trace)
Resumes the event recording.
Definition: litl_write.c:235
void litl_write_buffer_flush_off(litl_write_trace_t *trace)
Disable buffer flush.
Definition: litl_write.c:192
void litl_write_set_filename(litl_write_trace_t *trace, char *filename)
Sets a new name for the trace file.
Definition: litl_write.c:243
void litl_write_thread_safety_on(litl_write_trace_t *trace)
Enable thread safety.
Definition: litl_write.c:199
litl_write_trace_t * litl_write_init_trace(const uint32_t buf_size)
Initializes the trace buffer.
Definition: litl_write.c:81
void litl_write_thread_safety_off(litl_write_trace_t *trace)
Disable thread safety. By default, it is enabled.
Definition: litl_write.c:206
litl_t * __litl_write_get_event(litl_write_trace_t *trace, litl_type_t type, litl_code_t code, int size)
For internal use only. Allocates an event.
Definition: litl_write.c:592
litl_t * litl_write_probe_raw(litl_write_trace_t *trace, litl_code_t code, litl_size_t size, litl_data_t data[])
Records an event with data in a string format.
Definition: litl_write.c:878
litl_t * litl_write_probe_reg_4(litl_write_trace_t *trace, litl_code_t code, litl_param_t param1, litl_param_t param2, litl_param_t param3, litl_param_t param4)
Records a regular event with 4 parameters.
Definition: litl_write.c:732
litl_t * litl_write_probe_reg_9(litl_write_trace_t *trace, litl_code_t code, litl_param_t param1, litl_param_t param2, litl_param_t param3, litl_param_t param4, litl_param_t param5, litl_param_t param6, litl_param_t param7, litl_param_t param8, litl_param_t param9)
Records a regular event with 9 parameters.
Definition: litl_write.c:828
litl_t * litl_write_probe_reg_1(litl_write_trace_t *trace, litl_code_t code, litl_param_t param1)
Records a regular event with 1 parameter.
Definition: litl_write.c:692
litl_t * litl_write_probe_reg_10(litl_write_trace_t *trace, litl_code_t code, litl_param_t param1, litl_param_t param2, litl_param_t param3, litl_param_t param4, litl_param_t param5, litl_param_t param6, litl_param_t param7, litl_param_t param8, litl_param_t param9, litl_param_t param10)
Records a regular event with 10 parameters.
Definition: litl_write.c:852
litl_t * litl_write_probe_reg_7(litl_write_trace_t *trace, litl_code_t code, litl_param_t param1, litl_param_t param2, litl_param_t param3, litl_param_t param4, litl_param_t param5, litl_param_t param6, litl_param_t param7)
Records a regular event with 7 parameters.
Definition: litl_write.c:785
litl_t * litl_write_probe_reg_6(litl_write_trace_t *trace, litl_code_t code, litl_param_t param1, litl_param_t param2, litl_param_t param3, litl_param_t param4, litl_param_t param5, litl_param_t param6)
Records a regular event with 6 parameters.
Definition: litl_write.c:766
litl_t * litl_write_probe_reg_8(litl_write_trace_t *trace, litl_code_t code, litl_param_t param1, litl_param_t param2, litl_param_t param3, litl_param_t param4, litl_param_t param5, litl_param_t param6, litl_param_t param7, litl_param_t param8)
Records a regular event with 8 parameters.
Definition: litl_write.c:806
litl_t * litl_write_probe_reg_5(litl_write_trace_t *trace, litl_code_t code, litl_param_t param1, litl_param_t param2, litl_param_t param3, litl_param_t param4, litl_param_t param5)
Records a regular event with 5 parameters.
Definition: litl_write.c:748
litl_t * litl_write_probe_reg_0(litl_write_trace_t *trace, litl_code_t code)
Records a regular event without parameters.
Definition: litl_write.c:684
litl_t * litl_write_probe_reg_2(litl_write_trace_t *trace, litl_code_t code, litl_param_t param1, litl_param_t param2)
Records a regular event with 2 parameters.
Definition: litl_write.c:704
litl_t * litl_write_probe_reg_3(litl_write_trace_t *trace, litl_code_t code, litl_param_t param1, litl_param_t param2, litl_param_t param3)
Records a regular event with 3 parameters.
Definition: litl_write.c:717
litl_types Provides a set of data structures for recording and reading events as well as merging and ...
A general structure of LiTL event type.
Definition: litl_types.h:192
A data structure for recording events.
Definition: litl_types.h:307