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

split arc extraction into function

Browse Source
This commit is contained in:
SpaceCat-Chan 2022-11-27 14:17:25 +01:00 committed by Lofty
parent 2c1a9d18ed
commit 9b4c6966be
1 changed files with 242 additions and 282 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -1,11 +1,7 @@
use std::{ use std::{collections::HashMap, ptr::NonNull, sync::atomic::AtomicUsize, time::Instant};
collections::HashMap,
ptr::NonNull,
sync::atomic::AtomicUsize, time::Instant,
};
use colored::Colorize; use colored::Colorize;
use indicatif::{ProgressBar, ProgressStyle, ParallelProgressIterator}; use indicatif::{ParallelProgressIterator, ProgressBar, ProgressStyle};
use rayon::prelude::*; use rayon::prelude::*;
#[macro_use] #[macro_use]
@ -25,17 +21,17 @@ pub extern "C" fn npnr_router_awooter(ctx: Option<NonNull<npnr::Context>>) -> bo
}) })
} }
type ArcVec = Vec<((i32, i32), (i32, i32))>; type Arc = ((npnr::WireId, npnr::Loc), (npnr::WireId, npnr::Loc));
fn find_partition_point( fn find_partition_point(
ctx: &npnr::Context, ctx: &npnr::Context,
nets: &npnr::Nets, arcs: &[Arc],
pips: &[npnr::PipId], pips: &[npnr::PipId],
x_start: i32, x_start: i32,
x_finish: i32, x_finish: i32,
y_start: i32, y_start: i32,
y_finish: i32, y_finish: i32,
) -> (i32, i32, ArcVec, ArcVec, ArcVec, ArcVec) { ) -> (i32, i32, Vec<Arc>, Vec<Arc>, Vec<Arc>, Vec<Arc>) {
let mut x = ((x_finish - x_start) / 2) + x_start; let mut x = ((x_finish - x_start) / 2) + x_start;
let mut y = ((y_finish - y_start) / 2) + y_start; let mut y = ((y_finish - y_start) / 2) + y_start;
let mut x_diff = (x_finish - x_start) / 4; let mut x_diff = (x_finish - x_start) / 4;
@ -47,7 +43,7 @@ fn find_partition_point(
let mut nw; let mut nw;
while x_diff != 0 { while x_diff != 0 {
(ne, se, sw, nw) = partition_nets(ctx, nets, pips, x, y); (ne, se, sw, nw) = partition(ctx, arcs, pips, x, y);
let north = ne.len() + nw.len(); let north = ne.len() + nw.len();
let south = se.len() + sw.len(); let south = se.len() + sw.len();
@ -83,7 +79,7 @@ fn find_partition_point(
y_diff >>= 1; y_diff >>= 1;
} }
(ne, se, sw, nw) = partition_nets(ctx, nets, pips, x, y); (ne, se, sw, nw) = partition(ctx, arcs, pips, x, y);
let north = ne.len() + nw.len(); let north = ne.len() + nw.len();
let south = se.len() + sw.len(); let south = se.len() + sw.len();
@ -147,22 +143,22 @@ enum Segment {
} }
// 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(
ctx: &npnr::Context, ctx: &npnr::Context,
nets: &npnr::Nets, arcs: &[Arc],
pips: &[npnr::PipId], pips: &[npnr::PipId],
x: i32, x: i32,
y: i32, y: i32,
) -> (ArcVec, ArcVec, ArcVec, ArcVec) { ) -> (Vec<Arc>, Vec<Arc>, Vec<Arc>, Vec<Arc>) {
let mut pips_n = HashMap::new(); let mut pips_n = HashMap::new();
let mut pips_e = HashMap::new(); let mut pips_e = HashMap::new();
let mut pips_s = HashMap::new(); let mut pips_s = HashMap::new();
let mut pips_w = HashMap::new(); let mut pips_w = HashMap::new();
let mut ne = Vec::new(); let mut ne: Vec<Arc> = Vec::new();
let mut se = Vec::new(); let mut se: Vec<Arc> = Vec::new();
let mut sw = Vec::new(); let mut sw: Vec<Arc> = Vec::new();
let mut nw = Vec::new(); let mut nw: Vec<Arc> = Vec::new();
let mut part_horiz = AtomicUsize::new(0); let mut part_horiz = AtomicUsize::new(0);
let mut part_vert = AtomicUsize::new(0); let mut part_vert = AtomicUsize::new(0);
let mut part_diag = AtomicUsize::new(0); let mut part_diag = AtomicUsize::new(0);
@ -243,7 +239,7 @@ fn partition_nets(
log_info!(" {} are south-bound\n", south.to_string().bold()); log_info!(" {} are south-bound\n", south.to_string().bold());
log_info!(" {} are west-bound\n", west.to_string().bold()); log_info!(" {} are west-bound\n", west.to_string().bold());
let progress = ProgressBar::new(nets.len() as u64); let progress = ProgressBar::new(arcs.len() as u64);
progress.set_style( progress.set_style(
ProgressStyle::with_template("[{elapsed}] [{bar:40.cyan/blue}] {msg}") ProgressStyle::with_template("[{elapsed}] [{bar:40.cyan/blue}] {msg}")
.unwrap() .unwrap()
@ -252,72 +248,16 @@ fn partition_nets(
let mut explored_pips = AtomicUsize::new(0); let mut explored_pips = AtomicUsize::new(0);
let dereffed_nets: Vec<_> = nets let arcs = arcs
.iter()
.map(|(name, net)| (name, unsafe { net.as_mut().unwrap() }))
.collect();
let dereffed_port_refs: HashMap<_, _> = dereffed_nets
.iter()
.filter_map(|(name, _)| nets.users_by_name(**name).map(|a| (*name, a)))
.collect();
let arcs = dereffed_nets
.into_par_iter() .into_par_iter()
.progress_with(progress) .progress_with(progress)
.filter(|(_, net)| !net.is_global()) .flat_map(|&((source_wire, source), (sink_wire, sink_loc))| {
.filter_map(|(name, net)| {
let source = unsafe { net.driver().as_ref().unwrap() };
source.cell().map(|cell| (name, net, cell))
})
.flat_map(|(name, net, source)| {
let source = source.location();
let source_is_north = source.x < x; let source_is_north = source.x < x;
let source_is_east = source.y < y; let source_is_east = source.y < y;
let source_wire = ctx.source_wire(net);
let port_ref = dereffed_port_refs.get(name);
port_ref
.unwrap()
.into_par_iter()
.flat_map(|sink| {
ctx.sink_wires(net, *sink)
.into_par_iter()
.map(move |sink_wire| (sink, sink_wire))
})
.map(|(sink, sink_wire)| {
(
sink,
sink_wire,
&pips_n,
&pips_s,
&pips_e,
&pips_w,
&explored_pips,
&part_horiz,
&part_vert,
&part_diag,
)
})
.flat_map(
move |(
sink,
sink_wire,
pips_n,
pips_s,
pips_e,
pips_w,
explored_pips,
part_horiz,
part_vert,
part_diag,
)| {
let sink_loc = sink.cell().unwrap().location();
let sink_is_north = sink_loc.x < x; let sink_is_north = sink_loc.x < x;
let sink_is_east = sink_loc.y < y; let sink_is_east = sink_loc.y < y;
if source_is_north == sink_is_north && source_is_east == sink_is_east { if source_is_north == sink_is_north && source_is_east == sink_is_east {
let arc = ((source.x, source.y), (sink_loc.x, sink_loc.y)); let arc = ((source_wire, source), (sink_wire, sink_loc));
let seg = match (source_is_north, source_is_east) { let seg = match (source_is_north, source_is_east) {
(true, true) => Segment::Northeast, (true, true) => Segment::Northeast,
(true, false) => Segment::Northwest, (true, false) => Segment::Northwest,
@ -325,8 +265,7 @@ fn partition_nets(
(false, false) => Segment::Southwest, (false, false) => Segment::Southwest,
}; };
vec![(seg, arc)] vec![(seg, arc)]
} else if source_is_north != sink_is_north && source_is_east == sink_is_east } else if source_is_north != sink_is_north && source_is_east == sink_is_east {
{
let middle = (x, (source.y + sink_loc.y) / 2); let middle = (x, (source.y + sink_loc.y) / 2);
let middle = ( let middle = (
middle.0.clamp(1, ctx.grid_dim_x() - 1), middle.0.clamp(1, ctx.grid_dim_x() - 1),
@ -340,23 +279,21 @@ fn partition_nets(
let (selected_pip, pip_uses) = pips let (selected_pip, pip_uses) = pips
.iter() .iter()
.min_by_key(|(pip, uses)| { .min_by_key(|(pip, uses)| {
let src_to_pip = let src_to_pip = ctx.estimate_delay(source_wire, ctx.pip_src_wire(*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 pip_to_snk =
ctx.estimate_delay(ctx.pip_dst_wire(*pip), sink_wire);
let uses = uses.load(std::sync::atomic::Ordering::Acquire); let uses = uses.load(std::sync::atomic::Ordering::Acquire);
(1000.0 * (src_to_pip + ((uses + 1) as f32) * pip_to_snk)) (1000.0 * (src_to_pip + ((uses + 1) as f32) * pip_to_snk)) as u64
as u64
}) })
.unwrap(); .unwrap();
pip_uses.fetch_add(1, std::sync::atomic::Ordering::Release); pip_uses.fetch_add(1, std::sync::atomic::Ordering::Release);
let selected_pip = *selected_pip; let selected_pip = *selected_pip;
explored_pips explored_pips.fetch_add(pips.len(), std::sync::atomic::Ordering::Relaxed);
.fetch_add(pips.len(), std::sync::atomic::Ordering::Relaxed);
let pip_loc = ctx.pip_location(selected_pip); let pip_loc = ctx.pip_location(selected_pip);
let src_to_pip = ((source.x, source.y), (pip_loc.x, pip_loc.y)); let pip_src_wire = ctx.pip_src_wire(selected_pip);
let pip_to_dst = ((pip_loc.x, pip_loc.y), (sink_loc.x, sink_loc.y)); let pip_dst_wire = ctx.pip_dst_wire(selected_pip);
let src_to_pip = ((source_wire, source), (pip_src_wire, pip_loc));
let pip_to_dst = ((pip_dst_wire, pip_loc), (sink_wire, sink_loc));
let (seg1, seg2) = match (source_is_north, source_is_east) { let (seg1, seg2) = match (source_is_north, source_is_east) {
(true, true) => (Segment::Northeast, Segment::Southeast), (true, true) => (Segment::Northeast, Segment::Southeast),
(true, false) => (Segment::Northwest, Segment::Southwest), (true, false) => (Segment::Northwest, Segment::Southwest),
@ -365,8 +302,7 @@ fn partition_nets(
}; };
part_horiz.fetch_add(1, std::sync::atomic::Ordering::Relaxed); part_horiz.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
vec![(seg1, src_to_pip), (seg2, pip_to_dst)] vec![(seg1, src_to_pip), (seg2, pip_to_dst)]
} else if source_is_north == sink_is_north && source_is_east != sink_is_east } else if source_is_north == sink_is_north && source_is_east != sink_is_east {
{
let middle = ((source.x + sink_loc.x) / 2, y); let middle = ((source.x + sink_loc.x) / 2, y);
let middle = ( let middle = (
middle.0.clamp(1, ctx.grid_dim_x() - 1), middle.0.clamp(1, ctx.grid_dim_x() - 1),
@ -380,23 +316,21 @@ fn partition_nets(
let (selected_pip, pip_uses) = pips let (selected_pip, pip_uses) = pips
.iter() .iter()
.min_by_key(|(pip, uses)| { .min_by_key(|(pip, uses)| {
let src_to_pip = let src_to_pip = ctx.estimate_delay(source_wire, ctx.pip_src_wire(*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 pip_to_snk =
ctx.estimate_delay(ctx.pip_dst_wire(*pip), sink_wire);
let uses = uses.load(std::sync::atomic::Ordering::Acquire); let uses = uses.load(std::sync::atomic::Ordering::Acquire);
(1000.0 * (src_to_pip + ((uses + 1) as f32) * pip_to_snk)) (1000.0 * (src_to_pip + ((uses + 1) as f32) * pip_to_snk)) as u64
as u64
}) })
.unwrap(); .unwrap();
pip_uses.fetch_add(1, std::sync::atomic::Ordering::Release); pip_uses.fetch_add(1, std::sync::atomic::Ordering::Release);
let selected_pip = *selected_pip; let selected_pip = *selected_pip;
explored_pips explored_pips.fetch_add(pips.len(), std::sync::atomic::Ordering::Relaxed);
.fetch_add(pips.len(), std::sync::atomic::Ordering::Relaxed);
let pip_loc = ctx.pip_location(selected_pip); let pip_loc = ctx.pip_location(selected_pip);
let src_to_pip = ((source.x, source.y), (pip_loc.x, pip_loc.y)); let pip_src_wire = ctx.pip_src_wire(selected_pip);
let pip_to_dst = ((pip_loc.x, pip_loc.y), (sink_loc.x, sink_loc.y)); let pip_dst_wire = ctx.pip_dst_wire(selected_pip);
let src_to_pip = ((source_wire, source), (pip_src_wire, pip_loc));
let pip_to_dst = ((pip_dst_wire, pip_loc), (sink_wire, sink_loc));
let (seg1, seg2) = match (source_is_north, source_is_east) { let (seg1, seg2) = match (source_is_north, source_is_east) {
(true, true) => (Segment::Northeast, Segment::Northwest), (true, true) => (Segment::Northeast, Segment::Northwest),
(true, false) => (Segment::Northwest, Segment::Northeast), (true, false) => (Segment::Northwest, Segment::Northeast),
@ -419,19 +353,15 @@ fn partition_nets(
let (horiz_pip, pip_uses) = pips let (horiz_pip, pip_uses) = pips
.iter() .iter()
.min_by_key(|(pip, uses)| { .min_by_key(|(pip, uses)| {
let src_to_pip = let src_to_pip = ctx.estimate_delay(source_wire, ctx.pip_src_wire(*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 pip_to_snk =
ctx.estimate_delay(ctx.pip_dst_wire(*pip), sink_wire);
let uses = uses.load(std::sync::atomic::Ordering::Acquire); let uses = uses.load(std::sync::atomic::Ordering::Acquire);
(1000.0 * (src_to_pip + ((uses + 1) as f32) * pip_to_snk)) (1000.0 * (src_to_pip + ((uses + 1) as f32) * pip_to_snk)) as u64
as u64
}) })
.unwrap(); .unwrap();
pip_uses.fetch_add(1, std::sync::atomic::Ordering::Release); pip_uses.fetch_add(1, std::sync::atomic::Ordering::Release);
let horiz_pip = *horiz_pip; let horiz_pip = *horiz_pip;
explored_pips explored_pips.fetch_add(pips.len(), std::sync::atomic::Ordering::Relaxed);
.fetch_add(pips.len(), std::sync::atomic::Ordering::Relaxed);
let middle = (split_line_over_y((source, sink_loc), y), y); let middle = (split_line_over_y((source, sink_loc), y), y);
let middle = ( let middle = (
@ -446,39 +376,37 @@ fn partition_nets(
let (vert_pip, pip_uses) = pips let (vert_pip, pip_uses) = pips
.iter() .iter()
.min_by_key(|(pip, uses)| { .min_by_key(|(pip, uses)| {
let src_to_pip = let src_to_pip = ctx.estimate_delay(source_wire, ctx.pip_src_wire(*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 pip_to_snk =
ctx.estimate_delay(ctx.pip_dst_wire(*pip), sink_wire);
let uses = uses.load(std::sync::atomic::Ordering::Acquire); let uses = uses.load(std::sync::atomic::Ordering::Acquire);
(1000.0 * (src_to_pip + ((uses + 1) as f32) * pip_to_snk)) (1000.0 * (src_to_pip + ((uses + 1) as f32) * pip_to_snk)) as u64
as u64
}) })
.unwrap(); .unwrap();
pip_uses.fetch_add(1, std::sync::atomic::Ordering::Release); pip_uses.fetch_add(1, std::sync::atomic::Ordering::Release);
let vert_pip = *vert_pip; let vert_pip = *vert_pip;
explored_pips explored_pips.fetch_add(pips.len(), std::sync::atomic::Ordering::Relaxed);
.fetch_add(pips.len(), std::sync::atomic::Ordering::Relaxed);
let horiz_loc = ctx.pip_location(horiz_pip); let horiz_loc = ctx.pip_location(horiz_pip);
let horiz_src_wire = ctx.pip_src_wire(horiz_pip);
let horiz_dst_wire = ctx.pip_dst_wire(horiz_pip);
let horiz_is_east = horiz_loc.y < y; let horiz_is_east = horiz_loc.y < y;
let vert_loc = ctx.pip_location(vert_pip); let vert_loc = ctx.pip_location(vert_pip);
let (src_to_mid1, mid1_to_mid2, mid2_to_dst) = let vert_src_wire = ctx.pip_src_wire(vert_pip);
if horiz_is_east == source_is_east { let vert_dst_wire = ctx.pip_dst_wire(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)), ((source_wire, source), (horiz_src_wire, horiz_loc)),
((horiz_loc.x, horiz_loc.y), (vert_loc.x, vert_loc.y)), ((horiz_dst_wire, horiz_loc), (vert_src_wire, vert_loc)),
((vert_loc.x, vert_loc.y), (sink_loc.x, sink_loc.y)), ((vert_dst_wire, vert_loc), (sink_wire, sink_loc)),
) )
} else { } else {
( (
((source.x, source.y), (vert_loc.x, vert_loc.y)), ((source_wire, source), (vert_src_wire, vert_loc)),
((vert_loc.x, vert_loc.y), (horiz_loc.x, horiz_loc.y)), ((vert_dst_wire, vert_loc), (horiz_src_wire, horiz_loc)),
((horiz_loc.x, horiz_loc.y), (sink_loc.x, sink_loc.y)), ((horiz_dst_wire, horiz_loc), (sink_wire, sink_loc)),
) )
}; };
let (seg1, seg2, seg3) = let (seg1, seg2, seg3) = match (source_is_north, source_is_east, horiz_is_east) {
match (source_is_north, source_is_east, horiz_is_east) {
(true, true, true) => { (true, true, true) => {
(Segment::Northeast, Segment::Southeast, Segment::Southwest) (Segment::Northeast, Segment::Southeast, Segment::Southwest)
} }
@ -511,8 +439,6 @@ fn partition_nets(
(seg3, mid2_to_dst), (seg3, mid2_to_dst),
] ]
} }
},
)
}) })
.collect::<Vec<_>>(); .collect::<Vec<_>>();
@ -619,6 +545,31 @@ fn partition_nets(
(ne, se, sw, nw) (ne, se, sw, nw)
} }
fn extract_arcs_from_nets(ctx: &npnr::Context, nets: npnr::Nets) -> Vec<Arc> {
let mut arcs = vec![];
for (name, net) in nets.iter() {
let net = unsafe { net.as_mut().unwrap() };
if net.is_global() {
continue;
}
let port_ref = net.driver();
let port_ref = unsafe { port_ref.as_ref().unwrap() };
if let Some(cell) = port_ref.cell() {
let source = cell.location();
let source_wire = ctx.source_wire(net);
for sink_ref in nets.users_by_name(*name).unwrap().iter() {
let sink = sink_ref.cell().unwrap();
let sink = sink.location();
for sink_wire in ctx.sink_wires(net, *sink_ref) {
arcs.push(((source_wire, source), (sink_wire, sink)))
}
}
}
}
arcs
}
fn route(ctx: &mut npnr::Context) -> bool { fn route(ctx: &mut npnr::Context) -> bool {
log_info!( log_info!(
"{}{}{}{}{}{} from Rust!\n", "{}{}{}{}{}{} from Rust!\n",
@ -714,8 +665,17 @@ fn route(ctx: &mut npnr::Context) -> bool {
let start = Instant::now(); let start = Instant::now();
let (x_part, y_part, ne, se, sw, nw) = let arcs = extract_arcs_from_nets(ctx, nets);
find_partition_point(ctx, &nets, pips, 0, ctx.grid_dim_x(), 0, ctx.grid_dim_y());
let (x_part, y_part, ne, se, sw, nw) = find_partition_point(
ctx,
&arcs[..],
pips,
0,
ctx.grid_dim_x(),
0,
ctx.grid_dim_y(),
);
let time = Instant::now() - start; let time = Instant::now() - start;
@ -726,23 +686,23 @@ fn route(ctx: &mut npnr::Context) -> bool {
let mut invalid_arcs_in_sw = 0; let mut invalid_arcs_in_sw = 0;
let mut invalid_arcs_in_nw = 0; let mut invalid_arcs_in_nw = 0;
for ((source_x, source_y), (sink_x, sink_y)) in ne { for ((_, source), (_, sink)) in ne {
if source_x > x_part || source_y > y_part || sink_x > x_part || sink_y > y_part { if source.x > x_part || source.y > y_part || sink.x > x_part || sink.y > y_part {
invalid_arcs_in_ne += 1; invalid_arcs_in_ne += 1;
} }
} }
for ((source_x, source_y), (sink_x, sink_y)) in se { for ((_, source), (_, sink)) in se {
if source_x < x_part || source_y > y_part || sink_x < x_part || sink_y > y_part { if source.x < x_part || source.y > y_part || sink.x < x_part || sink.y > y_part {
invalid_arcs_in_se += 1; invalid_arcs_in_se += 1;
} }
} }
for ((source_x, source_y), (sink_x, sink_y)) in sw { for ((_, source), (_, sink)) in sw {
if source_x < x_part || source_y < y_part || sink_x < x_part || sink_y < y_part { if source.x < x_part || source.y < y_part || sink.x < x_part || sink.y < y_part {
invalid_arcs_in_sw += 1; invalid_arcs_in_sw += 1;
} }
} }
for ((source_x, source_y), (sink_x, sink_y)) in nw { for ((_, source), (_, sink)) in nw {
if source_x > x_part || source_y < y_part || sink_x > x_part || sink_y < y_part { if source.x > x_part || source.y < y_part || sink.x > x_part || sink.y < y_part {
invalid_arcs_in_nw += 1; invalid_arcs_in_nw += 1;
} }
} }