litl  0.1.1
 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 
128 
137  litl_param_t param1);
138 
148  litl_param_t param1, litl_param_t param2);
149 
160  litl_param_t param1, litl_param_t param2,
161  litl_param_t param3);
162 
174  litl_param_t param1, litl_param_t param2,
175  litl_param_t param3, litl_param_t param4);
176 
189  litl_param_t param1, litl_param_t param2,
190  litl_param_t param3, litl_param_t param4,
191  litl_param_t param5);
192 
206  litl_param_t param1, litl_param_t param2,
207  litl_param_t param3, litl_param_t param4,
208  litl_param_t param5, litl_param_t param6);
209 
224  litl_param_t param1, litl_param_t param2,
225  litl_param_t param3, litl_param_t param4,
226  litl_param_t param5, litl_param_t param6,
227  litl_param_t param7);
228 
244  litl_param_t param1, litl_param_t param2,
245  litl_param_t param3, litl_param_t param4,
246  litl_param_t param5, litl_param_t param6,
247  litl_param_t param7, litl_param_t param8);
248 
265  litl_param_t param1, litl_param_t param2,
266  litl_param_t param3, litl_param_t param4,
267  litl_param_t param5, litl_param_t param6,
268  litl_param_t param7, litl_param_t param8,
269  litl_param_t param9);
270 
288  litl_param_t param1, litl_param_t param2,
289  litl_param_t param3, litl_param_t param4,
290  litl_param_t param5, litl_param_t param6,
291  litl_param_t param7, litl_param_t param8,
292  litl_param_t param9, litl_param_t param10);
293 
294 /*** Raw events ***/
295 
305  litl_size_t size, litl_data_t data[]);
306 
307 /*** Internal-use macros ***/
308 
319  litl_code_t code, int size);
320 
327 #define __LITL_WRITE_ADD_ARG(ptr, param) do { \
328  typeof(param) _param = param; \
329  memcpy(ptr, &_param, sizeof(_param)); \
330  ptr = ((char*) ptr)+sizeof(_param); \
331  } while(0)
332 
333 /*** Packed events ***/
334 
341 #define litl_write_probe_pack_0(trace, \
342  code) do { \
343  int total_size = LITL_BASE_SIZE; \
344  litl_t* p_evt = __litl_write_get_event(trace, \
345  LITL_TYPE_PACKED, \
346  code, total_size); \
347  if(p_evt){ \
348  p_evt->parameters.packed.size = total_size - LITL_BASE_SIZE; \
349  } \
350  } while(0)
351 
359 #define litl_write_probe_pack_1(trace, \
360  code, \
361  param1) do { \
362  int total_size = LITL_BASE_SIZE + sizeof(param1); \
363  litl_t* p_evt = __litl_write_get_event(trace, \
364  LITL_TYPE_PACKED, \
365  code, \
366  total_size); \
367  if(p_evt){ \
368  p_evt->parameters.packed.size = total_size - LITL_BASE_SIZE; \
369  void* _ptr_ = &p_evt->parameters.packed.param[0]; \
370  __LITL_WRITE_ADD_ARG(_ptr_, param1); \
371  } \
372  } while(0)
373 
382 #define litl_write_probe_pack_2(trace, \
383  code, \
384  param1, \
385  param2) do { \
386  int total_size = LITL_BASE_SIZE + sizeof(param1) + sizeof(param2); \
387  litl_t* p_evt = __litl_write_get_event(trace, \
388  LITL_TYPE_PACKED, \
389  code, \
390  total_size); \
391  if(p_evt){ \
392  p_evt->parameters.packed.size = total_size - LITL_BASE_SIZE; \
393  void* _ptr_ = &p_evt->parameters.packed.param[0]; \
394  __LITL_WRITE_ADD_ARG(_ptr_, param1); \
395  __LITL_WRITE_ADD_ARG(_ptr_, param2); \
396  } \
397  } while(0)
398 
408 #define litl_write_probe_pack_3(trace, \
409  code, \
410  param1, \
411  param2, \
412  param3) do { \
413  int total_size = LITL_BASE_SIZE + sizeof(param1) + sizeof(param2) + \
414  sizeof(param3); \
415  litl_t* p_evt = __litl_write_get_event(trace, \
416  LITL_TYPE_PACKED, \
417  code, \
418  total_size); \
419  if(p_evt){ \
420  p_evt->parameters.packed.size = total_size - LITL_BASE_SIZE; \
421  void* _ptr_ = &p_evt->parameters.packed.param[0]; \
422  __LITL_WRITE_ADD_ARG(_ptr_, param1); \
423  __LITL_WRITE_ADD_ARG(_ptr_, param2); \
424  __LITL_WRITE_ADD_ARG(_ptr_, param3); \
425  } \
426  } while(0)
427 
438 #define litl_write_probe_pack_4(trace, \
439  code, \
440  param1, \
441  param2, \
442  param3, \
443  param4) do { \
444  int total_size = LITL_BASE_SIZE + sizeof(param1) + sizeof(param2) + \
445  sizeof(param3) + sizeof(param4); \
446  litl_t* p_evt = __litl_write_get_event(trace, \
447  LITL_TYPE_PACKED, \
448  code, \
449  total_size); \
450  if(p_evt){ \
451  p_evt->parameters.packed.size = total_size - LITL_BASE_SIZE; \
452  void* _ptr_ = &p_evt->parameters.packed.param[0]; \
453  __LITL_WRITE_ADD_ARG(_ptr_, param1); \
454  __LITL_WRITE_ADD_ARG(_ptr_, param2); \
455  __LITL_WRITE_ADD_ARG(_ptr_, param3); \
456  __LITL_WRITE_ADD_ARG(_ptr_, param4); \
457  } \
458  } while(0)
459 
471 #define litl_write_probe_pack_5(trace, \
472  code, \
473  param1, \
474  param2, \
475  param3, \
476  param4, \
477  param5) do { \
478  int total_size = LITL_BASE_SIZE + sizeof(param1) + sizeof(param2) + \
479  sizeof(param3) + sizeof(param4) +sizeof(param5); \
480  litl_t* p_evt = __litl_write_get_event(trace, \
481  LITL_TYPE_PACKED, \
482  code, \
483  total_size); \
484  if(p_evt){ \
485  p_evt->parameters.packed.size = total_size - LITL_BASE_SIZE; \
486  void* _ptr_ = &p_evt->parameters.packed.param[0]; \
487  __LITL_WRITE_ADD_ARG(_ptr_, param1); \
488  __LITL_WRITE_ADD_ARG(_ptr_, param2); \
489  __LITL_WRITE_ADD_ARG(_ptr_, param3); \
490  __LITL_WRITE_ADD_ARG(_ptr_, param4); \
491  __LITL_WRITE_ADD_ARG(_ptr_, param5); \
492  } \
493  } while(0)
494 
507 #define litl_write_probe_pack_6(trace, \
508  code, \
509  param1, \
510  param2, \
511  param3, \
512  param4, \
513  param5, \
514  param6) do { \
515  int total_size = LITL_BASE_SIZE + sizeof(param1) + sizeof(param2) + \
516  sizeof(param3) + sizeof(param4) + sizeof(param5) + sizeof(param6); \
517  litl_t* p_evt = __litl_write_get_event(trace, \
518  LITL_TYPE_PACKED, \
519  code, \
520  total_size); \
521  if(p_evt){ \
522  p_evt->parameters.packed.size = total_size - LITL_BASE_SIZE; \
523  void* _ptr_ = &p_evt->parameters.packed.param[0]; \
524  __LITL_WRITE_ADD_ARG(_ptr_, param1); \
525  __LITL_WRITE_ADD_ARG(_ptr_, param2); \
526  __LITL_WRITE_ADD_ARG(_ptr_, param3); \
527  __LITL_WRITE_ADD_ARG(_ptr_, param4); \
528  __LITL_WRITE_ADD_ARG(_ptr_, param5); \
529  __LITL_WRITE_ADD_ARG(_ptr_, param6); \
530  } \
531  } while(0)
532 
546 #define litl_write_probe_pack_7(trace, \
547  code, \
548  param1, \
549  param2, \
550  param3, \
551  param4, \
552  param5, \
553  param6, \
554  param7) do { \
555  int total_size = LITL_BASE_SIZE + sizeof(param1) + sizeof(param2) + \
556  sizeof(param3) + sizeof(param4) + sizeof(param5) + sizeof(param6) \
557  + sizeof(param7); \
558  litl_t* p_evt = __litl_write_get_event(trace, \
559  LITL_TYPE_PACKED, \
560  code, \
561  total_size); \
562  if(p_evt){ \
563  p_evt->parameters.packed.size = total_size - LITL_BASE_SIZE; \
564  void* _ptr_ = &p_evt->parameters.packed.param[0]; \
565  __LITL_WRITE_ADD_ARG(_ptr_, param1); \
566  __LITL_WRITE_ADD_ARG(_ptr_, param2); \
567  __LITL_WRITE_ADD_ARG(_ptr_, param3); \
568  __LITL_WRITE_ADD_ARG(_ptr_, param4); \
569  __LITL_WRITE_ADD_ARG(_ptr_, param5); \
570  __LITL_WRITE_ADD_ARG(_ptr_, param6); \
571  __LITL_WRITE_ADD_ARG(_ptr_, param7); \
572  } \
573  } while(0)
574 
589 #define litl_write_probe_pack_8(trace, \
590  code, \
591  param1, \
592  param2, \
593  param3, \
594  param4, \
595  param5, \
596  param6, \
597  param7, \
598  param8) do { \
599  int total_size = LITL_BASE_SIZE + sizeof(param1) + sizeof(param2) + \
600  sizeof(param3) + sizeof(param4) + sizeof(param5) + sizeof(param6) \
601  + sizeof(param7) + sizeof(param8); \
602  litl_t* p_evt = __litl_write_get_event(trace, \
603  LITL_TYPE_PACKED, \
604  code, \
605  total_size); \
606  if(p_evt){ \
607  p_evt->parameters.packed.size = total_size - LITL_BASE_SIZE; \
608  void* _ptr_ = &p_evt->parameters.packed.param[0]; \
609  __LITL_WRITE_ADD_ARG(_ptr_, param1); \
610  __LITL_WRITE_ADD_ARG(_ptr_, param2); \
611  __LITL_WRITE_ADD_ARG(_ptr_, param3); \
612  __LITL_WRITE_ADD_ARG(_ptr_, param4); \
613  __LITL_WRITE_ADD_ARG(_ptr_, param5); \
614  __LITL_WRITE_ADD_ARG(_ptr_, param6); \
615  __LITL_WRITE_ADD_ARG(_ptr_, param7); \
616  __LITL_WRITE_ADD_ARG(_ptr_, param8); \
617  } \
618  } while(0)
619 
635 #define litl_write_probe_pack_9(trace, \
636  code, \
637  param1, \
638  param2, \
639  param3, \
640  param4, \
641  param5, \
642  param6, \
643  param7, \
644  param8, \
645  param9) do { \
646  int total_size = LITL_BASE_SIZE + sizeof(param1) + sizeof(param2) + \
647  sizeof(param3) + sizeof(param4) + sizeof(param5) + sizeof(param6) \
648  + sizeof(param7) + sizeof(param8) + sizeof(param9); \
649  litl_t* p_evt = __litl_write_get_event(trace, \
650  LITL_TYPE_PACKED, \
651  code, \
652  total_size); \
653  if(p_evt){ \
654  p_evt->parameters.packed.size = total_size - LITL_BASE_SIZE; \
655  void* _ptr_ = &p_evt->parameters.packed.param[0]; \
656  __LITL_WRITE_ADD_ARG(_ptr_, param1); \
657  __LITL_WRITE_ADD_ARG(_ptr_, param2); \
658  __LITL_WRITE_ADD_ARG(_ptr_, param3); \
659  __LITL_WRITE_ADD_ARG(_ptr_, param4); \
660  __LITL_WRITE_ADD_ARG(_ptr_, param5); \
661  __LITL_WRITE_ADD_ARG(_ptr_, param6); \
662  __LITL_WRITE_ADD_ARG(_ptr_, param7); \
663  __LITL_WRITE_ADD_ARG(_ptr_, param8); \
664  __LITL_WRITE_ADD_ARG(_ptr_, param9); \
665  } \
666  } while(0)
667 
684 #define litl_write_probe_pack_10(trace, \
685  code, \
686  param1, \
687  param2, \
688  param3, \
689  param4, \
690  param5, \
691  param6, \
692  param7, \
693  param8, \
694  param9, \
695  param10) do { \
696  int total_size = LITL_BASE_SIZE + sizeof(param1) + sizeof(param2) + \
697  sizeof(param3) + sizeof(param4) + sizeof(param5) + sizeof(param6) + \
698  sizeof(param7) + sizeof(param8) + sizeof(param9) + sizeof(param10); \
699  litl_t* p_evt = __litl_write_get_event(trace, \
700  LITL_TYPE_PACKED, \
701  code, \
702  total_size); \
703  if(p_evt){ \
704  p_evt->parameters.packed.size = total_size - LITL_BASE_SIZE; \
705  void* _ptr_ = &p_evt->parameters.packed.param[0]; \
706  __LITL_WRITE_ADD_ARG(_ptr_, param1); \
707  __LITL_WRITE_ADD_ARG(_ptr_, param2); \
708  __LITL_WRITE_ADD_ARG(_ptr_, param3); \
709  __LITL_WRITE_ADD_ARG(_ptr_, param4); \
710  __LITL_WRITE_ADD_ARG(_ptr_, param5); \
711  __LITL_WRITE_ADD_ARG(_ptr_, param6); \
712  __LITL_WRITE_ADD_ARG(_ptr_, param7); \
713  __LITL_WRITE_ADD_ARG(_ptr_, param8); \
714  __LITL_WRITE_ADD_ARG(_ptr_, param9); \
715  __LITL_WRITE_ADD_ARG(_ptr_, param10); \
716  } \
717  } while(0)
718 
725 
726 #endif /* LITL_WRITE_H_ */
void 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:792
void 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:965
litl_type_t
The enumeration of event types.
Definition: litl_types.h:178
void litl_write_probe_reg_0(litl_write_trace_t *trace, litl_code_t code)
Records a regular event without parameters.
Definition: litl_write.c:555
void litl_write_buffer_flush_on(litl_write_trace_t *trace)
Activates buffer flush.
Definition: litl_write.c:194
void 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:716
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)
Activates thread safety.
Definition: litl_write.c:208
void litl_write_thread_safety_off(litl_write_trace_t *trace)
Deactivates thread safety. By default, it is activated.
Definition: litl_write.c:215
void 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:681
A data structure for recording events.
Definition: litl_types.h:304
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
void litl_write_tid_recording_off(litl_write_trace_t *trace)
Deactivates recording tid. By default, it is activated.
Definition: litl_write.c:229
void 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:615
void 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:833
void litl_write_finalize_trace(litl_write_trace_t *trace)
Finalizes the trace.
Definition: litl_write.c:1008
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:495
void 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:584
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_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:647
void litl_write_resume_recording(litl_write_trace_t *trace)
Resumes the event recording.
Definition: litl_write.c:244
void 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:919
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:252
void litl_write_tid_recording_on(litl_write_trace_t *trace)
Activates recording tid.
Definition: litl_write.c:222
void litl_write_buffer_flush_off(litl_write_trace_t *trace)
Deactivates buffer flush. By default, it is activated.
Definition: litl_write.c:201
void litl_write_pause_recording(litl_write_trace_t *trace)
Pauses the event recording.
Definition: litl_write.c:236
void 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:875
void 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:753
uint32_t litl_code_t
A data type for storing events codes.
Definition: litl_types.h:140