micromegas_tracing/event/
block.rs

1use crate::prelude::*;
2
3/// Blocks are a batch of events sent as a unit
4#[derive(Debug)]
5pub struct EventBlock<Q> {
6    pub process_id: uuid::Uuid,
7    pub stream_id: uuid::Uuid,
8    pub begin: DualTime,
9    pub events: Q,
10    pub end: Option<DualTime>,
11    pub event_offset: usize,
12}
13
14impl<Q> EventBlock<Q>
15where
16    Q: micromegas_transit::HeterogeneousQueue,
17{
18    pub fn close(&mut self) {
19        self.end = Some(DualTime::now());
20    }
21}
22
23/// Serialize the dependencies of the events in the primary queue
24pub trait ExtractDeps {
25    type DepsQueue;
26    fn extract(&self) -> Self::DepsQueue;
27}
28
29/// Event blocks must adhere to TracingBlock in order to be managed by the stream
30pub trait TracingBlock {
31    type Queue: ExtractDeps;
32
33    fn new(
34        buffer_size: usize,
35        process_id: uuid::Uuid,
36        stream_id: uuid::Uuid,
37        object_offset: usize,
38    ) -> Self;
39    fn len_bytes(&self) -> usize;
40    fn capacity_bytes(&self) -> usize;
41    fn nb_objects(&self) -> usize;
42    fn object_offset(&self) -> usize;
43    fn events_mut(&mut self) -> &mut Self::Queue;
44    fn hint_max_obj_size(&self) -> usize {
45        // blocks with less than this amount of available memory will be considered full
46        128
47    }
48}
49
50impl<Q> TracingBlock for EventBlock<Q>
51where
52    Q: micromegas_transit::HeterogeneousQueue + ExtractDeps,
53{
54    type Queue = Q;
55    fn new(
56        buffer_size: usize,
57        process_id: uuid::Uuid,
58        stream_id: uuid::Uuid,
59        event_offset: usize,
60    ) -> Self {
61        Self {
62            process_id,
63            stream_id,
64            begin: DualTime::now(),
65            events: Q::new(buffer_size),
66            end: None,
67            event_offset,
68        }
69    }
70
71    fn len_bytes(&self) -> usize {
72        self.events.len_bytes()
73    }
74
75    fn capacity_bytes(&self) -> usize {
76        self.events.capacity_bytes()
77    }
78
79    fn nb_objects(&self) -> usize {
80        self.events.nb_objects()
81    }
82
83    fn object_offset(&self) -> usize {
84        self.event_offset
85    }
86
87    fn events_mut(&mut self) -> &mut Self::Queue {
88        &mut self.events
89    }
90}