Skip to main content

prjunnamed_netlist/
rewrite.rs

1use std::{
2    borrow::Cow,
3    cell::RefCell,
4    collections::{HashMap, HashSet},
5};
6
7use crate::{design::TopoSortItem, Cell, ControlNet, Design, MetaItemId, ValueBit, Value};
8
9pub enum RewriteResult {
10    None,
11    Cell(Cell),
12    CellMeta(Cell, MetaItemId),
13    Value(Value),
14}
15
16impl From<Value> for RewriteResult {
17    fn from(value: Value) -> Self {
18        RewriteResult::Value(value)
19    }
20}
21
22impl From<ValueBit> for RewriteResult {
23    fn from(net: ValueBit) -> Self {
24        RewriteResult::Value(net.into())
25    }
26}
27
28impl From<ControlNet> for RewriteResult {
29    fn from(cnet: ControlNet) -> Self {
30        match cnet {
31            ControlNet::Pos(net) => RewriteResult::Value(net.into()),
32            ControlNet::Neg(net) => RewriteResult::Cell(Cell::Not(net.into())),
33        }
34    }
35}
36
37impl From<Cell> for RewriteResult {
38    fn from(cell: Cell) -> Self {
39        RewriteResult::Cell(cell)
40    }
41}
42
43pub enum RewriteNetSource<'a> {
44    Opaque,
45    Cell(Cow<'a, Cell>, MetaItemId, usize),
46}
47
48pub trait RewriteRuleset {
49    fn rewrite<'a>(
50        &self,
51        cell: &Cell,
52        meta: MetaItemId,
53        output: Option<&Value>,
54        rewriter: &Rewriter<'a>,
55    ) -> RewriteResult {
56        let _ = (cell, meta, output, rewriter);
57        RewriteResult::None
58    }
59    fn cell_added(&self, design: &Design, cell: &Cell, output: &Value) {
60        let _ = (design, cell, output);
61    }
62    fn net_replaced(&self, design: &Design, from: ValueBit, to: ValueBit) {
63        let _ = (design, from, to);
64    }
65}
66
67pub struct Rewriter<'a> {
68    design: &'a Design,
69    rules: &'a [&'a dyn RewriteRuleset],
70    processed: RefCell<HashSet<ValueBit>>,
71    cache: RefCell<HashMap<Cell, Value>>,
72}
73
74impl<'a> Rewriter<'a> {
75    pub fn find_cell(&self, net: ValueBit) -> RewriteNetSource<'a> {
76        if !self.processed.borrow().contains(&net) && !net.is_const() {
77            return RewriteNetSource::Opaque;
78        }
79        let (cell, meta, bit) = self.design.find_new_cell(net);
80        RewriteNetSource::Cell(cell, meta, bit)
81    }
82
83    fn process_cell(&self, cell: &Cell, meta: MetaItemId, output: Option<&Value>) -> RewriteResult {
84        let mut replacement_cell = None;
85        let mut replacement_meta = None;
86        'outer: loop {
87            for &rule in self.rules {
88                let cur_cell = replacement_cell.as_ref().unwrap_or(cell);
89                let cur_meta = replacement_meta.unwrap_or(meta);
90                let _guard = self.design.use_metadata(cur_meta);
91                match rule.rewrite(cur_cell, cur_meta, output, self) {
92                    RewriteResult::None => (),
93                    RewriteResult::Cell(new_cell) => {
94                        replacement_cell = Some(new_cell);
95                        continue 'outer;
96                    }
97                    RewriteResult::CellMeta(new_cell, new_meta) => {
98                        replacement_cell = Some(new_cell);
99                        replacement_meta = Some(new_meta);
100                        continue 'outer;
101                    }
102                    RewriteResult::Value(value) => {
103                        return RewriteResult::Value(value);
104                    }
105                }
106            }
107            break;
108        }
109        let cell = replacement_cell.as_ref().unwrap_or(cell);
110        if let Some(value) = self.cache.borrow().get(cell) {
111            let meta = replacement_meta.unwrap_or(meta);
112            self.design.append_metadata_by_net(value[0], meta);
113            RewriteResult::Value(value.clone())
114        } else {
115            match (replacement_cell, replacement_meta) {
116                (None, _) => RewriteResult::None,
117                (Some(cell), None) => RewriteResult::Cell(cell),
118                (Some(cell), Some(meta)) => RewriteResult::CellMeta(cell, meta),
119            }
120        }
121    }
122
123    pub fn add_cell(&self, cell: Cell) -> Value {
124        self.add_cell_meta(cell, self.design.get_use_metadata())
125    }
126
127    pub fn add_cell_meta(&self, cell: Cell, meta: MetaItemId) -> Value {
128        self.add_cell_meta_output(cell, meta, None)
129    }
130
131    fn add_cell_meta_output(&self, cell: Cell, meta: MetaItemId, output: Option<&Value>) -> Value {
132        let (cell, meta) = match self.process_cell(&cell, meta, output) {
133            RewriteResult::None => (cell, meta),
134            RewriteResult::Cell(new_cell) => (new_cell, meta),
135            RewriteResult::CellMeta(new_cell, new_meta) => (new_cell, new_meta),
136            RewriteResult::Value(value) => return value,
137        };
138        let value = self.design.add_cell_with_metadata_id(cell.clone(), meta);
139        for &rule in self.rules {
140            rule.cell_added(self.design, &cell, &value);
141        }
142        for net in &value {
143            self.processed.borrow_mut().insert(net);
144        }
145        if !cell.has_effects(self.design) {
146            self.cache.borrow_mut().insert(cell, value.clone());
147        }
148        value
149    }
150
151    pub fn meta_from_merge(&self, iter: impl IntoIterator<Item = MetaItemId>) -> MetaItemId {
152        self.design.meta_from_merge(iter)
153    }
154
155    fn run(&mut self) {
156        let worklist = self.design.topo_sort();
157        for item in worklist {
158            match item {
159                TopoSortItem::Cell(cell_id) => {
160                    let output = self.design.cell_output(cell_id);
161                    let mut cell = self.design.cell(cell_id).into_owned();
162                    cell.visit_mut(|net| *net = self.design.map_net_new(*net));
163                    match self.process_cell(&cell, self.design.cell_metadata(cell_id), Some(&output)) {
164                        RewriteResult::None => {
165                            for &rule in self.rules {
166                                rule.cell_added(self.design, &cell, &output);
167                            }
168                            if !cell.has_effects(self.design) {
169                                self.cache.borrow_mut().insert(cell, output.clone());
170                            }
171                            for net in output {
172                                self.processed.borrow_mut().insert(net);
173                            }
174                        }
175                        RewriteResult::Cell(new_cell) => {
176                            self.design.cell_replace(cell_id, new_cell.clone());
177                            for &rule in self.rules {
178                                rule.cell_added(self.design, &new_cell, &output);
179                            }
180                            if !new_cell.has_effects(self.design) {
181                                self.cache.borrow_mut().insert(new_cell, output.clone());
182                            }
183                            for net in output {
184                                self.processed.borrow_mut().insert(net);
185                            }
186                        }
187                        RewriteResult::CellMeta(new_cell, new_meta) => {
188                            self.design.cell_replace(cell_id, new_cell.clone());
189                            for &rule in self.rules {
190                                rule.cell_added(self.design, &new_cell, &output);
191                            }
192                            self.design.cell_append_metadata(cell_id, new_meta);
193                            if !new_cell.has_effects(self.design) {
194                                self.cache.borrow_mut().insert(new_cell, output.clone());
195                            }
196                            for net in output {
197                                self.processed.borrow_mut().insert(net);
198                            }
199                        }
200                        RewriteResult::Value(value) => {
201                            assert_eq!(value.len(), output.len());
202                            for (net, new_net) in output.iter().zip(value) {
203                                self.design.replace_net(net, new_net);
204                                for &rule in self.rules {
205                                    rule.net_replaced(self.design, net, new_net);
206                                }
207                                self.processed.borrow_mut().insert(net);
208                            }
209                            self.design.cell_unalive(cell_id);
210                        }
211                    }
212                }
213                TopoSortItem::CellBit(cell, bit) => {
214                    let mut slice = self.design.cell(cell).slice(bit..bit + 1).unwrap();
215                    slice.visit_mut(|net| *net = self.design.map_net_new(*net));
216                    let net = self.design.cell_output(cell)[bit];
217                    let new_value =
218                        self.add_cell_meta_output(slice, self.design.cell_metadata(cell), Some(&net.into()));
219                    let new_net = new_value[0];
220                    self.design.replace_net(net, new_net);
221                    for &rule in self.rules {
222                        rule.net_replaced(self.design, net, new_net);
223                    }
224                    self.processed.borrow_mut().insert(net);
225                }
226            }
227        }
228    }
229}
230
231impl Design {
232    pub fn rewrite(&mut self, rules: &[&dyn RewriteRuleset]) {
233        assert!(!self.is_changed());
234        let mut rewriter = Rewriter {
235            design: self,
236            rules,
237            processed: RefCell::new(HashSet::new()),
238            cache: RefCell::new(HashMap::new()),
239        };
240        rewriter.run();
241        self.compact();
242    }
243}