caiyu/nextpnr
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

awooter: cargo fmt

Browse Source
This commit is contained in:
Lofty 2022-11-26 17:11:18 +00:00
parent f1a4848c0f
commit 2a18fe58c6
1 changed files with 226 additions and 187 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

413
common/route/awooter/rust/src/lib.rs
View File

@ -1,4 +1,8 @@
use std::{collections::HashMap, ptr::NonNull, sync::{atomic::AtomicUsize, Mutex}}; use std::{
collections::HashMap,
ptr::NonNull,
sync::{atomic::AtomicUsize, Mutex},
};
use colored::Colorize; use colored::Colorize;
use indicatif::{ProgressBar, ProgressStyle}; use indicatif::{ProgressBar, ProgressStyle};
@ -113,7 +117,6 @@ fn find_partition_point(
(x, y, ne, se, sw, nw) (x, y, ne, se, sw, nw)
} }
/// finds the y location a line would be split at if you split it at a certain x location /// finds the y location a line would be split at if you split it at a certain x location
/// ///
/// the function assumes the line goes on forever in both directions, and it truncates the actual coordinate /// the function assumes the line goes on forever in both directions, and it truncates the actual coordinate
@ -158,7 +161,6 @@ enum Segment {
Northwest, Northwest,
} }
// A big thank you to @Spacecat-chan for fixing my broken and buggy partition code. // A big thank you to @Spacecat-chan for fixing my broken and buggy partition code.
fn partition_nets( fn partition_nets(
ctx: &npnr::Context, ctx: &npnr::Context,
@ -193,7 +195,7 @@ fn partition_nets(
// wrong direction. // wrong direction.
// //
// Possibly fixed? I need to double-check. // Possibly fixed? I need to double-check.
let mut candidates = 0; let mut candidates = 0;
let mut north = 0; let mut north = 0;
let mut east = 0; let mut east = 0;
@ -214,46 +216,49 @@ fn partition_nets(
if dir.x < 0 { if dir.x < 0 {
north += 1; north += 1;
pips_n pips_n
.entry((loc.x, loc.y)) .entry((loc.x, loc.y))
.and_modify(|pip_list: &mut Vec<(npnr::PipId, Vec<npnr::IdString>)>| { .and_modify(|pip_list: &mut Vec<(npnr::PipId, Vec<npnr::IdString>)>| {
pip_list.push((pip, Vec::new())) pip_list.push((pip, Vec::new()))
}) })
.or_insert_with(|| vec![(pip, Vec::new())]); .or_insert_with(|| vec![(pip, Vec::new())]);
} }
if dir.x > 0 { if dir.x > 0 {
south += 1; south += 1;
pips_s pips_s
.entry((loc.x, loc.y)) .entry((loc.x, loc.y))
.and_modify(|pip_list: &mut Vec<(npnr::PipId, Vec<npnr::IdString>)>| { .and_modify(|pip_list: &mut Vec<(npnr::PipId, Vec<npnr::IdString>)>| {
pip_list.push((pip, Vec::new())) pip_list.push((pip, Vec::new()))
}) })
.or_insert_with(|| vec![(pip, Vec::new())]); .or_insert_with(|| vec![(pip, Vec::new())]);
} }
if dir.y < 0 { if dir.y < 0 {
east += 1; east += 1;
pips_e pips_e
.entry((loc.x, loc.y)) .entry((loc.x, loc.y))
.and_modify(|pip_list: &mut Vec<(npnr::PipId, Vec<npnr::IdString>)>| { .and_modify(|pip_list: &mut Vec<(npnr::PipId, Vec<npnr::IdString>)>| {
pip_list.push((pip, Vec::new())) pip_list.push((pip, Vec::new()))
}) })
.or_insert_with(|| vec![(pip, Vec::new())]); .or_insert_with(|| vec![(pip, Vec::new())]);
} }
if dir.y > 0 { if dir.y > 0 {
west += 1; west += 1;
pips_w pips_w
.entry((loc.x, loc.y)) .entry((loc.x, loc.y))
.and_modify(|pip_list: &mut Vec<(npnr::PipId, Vec<npnr::IdString>)>| { .and_modify(|pip_list: &mut Vec<(npnr::PipId, Vec<npnr::IdString>)>| {
pip_list.push((pip, Vec::new())) pip_list.push((pip, Vec::new()))
}) })
.or_insert_with(|| vec![(pip, Vec::new())]); .or_insert_with(|| vec![(pip, Vec::new())]);
} }
} }
} }
log_info!(" Out of {} candidate pips:\n", candidates.to_string().bold()); log_info!(
" Out of {} candidate pips:\n",
candidates.to_string().bold()
);
log_info!(" {} are north-bound\n", north.to_string().bold()); log_info!(" {} are north-bound\n", north.to_string().bold());
log_info!(" {} are east-bound\n", east.to_string().bold()); log_info!(" {} are east-bound\n", east.to_string().bold());
log_info!(" {} are south-bound\n", south.to_string().bold()); log_info!(" {} are south-bound\n", south.to_string().bold());
@ -304,167 +309,195 @@ fn partition_nets(
// but doing so gives lifetime errors, and you can't describe // but doing so gives lifetime errors, and you can't describe
// lifetimes in a closure, as far as I can tell. // lifetimes in a closure, as far as I can tell.
let arcs = nets.users_by_name(*name).unwrap().iter().flat_map(|sink| { let arcs = nets
let sink = unsafe { sink.as_ref().unwrap() }; .users_by_name(*name)
ctx.sink_wires(net, sink).into_iter().map(move |sink_wire| (sink, sink_wire)) .unwrap()
}).flat_map(|(sink, sink_wire)| { .iter()
let sink_loc = sink.cell().unwrap().location(); .flat_map(|sink| {
let sink_is_north = sink_loc.x < x; let sink = unsafe { sink.as_ref().unwrap() };
let sink_is_east = sink_loc.y < y; ctx.sink_wires(net, sink)
if source_is_north == sink_is_north && source_is_east == sink_is_east { .into_iter()
let arc = ((source.x, source.y), (sink_loc.x, sink_loc.y)); .map(move |sink_wire| (sink, sink_wire))
let seg = match (source_is_north, source_is_east) { })
(true, true) => Segment::Northeast, .flat_map(|(sink, sink_wire)| {
(true, false) => Segment::Northwest, let sink_loc = sink.cell().unwrap().location();
(false, true) => Segment::Southeast, let sink_is_north = sink_loc.x < x;
(false, false) => Segment::Southwest, let sink_is_east = sink_loc.y < y;
}; if source_is_north == sink_is_north && source_is_east == sink_is_east {
vec![(seg, arc)] let arc = ((source.x, source.y), (sink_loc.x, sink_loc.y));
} else if source_is_north != sink_is_north && source_is_east == sink_is_east { let seg = match (source_is_north, source_is_east) {
let middle = (x, (source.y + sink_loc.y) / 2); (true, true) => Segment::Northeast,
let mut pips_s = pips_s.lock().unwrap(); (true, false) => Segment::Northwest,
let mut pips_n = pips_n.lock().unwrap(); (false, true) => Segment::Southeast,
let pips = match source_is_north { (false, false) => Segment::Southwest,
true => pips_s.get_mut(&middle).unwrap(),
false => pips_n.get_mut(&middle).unwrap(),
};
let (selected_pip, pip_uses) = pips
.iter_mut()
.min_by_key(|(pip, uses)| {
let src_to_pip =
ctx.estimate_delay(source_wire, ctx.pip_src_wire(*pip));
let pip_to_snk = ctx.estimate_delay(ctx.pip_dst_wire(*pip), sink_wire);
let uses = uses.len() - (uses.contains(name) as usize);
(1000.0 * (src_to_pip + ((uses + 1) as f32) * pip_to_snk)) as u64
})
.unwrap();
pip_uses.push(*name);
let selected_pip = *selected_pip;
explored_pips.fetch_add(pips.len(), std::sync::atomic::Ordering::SeqCst);
explored_pips.fetch_add(pips.len(), std::sync::atomic::Ordering::SeqCst);
let pip_loc = ctx.pip_location(selected_pip);
let src_to_pip = ((source.x, source.y), (pip_loc.x, pip_loc.y));
let pip_to_dst = ((pip_loc.x, pip_loc.y), (sink_loc.x, sink_loc.y));
let (seg1, seg2) = match (source_is_north, source_is_east) {
(true, true) => (Segment::Northeast, Segment::Southeast),
(true, false) => (Segment::Northwest, Segment::Southwest),
(false, true) => (Segment::Southeast, Segment::Northeast),
(false, false) => (Segment::Southwest, Segment::Northwest),
};
part_horiz.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
vec![(seg1, src_to_pip), (seg2, pip_to_dst)]
} else if source_is_north == sink_is_north && source_is_east != sink_is_east {
let middle = ((source.x + sink_loc.x) / 2, y);
let mut pips_e = pips_e.lock().unwrap();
let mut pips_w = pips_w.lock().unwrap();
let pips = match source_is_east {
true => pips_w.get_mut(&middle).unwrap(),
false => pips_e.get_mut(&middle).unwrap(),
};
let (selected_pip, pip_uses) = pips
.iter_mut()
.min_by_key(|(pip, uses)| {
let src_to_pip =
ctx.estimate_delay(source_wire, ctx.pip_src_wire(*pip));
let pip_to_snk = ctx.estimate_delay(ctx.pip_dst_wire(*pip), sink_wire);
let uses = uses.len() - (uses.contains(name) as usize);
(1000.0 * (src_to_pip + ((uses + 1) as f32) * pip_to_snk)) as u64
})
.unwrap();
pip_uses.push(*name);
let selected_pip = *selected_pip;
explored_pips.fetch_add(pips.len(), std::sync::atomic::Ordering::SeqCst);
let pip_loc = ctx.pip_location(selected_pip);
let src_to_pip = ((source.x, source.y), (pip_loc.x, pip_loc.y));
let pip_to_dst = ((pip_loc.x, pip_loc.y), (sink_loc.x, sink_loc.y));
let (seg1, seg2) = match (source_is_north, source_is_east) {
(true, true) => (Segment::Northeast, Segment::Northwest),
(true, false) => (Segment::Northwest, Segment::Northeast),
(false, true) => (Segment::Southeast, Segment::Southwest),
(false, false) => (Segment::Southwest, Segment::Southeast),
};
part_vert.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
vec![(seg1, src_to_pip), (seg2, pip_to_dst)]
} else {
let middle = (x, split_line_over_x((source, sink_loc), x));
let mut pips_e = pips_e.lock().unwrap();
let mut pips_w = pips_w.lock().unwrap();
let pips = match source_is_east {
true => pips_w.get_mut(&middle).unwrap(),
false => pips_e.get_mut(&middle).unwrap(),
};
let (horiz_pip, pip_uses) = pips
.iter_mut()
.min_by_key(|(pip, uses)| {
let src_to_pip =
ctx.estimate_delay(source_wire, ctx.pip_src_wire(*pip));
let pip_to_snk = ctx.estimate_delay(ctx.pip_dst_wire(*pip), sink_wire);
let uses = uses.len() - (uses.contains(name) as usize);
(1000.0 * (src_to_pip + ((uses + 1) as f32) * pip_to_snk)) as u64
})
.unwrap();
pip_uses.push(*name);
let horiz_pip = *horiz_pip;
explored_pips.fetch_add(pips.len(), std::sync::atomic::Ordering::SeqCst);
let middle = (split_line_over_y((source, sink_loc), y), y);
let mut pips_s = pips_s.lock().unwrap();
let mut pips_n = pips_n.lock().unwrap();
let pips = match source_is_north {
true => pips_s.get_mut(&middle).unwrap(),
false => pips_n.get_mut(&middle).unwrap(),
};
let (vert_pip, pip_uses) = pips
.iter_mut()
.min_by_key(|(pip, uses)| {
let src_to_pip =
ctx.estimate_delay(source_wire, ctx.pip_src_wire(*pip));
let pip_to_snk = ctx.estimate_delay(ctx.pip_dst_wire(*pip), sink_wire);
let uses = uses.len() - (uses.contains(name) as usize);
(1000.0 * (src_to_pip + ((uses + 1) as f32) * pip_to_snk)) as u64
})
.unwrap();
pip_uses.push(*name);
let vert_pip = *vert_pip;
explored_pips.fetch_add(pips.len(), std::sync::atomic::Ordering::SeqCst);
let horiz_loc = ctx.pip_location(horiz_pip);
let horiz_is_east = horiz_loc.y < y;
let vert_loc = ctx.pip_location(vert_pip);
let (src_to_mid1, mid1_to_mid2, mid2_to_dst) =
if horiz_is_east == source_is_east {
(
((source.x, source.y), (horiz_loc.x, horiz_loc.y)),
((horiz_loc.x, horiz_loc.y), (vert_loc.x, vert_loc.y)),
((vert_loc.x, vert_loc.y), (sink_loc.x, sink_loc.y)),
)
} else {
(
((source.x, source.y), (vert_loc.x, vert_loc.y)),
((vert_loc.x, vert_loc.y), (horiz_loc.x, horiz_loc.y)),
((horiz_loc.x, horiz_loc.y), (sink_loc.x, sink_loc.y)),
)
}; };
let (seg1, seg2, seg3) = match (source_is_north, source_is_east, horiz_is_east) { vec![(seg, arc)]
(true, true, true) => (Segment::Northeast, Segment::Southeast, Segment::Southwest), } else if source_is_north != sink_is_north && source_is_east == sink_is_east {
(true, true, false) => (Segment::Northeast, Segment::Northwest, Segment::Southwest), let middle = (x, (source.y + sink_loc.y) / 2);
(true, false, true) => (Segment::Northwest, Segment::Northeast, Segment::Southeast), let mut pips_s = pips_s.lock().unwrap();
(true, false, false) => (Segment::Northwest, Segment::Southwest, Segment::Southeast), let mut pips_n = pips_n.lock().unwrap();
(false, true, true) => (Segment::Southeast, Segment::Northeast, Segment::Northwest), let pips = match source_is_north {
(false, true, false) => (Segment::Southeast, Segment::Southwest, Segment::Northwest), true => pips_s.get_mut(&middle).unwrap(),
(false, false, true) => (Segment::Southwest, Segment::Southeast, Segment::Northeast), false => pips_n.get_mut(&middle).unwrap(),
(false, false, false) => (Segment::Southwest, Segment::Northwest, Segment::Northeast), };
};
part_diag.fetch_add(1, std::sync::atomic::Ordering::SeqCst); let (selected_pip, pip_uses) = pips
vec![(seg1, src_to_mid1), (seg2, mid1_to_mid2), (seg3, mid2_to_dst)] .iter_mut()
} .min_by_key(|(pip, uses)| {
}).collect::<Vec<_>>(); let src_to_pip =
ctx.estimate_delay(source_wire, ctx.pip_src_wire(*pip));
let pip_to_snk = ctx.estimate_delay(ctx.pip_dst_wire(*pip), sink_wire);
let uses = uses.len() - (uses.contains(name) as usize);
(1000.0 * (src_to_pip + ((uses + 1) as f32) * pip_to_snk)) as u64
})
.unwrap();
pip_uses.push(*name);
let selected_pip = *selected_pip;
explored_pips.fetch_add(pips.len(), std::sync::atomic::Ordering::SeqCst);
let pip_loc = ctx.pip_location(selected_pip);
let src_to_pip = ((source.x, source.y), (pip_loc.x, pip_loc.y));
let pip_to_dst = ((pip_loc.x, pip_loc.y), (sink_loc.x, sink_loc.y));
let (seg1, seg2) = match (source_is_north, source_is_east) {
(true, true) => (Segment::Northeast, Segment::Southeast),
(true, false) => (Segment::Northwest, Segment::Southwest),
(false, true) => (Segment::Southeast, Segment::Northeast),
(false, false) => (Segment::Southwest, Segment::Northwest),
};
part_horiz.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
vec![(seg1, src_to_pip), (seg2, pip_to_dst)]
} else if source_is_north == sink_is_north && source_is_east != sink_is_east {
let middle = ((source.x + sink_loc.x) / 2, y);
let mut pips_e = pips_e.lock().unwrap();
let mut pips_w = pips_w.lock().unwrap();
let pips = match source_is_east {
true => pips_w.get_mut(&middle).unwrap(),
false => pips_e.get_mut(&middle).unwrap(),
};
let (selected_pip, pip_uses) = pips
.iter_mut()
.min_by_key(|(pip, uses)| {
let src_to_pip =
ctx.estimate_delay(source_wire, ctx.pip_src_wire(*pip));
let pip_to_snk = ctx.estimate_delay(ctx.pip_dst_wire(*pip), sink_wire);
let uses = uses.len() - (uses.contains(name) as usize);
(1000.0 * (src_to_pip + ((uses + 1) as f32) * pip_to_snk)) as u64
})
.unwrap();
pip_uses.push(*name);
let selected_pip = *selected_pip;
explored_pips.fetch_add(pips.len(), std::sync::atomic::Ordering::SeqCst);
let pip_loc = ctx.pip_location(selected_pip);
let src_to_pip = ((source.x, source.y), (pip_loc.x, pip_loc.y));
let pip_to_dst = ((pip_loc.x, pip_loc.y), (sink_loc.x, sink_loc.y));
let (seg1, seg2) = match (source_is_north, source_is_east) {
(true, true) => (Segment::Northeast, Segment::Northwest),
(true, false) => (Segment::Northwest, Segment::Northeast),
(false, true) => (Segment::Southeast, Segment::Southwest),
(false, false) => (Segment::Southwest, Segment::Southeast),
};
part_vert.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
vec![(seg1, src_to_pip), (seg2, pip_to_dst)]
} else {
let middle = (x, split_line_over_x((source, sink_loc), x));
let mut pips_e = pips_e.lock().unwrap();
let mut pips_w = pips_w.lock().unwrap();
let pips = match source_is_east {
true => pips_w.get_mut(&middle).unwrap(),
false => pips_e.get_mut(&middle).unwrap(),
};
let (horiz_pip, pip_uses) = pips
.iter_mut()
.min_by_key(|(pip, uses)| {
let src_to_pip =
ctx.estimate_delay(source_wire, ctx.pip_src_wire(*pip));
let pip_to_snk = ctx.estimate_delay(ctx.pip_dst_wire(*pip), sink_wire);
let uses = uses.len() - (uses.contains(name) as usize);
(1000.0 * (src_to_pip + ((uses + 1) as f32) * pip_to_snk)) as u64
})
.unwrap();
pip_uses.push(*name);
let horiz_pip = *horiz_pip;
explored_pips.fetch_add(pips.len(), std::sync::atomic::Ordering::SeqCst);
let middle = (split_line_over_y((source, sink_loc), y), y);
let mut pips_s = pips_s.lock().unwrap();
let mut pips_n = pips_n.lock().unwrap();
let pips = match source_is_north {
true => pips_s.get_mut(&middle).unwrap(),
false => pips_n.get_mut(&middle).unwrap(),
};
let (vert_pip, pip_uses) = pips
.iter_mut()
.min_by_key(|(pip, uses)| {
let src_to_pip =
ctx.estimate_delay(source_wire, ctx.pip_src_wire(*pip));
let pip_to_snk = ctx.estimate_delay(ctx.pip_dst_wire(*pip), sink_wire);
let uses = uses.len() - (uses.contains(name) as usize);
(1000.0 * (src_to_pip + ((uses + 1) as f32) * pip_to_snk)) as u64
})
.unwrap();
pip_uses.push(*name);
let vert_pip = *vert_pip;
explored_pips.fetch_add(pips.len(), std::sync::atomic::Ordering::SeqCst);
let horiz_loc = ctx.pip_location(horiz_pip);
let horiz_is_east = horiz_loc.y < y;
let vert_loc = ctx.pip_location(vert_pip);
let (src_to_mid1, mid1_to_mid2, mid2_to_dst) =
if horiz_is_east == source_is_east {
(
((source.x, source.y), (horiz_loc.x, horiz_loc.y)),
((horiz_loc.x, horiz_loc.y), (vert_loc.x, vert_loc.y)),
((vert_loc.x, vert_loc.y), (sink_loc.x, sink_loc.y)),
)
} else {
(
((source.x, source.y), (vert_loc.x, vert_loc.y)),
((vert_loc.x, vert_loc.y), (horiz_loc.x, horiz_loc.y)),
((horiz_loc.x, horiz_loc.y), (sink_loc.x, sink_loc.y)),
)
};
let (seg1, seg2, seg3) = match (source_is_north, source_is_east, horiz_is_east)
{
(true, true, true) => {
(Segment::Northeast, Segment::Southeast, Segment::Southwest)
}
(true, true, false) => {
(Segment::Northeast, Segment::Northwest, Segment::Southwest)
}
(true, false, true) => {
(Segment::Northwest, Segment::Northeast, Segment::Southeast)
}
(true, false, false) => {
(Segment::Northwest, Segment::Southwest, Segment::Southeast)
}
(false, true, true) => {
(Segment::Southeast, Segment::Northeast, Segment::Northwest)
}
(false, true, false) => {
(Segment::Southeast, Segment::Southwest, Segment::Northwest)
}
(false, false, true) => {
(Segment::Southwest, Segment::Southeast, Segment::Northeast)
}
(false, false, false) => {
(Segment::Southwest, Segment::Northwest, Segment::Northeast)
}
};
part_diag.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
vec![
(seg1, src_to_mid1),
(seg2, mid1_to_mid2),
(seg3, mid2_to_dst),
]
}
})
.collect::<Vec<_>>();
for (segment, arc) in arcs { for (segment, arc) in arcs {
match segment { match segment {
@ -478,7 +511,10 @@ fn partition_nets(
progress.finish_and_clear(); progress.finish_and_clear();
log_info!(" {} pips explored\n", explored_pips.get_mut().to_string().bold()); log_info!(
" {} pips explored\n",
explored_pips.get_mut().to_string().bold()
);
let north = ne.len() + nw.len(); let north = ne.len() + nw.len();
let south = se.len() + sw.len(); let south = se.len() + sw.len();
@ -696,7 +732,10 @@ fn route(ctx: &mut npnr::Context) -> bool {
.into_iter() .into_iter()
.all(|x| x == 0) .all(|x| x == 0)
{ {
log_info!("{}\n", "Found no arcs crossing partition boundaries.".green()); log_info!(
"{}\n",
"Found no arcs crossing partition boundaries.".green()
);
} else { } else {
println!("{}", "found arcs crossing partition boundaries!".yellow()); println!("{}", "found arcs crossing partition boundaries!".yellow());
println!("count in ne: {}", invalid_arcs_in_ne.to_string().bold()); println!("count in ne: {}", invalid_arcs_in_ne.to_string().bold());