noxu-cleaner 7.2.1

Log file garbage collection for Noxu DB
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

//! `LogWriteObserver` implementation backed by a `UtilizationTracker`.
//!
//! Wraps an `Arc<Mutex<UtilizationTracker>>` and implements the
//! `noxu_log::LogWriteObserver` trait so that the `LogManager` can notify
//! it (under the LWL) for every log write.
//!
//! Utilization tracking hooks invoked from the log write path.
//! `countObsoleteNode` calls made from `LogManager.serialLogWork()`.

use std::sync::Arc;

use noxu_log::{
    LogWriteObserver, ObsoleteKind as LogObsoleteKind, ObsoleteLsn,
};
use noxu_sync::Mutex;

use crate::UtilizationTracker;
use crate::utilization_tracker::ObsoleteKind;

/// An `Arc<Mutex<UtilizationTracker>>` wrapper that implements `LogWriteObserver`.
///
/// Install this in the `LogManager` via `set_write_observer()` so that every
/// log write is automatically reflected in the utilization statistics.
pub struct UtilizationTrackerObserver {
    tracker: Arc<Mutex<UtilizationTracker>>,
}

impl UtilizationTrackerObserver {
    /// Wraps an existing tracker.
    pub fn new(tracker: Arc<Mutex<UtilizationTracker>>) -> Self {
        UtilizationTrackerObserver { tracker }
    }

    /// Returns the underlying tracker.
    pub fn tracker(&self) -> &Arc<Mutex<UtilizationTracker>> {
        &self.tracker
    }
}

impl LogWriteObserver for UtilizationTrackerObserver {
    fn count_new_entry(
        &self,
        file_num: u32,
        _offset: u32,
        entry_size: u32,
        is_ln: bool,
        is_in: bool,
        db_id: Option<u32>,
    ) {
        self.tracker.lock().count_new_log_entry_db(
            file_num,
            entry_size as i32,
            is_ln,
            is_in,
            db_id,
        );
    }

    fn count_obsolete(&self, obsolete: ObsoleteLsn) {
        let kind = match obsolete.kind {
            LogObsoleteKind::Exact => ObsoleteKind::Exact,
            LogObsoleteKind::Inexact => ObsoleteKind::Inexact,
            LogObsoleteKind::DupsAllowed => ObsoleteKind::DupsAllowed,
        };
        let file_num = obsolete.lsn.file_number();
        let offset = obsolete.lsn.file_offset();
        let mut tracker = self.tracker.lock();
        match kind {
            ObsoleteKind::Exact => tracker.count_obsolete_node(
                file_num,
                offset,
                obsolete.size,
                obsolete.is_ln,
                obsolete.db_id,
            ),
            ObsoleteKind::Inexact => tracker.count_obsolete_node_inexact(
                file_num,
                offset,
                obsolete.size,
                obsolete.is_ln,
                obsolete.db_id,
            ),
            ObsoleteKind::DupsAllowed => tracker
                .count_obsolete_node_dups_allowed(
                    file_num,
                    offset,
                    obsolete.size,
                    obsolete.is_ln,
                    obsolete.db_id,
                ),
        }
    }
}