oxidd 0.11.0

A safe, concurrent, modular, and performant decision diagram framework.
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

use std::hash::Hash;

use oxidd_core::util::Borrowed;
use oxidd_core::{Manager, ManagerEventSubscriber};

cfg_if::cfg_if! {
    if #[cfg(feature = "apply-cache-direct-mapped")] {
        pub(crate) type ApplyCache<M, O, const ARITY: usize> =
            oxidd_cache::direct::DMApplyCache<M, O, rustc_hash::FxHasher, ARITY>;
    } else {
        pub(crate) type ApplyCache<M, O, const ARITY: usize> = NoApplyCache<M, O, ARITY>;
    }
}

/// Create a new apply cache
///
/// SAFETY: The apply cache must only be used inside a manager that guarantees
/// all node deletions to be wrapped inside a
/// [`oxidd_core::ApplyCache::pre_gc()`] / [`oxidd_core::ApplyCache::post_gc()`]
/// pair.
pub(crate) unsafe fn new_apply_cache<M: Manager, O: Copy + Ord + Hash, const ARITY: usize>(
    capacity: usize,
) -> ApplyCache<M, O, ARITY> {
    cfg_if::cfg_if! {
        if #[cfg(feature = "apply-cache-direct-mapped")] {
            // SAFETY: see above
            unsafe { ApplyCache::with_capacity(capacity) }
        } else {
            let _ = capacity;
            NoApplyCache(std::marker::PhantomData)
        }
    }
}

#[allow(unused)]
pub struct NoApplyCache<M, O, const ARITY: usize>(pub std::marker::PhantomData<(M, O)>);

impl<M: Manager, O: Copy, const ARITY: usize> oxidd_core::util::DropWith<M::Edge>
    for NoApplyCache<M, O, ARITY>
{
    #[inline(always)]
    fn drop_with(self, _drop_edge: impl Fn(M::Edge)) {
        // Nothing to do
    }
}

impl<M: Manager, O, const ARITY: usize> ManagerEventSubscriber<M> for NoApplyCache<M, O, ARITY> {
    fn pre_gc(&self, _manager: &M) {
        // Nothing to do
    }

    unsafe fn post_gc(&self, _manager: &M) {
        // Nothing to do
    }
}

impl<M: Manager, O: Copy, const ARITY: usize> oxidd_core::ApplyCache<M, O>
    for NoApplyCache<M, O, ARITY>
{
    #[inline(always)]
    fn get_with_numeric(
        &self,
        _manager: &M,
        _operator: O,
        _operands: &[Borrowed<M::Edge>],
        _numeric_operands: &[u32],
    ) -> Option<M::Edge> {
        None
    }

    #[inline(always)]
    fn add_with_numeric(
        &self,
        _manager: &M,
        _operator: O,
        _operands: &[Borrowed<M::Edge>],
        _numeric_operands: &[u32],
        _value: Borrowed<M::Edge>,
    ) {
        // Just forget about it
    }

    #[inline(always)]
    fn clear(&self, _manager: &M) {
        // Nothing to do
    }
}