micromegas_tracing/logs/
block.rs

1use super::{
2    LogMetadata, LogMetadataRecord, LogStaticStrEvent, LogStaticStrInteropEvent,
3    LogStaticStrInteropEventV2, LogStringEvent, LogStringInteropEvent, TaggedLogInteropEvent,
4    TaggedLogStaticStrEvent, TaggedLogString,
5};
6use crate::{
7    dyn_deps::DynDeps,
8    event::{EventBlock, EventStream, ExtractDeps},
9    property_set::{
10        PropertyDepsQueue, PropertySetDependency, PropertySetId, StringDepsQueue, record_properties,
11    },
12};
13use micromegas_transit::{StaticStringDependency, Utf8StaticStringDependency, prelude::*};
14use rustc_hash::FxHashSet;
15
16declare_queue_struct!(
17    struct LogMsgQueue<
18        LogStaticStrEvent,
19        LogStringEvent,
20        LogStaticStrInteropEvent,
21        LogStaticStrInteropEventV2,
22        LogStringInteropEvent,
23        TaggedLogString,
24        TaggedLogStaticStrEvent,
25        TaggedLogInteropEvent,
26    > {}
27);
28
29declare_queue_struct!(
30    struct LogDepsQueue<
31        Utf8StaticStringDependency,
32        StaticStringDependency,
33        LogMetadataRecord,
34        PropertySetDependency,
35    > {}
36);
37
38fn record_log_event_dependencies(
39    log_desc: &LogMetadata,
40    recorded_deps: &mut FxHashSet<u64>,
41    deps: &mut LogDepsQueue,
42) {
43    let log_ptr = log_desc as *const _ as u64;
44    if recorded_deps.insert(log_ptr) {
45        let name = Utf8StaticStringDependency::from(log_desc.fmt_str);
46        if recorded_deps.insert(name.ptr as u64) {
47            deps.push(name);
48        }
49        let target = Utf8StaticStringDependency::from(log_desc.target);
50        if recorded_deps.insert(target.ptr as u64) {
51            deps.push(target);
52        }
53        let module_path = Utf8StaticStringDependency::from(log_desc.module_path);
54        if recorded_deps.insert(module_path.ptr as u64) {
55            deps.push(module_path);
56        }
57        let file = Utf8StaticStringDependency::from(log_desc.file);
58        if recorded_deps.insert(file.ptr as u64) {
59            deps.push(file);
60        }
61        deps.push(LogMetadataRecord {
62            id: log_ptr,
63            level: log_desc.level as u32,
64            fmt_str: log_desc.fmt_str.as_ptr(),
65            target: log_desc.target.as_ptr(),
66            module_path: log_desc.module_path.as_ptr(),
67            file: log_desc.file.as_ptr(),
68            line: log_desc.line,
69        });
70    }
71}
72
73impl ExtractDeps for LogMsgQueue {
74    type DepsQueue = LogDepsQueue;
75
76    fn extract(&self, dyn_deps: &DynDeps<Self::DepsQueue>) -> Self::DepsQueue {
77        let mut deps = LogDepsQueue::new(1024 * 1024);
78        let mut recorded_deps = FxHashSet::default();
79        let mut last_desc = 0u64;
80        let mut last_set = PropertySetId(0);
81        for x in self.iter() {
82            match x {
83                LogMsgQueueAny::LogStaticStrEvent(evt) => {
84                    let desc = evt.desc as *const _ as u64;
85                    if desc != last_desc {
86                        last_desc = desc;
87                        record_log_event_dependencies(evt.desc, &mut recorded_deps, &mut deps);
88                    }
89                }
90                LogMsgQueueAny::LogStringEvent(evt) => {
91                    let desc = evt.desc as *const _ as u64;
92                    if desc != last_desc {
93                        last_desc = desc;
94                        record_log_event_dependencies(evt.desc, &mut recorded_deps, &mut deps);
95                    }
96                }
97                LogMsgQueueAny::LogStaticStrInteropEvent(evt) => {
98                    if recorded_deps.insert(evt.target.id()) {
99                        deps.push(Utf8StaticStringDependency::from(&evt.target));
100                    }
101                    if recorded_deps.insert(evt.msg.id()) {
102                        deps.push(Utf8StaticStringDependency::from(&evt.msg));
103                    }
104                }
105                // The target of the interop events below is in the dynamic queue.
106                LogMsgQueueAny::LogStaticStrInteropEventV2(evt) => {
107                    if recorded_deps.insert(evt.msg.id()) {
108                        deps.push(Utf8StaticStringDependency::from(&evt.msg));
109                    }
110                }
111                LogMsgQueueAny::LogStringInteropEvent(_) => {}
112                LogMsgQueueAny::TaggedLogInteropEvent(evt) => {
113                    if evt.properties != last_set {
114                        last_set = evt.properties;
115                        if let Some(set) = evt.properties.as_interned() {
116                            record_properties(set, &mut recorded_deps, &mut deps);
117                        }
118                    }
119                }
120                LogMsgQueueAny::TaggedLogString(evt) => {
121                    let desc = evt.desc as *const _ as u64;
122                    if desc != last_desc {
123                        last_desc = desc;
124                        record_log_event_dependencies(evt.desc, &mut recorded_deps, &mut deps);
125                    }
126                    if evt.properties != last_set {
127                        last_set = evt.properties;
128                        if let Some(set) = evt.properties.as_interned() {
129                            record_properties(set, &mut recorded_deps, &mut deps);
130                        }
131                    }
132                }
133                LogMsgQueueAny::TaggedLogStaticStrEvent(evt) => {
134                    let desc = evt.desc as *const _ as u64;
135                    if desc != last_desc {
136                        last_desc = desc;
137                        record_log_event_dependencies(evt.desc, &mut recorded_deps, &mut deps);
138                    }
139                    if evt.properties != last_set {
140                        last_set = evt.properties;
141                        if let Some(set) = evt.properties.as_interned() {
142                            record_properties(set, &mut recorded_deps, &mut deps);
143                        }
144                    }
145                }
146            }
147        }
148        dyn_deps.record_static_refs(&mut recorded_deps, &mut deps);
149        deps.extend_from(dyn_deps.queue());
150        deps
151    }
152}
153
154impl StringDepsQueue for LogDepsQueue {
155    fn push_string(&mut self, dep: StaticStringDependency) {
156        self.push(dep);
157    }
158}
159
160impl PropertyDepsQueue for LogDepsQueue {
161    fn push_set(&mut self, dep: PropertySetDependency) {
162        self.push(dep);
163    }
164}
165
166pub type LogBlock = EventBlock<LogMsgQueue>;
167pub type LogStream = EventStream<LogBlock>;
micromegas_tracing/logs/block.rs

micromegas_tracing/logs/
block.rs
