litl 0.1.9
Loading...
Searching...
No Matches
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
54litl_write_trace_t* litl_write_init_trace(const uint32_t buf_size);
55
62
69
76
83
89
96
103
110
117void 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
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_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
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_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_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_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_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_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_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_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_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_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_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