litl  0.1.3
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros Groups
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 = LITL_BASE_SIZE; \
357  litl_t* p_evt = __litl_write_get_event(trace, \
358  LITL_TYPE_PACKED, \
359  code, total_size); \
360  if(p_evt){ \
361  p_evt->parameters.packed.size = total_size - LITL_BASE_SIZE; \
362  } \
363  retval = p_evt; \
364  } while(0)
365 
373 #define litl_write_probe_pack_1(trace, \
374  code, \
375  param1, \
376  retval) \
377  do { \
378  int total_size = LITL_BASE_SIZE + sizeof(param1); \
379  litl_t* p_evt = __litl_write_get_event(trace, \
380  LITL_TYPE_PACKED, \
381  code, \
382  total_size); \
383  if(p_evt){ \
384  p_evt->parameters.packed.size = total_size - LITL_BASE_SIZE; \
385  void* _ptr_ = &p_evt->parameters.packed.param[0]; \
386  __LITL_WRITE_ADD_ARG(_ptr_, param1); \
387  } \
388  retval = p_evt; \
389  } while(0)
390 
399 #define litl_write_probe_pack_2(trace, \
400  code, \
401  param1, \
402  param2, \
403  retval) \
404  do { \
405  int total_size = LITL_BASE_SIZE + sizeof(param1) + sizeof(param2); \
406  litl_t* p_evt = __litl_write_get_event(trace, \
407  LITL_TYPE_PACKED, \
408  code, \
409  total_size); \
410  if(p_evt){ \
411  p_evt->parameters.packed.size = total_size - LITL_BASE_SIZE; \
412  void* _ptr_ = &p_evt->parameters.packed.param[0]; \
413  __LITL_WRITE_ADD_ARG(_ptr_, param1); \
414  __LITL_WRITE_ADD_ARG(_ptr_, param2); \
415  } \
416  retval = p_evt; \
417  } while(0)
418 
428 #define litl_write_probe_pack_3(trace, \
429  code, \
430  param1, \
431  param2, \
432  param3, \
433  retval) do { \
434  int total_size = LITL_BASE_SIZE + sizeof(param1) + sizeof(param2) + \
435  sizeof(param3); \
436  litl_t* p_evt = __litl_write_get_event(trace, \
437  LITL_TYPE_PACKED, \
438  code, \
439  total_size); \
440  if(p_evt){ \
441  p_evt->parameters.packed.size = total_size - LITL_BASE_SIZE; \
442  void* _ptr_ = &p_evt->parameters.packed.param[0]; \
443  __LITL_WRITE_ADD_ARG(_ptr_, param1); \
444  __LITL_WRITE_ADD_ARG(_ptr_, param2); \
445  __LITL_WRITE_ADD_ARG(_ptr_, param3); \
446  } \
447  retval = p_evt; \
448  } while(0)
449 
460 #define litl_write_probe_pack_4(trace, \
461  code, \
462  param1, \
463  param2, \
464  param3, \
465  param4, \
466  retval) do { \
467  int total_size = LITL_BASE_SIZE + sizeof(param1) + sizeof(param2) + \
468  sizeof(param3) + sizeof(param4); \
469  litl_t* p_evt = __litl_write_get_event(trace, \
470  LITL_TYPE_PACKED, \
471  code, \
472  total_size); \
473  if(p_evt){ \
474  p_evt->parameters.packed.size = total_size - LITL_BASE_SIZE; \
475  void* _ptr_ = &p_evt->parameters.packed.param[0]; \
476  __LITL_WRITE_ADD_ARG(_ptr_, param1); \
477  __LITL_WRITE_ADD_ARG(_ptr_, param2); \
478  __LITL_WRITE_ADD_ARG(_ptr_, param3); \
479  __LITL_WRITE_ADD_ARG(_ptr_, param4); \
480  } \
481  retval = p_evt; \
482  } while(0)
483 
495 #define litl_write_probe_pack_5(trace, \
496  code, \
497  param1, \
498  param2, \
499  param3, \
500  param4, \
501  param5, \
502  retval) do { \
503  int total_size = LITL_BASE_SIZE + sizeof(param1) + sizeof(param2) + \
504  sizeof(param3) + sizeof(param4) +sizeof(param5); \
505  litl_t* p_evt = __litl_write_get_event(trace, \
506  LITL_TYPE_PACKED, \
507  code, \
508  total_size); \
509  if(p_evt){ \
510  p_evt->parameters.packed.size = total_size - LITL_BASE_SIZE; \
511  void* _ptr_ = &p_evt->parameters.packed.param[0]; \
512  __LITL_WRITE_ADD_ARG(_ptr_, param1); \
513  __LITL_WRITE_ADD_ARG(_ptr_, param2); \
514  __LITL_WRITE_ADD_ARG(_ptr_, param3); \
515  __LITL_WRITE_ADD_ARG(_ptr_, param4); \
516  __LITL_WRITE_ADD_ARG(_ptr_, param5); \
517  } \
518  retval = p_evt; \
519  } while(0)
520 
533 #define litl_write_probe_pack_6(trace, \
534  code, \
535  param1, \
536  param2, \
537  param3, \
538  param4, \
539  param5, \
540  param6, \
541  retval) do { \
542  int total_size = LITL_BASE_SIZE + sizeof(param1) + sizeof(param2) + \
543  sizeof(param3) + sizeof(param4) + sizeof(param5) + sizeof(param6); \
544  litl_t* p_evt = __litl_write_get_event(trace, \
545  LITL_TYPE_PACKED, \
546  code, \
547  total_size); \
548  if(p_evt){ \
549  p_evt->parameters.packed.size = total_size - LITL_BASE_SIZE; \
550  void* _ptr_ = &p_evt->parameters.packed.param[0]; \
551  __LITL_WRITE_ADD_ARG(_ptr_, param1); \
552  __LITL_WRITE_ADD_ARG(_ptr_, param2); \
553  __LITL_WRITE_ADD_ARG(_ptr_, param3); \
554  __LITL_WRITE_ADD_ARG(_ptr_, param4); \
555  __LITL_WRITE_ADD_ARG(_ptr_, param5); \
556  __LITL_WRITE_ADD_ARG(_ptr_, param6); \
557  } \
558  retval = p_evt; \
559  } while(0)
560 
574 #define litl_write_probe_pack_7(trace, \
575  code, \
576  param1, \
577  param2, \
578  param3, \
579  param4, \
580  param5, \
581  param6, \
582  param7, \
583  retval) do { \
584  int total_size = LITL_BASE_SIZE + sizeof(param1) + sizeof(param2) + \
585  sizeof(param3) + sizeof(param4) + sizeof(param5) + sizeof(param6) \
586  + sizeof(param7); \
587  litl_t* p_evt = __litl_write_get_event(trace, \
588  LITL_TYPE_PACKED, \
589  code, \
590  total_size); \
591  if(p_evt){ \
592  p_evt->parameters.packed.size = total_size - LITL_BASE_SIZE; \
593  void* _ptr_ = &p_evt->parameters.packed.param[0]; \
594  __LITL_WRITE_ADD_ARG(_ptr_, param1); \
595  __LITL_WRITE_ADD_ARG(_ptr_, param2); \
596  __LITL_WRITE_ADD_ARG(_ptr_, param3); \
597  __LITL_WRITE_ADD_ARG(_ptr_, param4); \
598  __LITL_WRITE_ADD_ARG(_ptr_, param5); \
599  __LITL_WRITE_ADD_ARG(_ptr_, param6); \
600  __LITL_WRITE_ADD_ARG(_ptr_, param7); \
601  } \
602  retval = p_evt; \
603  } while(0)
604 
619 #define litl_write_probe_pack_8(trace, \
620  code, \
621  param1, \
622  param2, \
623  param3, \
624  param4, \
625  param5, \
626  param6, \
627  param7, \
628  param8, \
629  retval) do { \
630  int total_size = LITL_BASE_SIZE + sizeof(param1) + sizeof(param2) + \
631  sizeof(param3) + sizeof(param4) + sizeof(param5) + sizeof(param6) \
632  + sizeof(param7) + sizeof(param8); \
633  litl_t* p_evt = __litl_write_get_event(trace, \
634  LITL_TYPE_PACKED, \
635  code, \
636  total_size); \
637  if(p_evt){ \
638  p_evt->parameters.packed.size = total_size - LITL_BASE_SIZE; \
639  void* _ptr_ = &p_evt->parameters.packed.param[0]; \
640  __LITL_WRITE_ADD_ARG(_ptr_, param1); \
641  __LITL_WRITE_ADD_ARG(_ptr_, param2); \
642  __LITL_WRITE_ADD_ARG(_ptr_, param3); \
643  __LITL_WRITE_ADD_ARG(_ptr_, param4); \
644  __LITL_WRITE_ADD_ARG(_ptr_, param5); \
645  __LITL_WRITE_ADD_ARG(_ptr_, param6); \
646  __LITL_WRITE_ADD_ARG(_ptr_, param7); \
647  __LITL_WRITE_ADD_ARG(_ptr_, param8); \
648  } \
649  retval = p_evt; \
650  } while(0)
651 
667 #define litl_write_probe_pack_9(trace, \
668  code, \
669  param1, \
670  param2, \
671  param3, \
672  param4, \
673  param5, \
674  param6, \
675  param7, \
676  param8, \
677  param9, \
678  retval) do { \
679  int total_size = LITL_BASE_SIZE + sizeof(param1) + sizeof(param2) + \
680  sizeof(param3) + sizeof(param4) + sizeof(param5) + sizeof(param6) \
681  + sizeof(param7) + sizeof(param8) + sizeof(param9); \
682  litl_t* p_evt = __litl_write_get_event(trace, \
683  LITL_TYPE_PACKED, \
684  code, \
685  total_size); \
686  if(p_evt){ \
687  p_evt->parameters.packed.size = total_size - LITL_BASE_SIZE; \
688  void* _ptr_ = &p_evt->parameters.packed.param[0]; \
689  __LITL_WRITE_ADD_ARG(_ptr_, param1); \
690  __LITL_WRITE_ADD_ARG(_ptr_, param2); \
691  __LITL_WRITE_ADD_ARG(_ptr_, param3); \
692  __LITL_WRITE_ADD_ARG(_ptr_, param4); \
693  __LITL_WRITE_ADD_ARG(_ptr_, param5); \
694  __LITL_WRITE_ADD_ARG(_ptr_, param6); \
695  __LITL_WRITE_ADD_ARG(_ptr_, param7); \
696  __LITL_WRITE_ADD_ARG(_ptr_, param8); \
697  __LITL_WRITE_ADD_ARG(_ptr_, param9); \
698  } \
699  retval = p_evt; \
700  } while(0)
701 
718 #define litl_write_probe_pack_10(trace, \
719  code, \
720  param1, \
721  param2, \
722  param3, \
723  param4, \
724  param5, \
725  param6, \
726  param7, \
727  param8, \
728  param9, \
729  param10, \
730  retval) do { \
731  int total_size = LITL_BASE_SIZE + sizeof(param1) + sizeof(param2) + \
732  sizeof(param3) + sizeof(param4) + sizeof(param5) + sizeof(param6) + \
733  sizeof(param7) + sizeof(param8) + sizeof(param9) + sizeof(param10); \
734  litl_t* p_evt = __litl_write_get_event(trace, \
735  LITL_TYPE_PACKED, \
736  code, \
737  total_size); \
738  if(p_evt){ \
739  p_evt->parameters.packed.size = total_size - LITL_BASE_SIZE; \
740  void* _ptr_ = &p_evt->parameters.packed.param[0]; \
741  __LITL_WRITE_ADD_ARG(_ptr_, param1); \
742  __LITL_WRITE_ADD_ARG(_ptr_, param2); \
743  __LITL_WRITE_ADD_ARG(_ptr_, param3); \
744  __LITL_WRITE_ADD_ARG(_ptr_, param4); \
745  __LITL_WRITE_ADD_ARG(_ptr_, param5); \
746  __LITL_WRITE_ADD_ARG(_ptr_, param6); \
747  __LITL_WRITE_ADD_ARG(_ptr_, param7); \
748  __LITL_WRITE_ADD_ARG(_ptr_, param8); \
749  __LITL_WRITE_ADD_ARG(_ptr_, param9); \
750  __LITL_WRITE_ADD_ARG(_ptr_, param10); \
751  } \
752  retval = p_evt; \
753  } while(0)
754 
761 
762 #endif /* LITL_WRITE_H_ */
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:617
litl_type_t
The enumeration of event types.
Definition: litl_types.h:178
void litl_write_buffer_flush_on(litl_write_trace_t *trace)
Enable buffer flush. By default, it is disabled.
Definition: litl_write.c:195
uint64_t litl_param_t
A data type for the non-optimized storage of parameters.
Definition: litl_types.h:122
void litl_write_thread_safety_on(litl_write_trace_t *trace)
Enable thread safety.
Definition: litl_write.c:209
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:605
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:679
void litl_write_thread_safety_off(litl_write_trace_t *trace)
Disable thread safety. By default, it is enabled.
Definition: litl_write.c:216
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:645
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:741
A data structure for recording events.
Definition: litl_types.h:304
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:791
litl_write_trace_t * litl_write_init_trace(const uint32_t buf_size)
Initializes the trace buffer.
Definition: litl_write.c:85
A general structure of LiTL event type.
Definition: litl_types.h:190
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:698
void litl_write_tid_recording_off(litl_write_trace_t *trace)
Disable recording tid. By default, it is enabled.
Definition: litl_write.c:230
void litl_write_finalize_trace(litl_write_trace_t *trace)
Finalizes the trace.
Definition: litl_write.c:842
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:496
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:630
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:719
uint8_t litl_data_t
A data type for the optimized storage of parameters.
Definition: litl_types.h:155
litl_types Provides a set of data structures for recording and reading events as well as merging and ...
void litl_write_resume_recording(litl_write_trace_t *trace)
Resumes the event recording.
Definition: litl_write.c:245
uint32_t litl_size_t
An auxiliary data type for storing data.
Definition: litl_types.h:145
void litl_write_set_filename(litl_write_trace_t *trace, char *filename)
Sets a new name for the trace file.
Definition: litl_write.c:253
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:765
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:661
void litl_write_tid_recording_on(litl_write_trace_t *trace)
Enable recording tid.
Definition: litl_write.c:223
void litl_write_buffer_flush_off(litl_write_trace_t *trace)
Disable buffer flush.
Definition: litl_write.c:202
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:597
void litl_write_pause_recording(litl_write_trace_t *trace)
Pauses the event recording.
Definition: litl_write.c:237
uint32_t litl_code_t
A data type for storing events codes.
Definition: litl_types.h:140