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

Rename Partition -> BelBucket.

Browse Source 
Signed-off-by: Keith Rothman <537074+litghost@users.noreply.github.com>
This commit is contained in:
Keith Rothman 2021-01-29 14:55:10 -08:00
parent 11c80c048b
commit 9fe546f279
17 changed files with 196 additions and 196 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

60
common/archcheck.cc
View File

@ -52,12 +52,12 @@ void archcheck_names(const Context *ctx)
}
}
log_info("Checking partition names..\n");
for(PartitionId partition : ctx->getPartitions()) {
IdString name = ctx->getPartitionName(partition);
PartitionId partition2 = ctx->getPartitionByName(name);
if (partition != partition2) {
log_error("partition != partition2, name = %s\n", name.c_str(ctx));
log_info("Checking bucket names..\n");
for(BelBucketId bucket : ctx->getBelBuckets()) {
IdString name = ctx->getBelBucketName(bucket);
BelBucketId bucket2 = ctx->getBelBucketByName(name);
if (bucket != bucket2) {
log_error("bucket != bucket2, name = %s\n", name.c_str(ctx));
}
}
@ -197,38 +197,38 @@ void archcheck_conn(const Context *ctx)
}
}
void archcheck_partitions(const Context *ctx)
void archcheck_buckets(const Context *ctx)
{
log_info("Checking partition data.\n");
log_info("Checking bucket data.\n");
// Partitions should be subsets of BELs that form an exact cover.
// In particular that means cell types in a partition should only be
// placable in that partition.
for(PartitionId partition : ctx->getPartitions()) {
// BEL buckets should be subsets of BELs that form an exact cover.
// In particular that means cell types in a bucket should only be
// placable in that bucket.
for(BelBucketId bucket : ctx->getBelBuckets()) {
// Find out which cell types are in this partition.
std::unordered_set<IdString> cell_types_in_partition;
// Find out which cell types are in this bucket.
std::unordered_set<IdString> cell_types_in_bucket;
for(IdString cell_type : ctx->getCellTypes()) {
if(ctx->getPartitionForCellType(cell_type) == partition) {
cell_types_in_partition.insert(cell_type);
if(ctx->getBelBucketForCellType(cell_type) == bucket) {
cell_types_in_bucket.insert(cell_type);
}
}
// Make sure that all cell types in this partition have at least one
// Make sure that all cell types in this bucket have at least one
// BelId they can be placed at.
std::unordered_set<IdString> cell_types_unused;
std::unordered_set<BelId> bels_in_partition;
for(BelId bel : ctx->getBelsForPartition(partition)) {
PartitionId partition2 = ctx->getPartitionForBel(bel);
log_assert(partition == partition2);
std::unordered_set<BelId> bels_in_bucket;
for(BelId bel : ctx->getBelsInBucket(bucket)) {
BelBucketId bucket2 = ctx->getBelBucketForBel(bel);
log_assert(bucket == bucket2);
bels_in_partition.insert(bel);
bels_in_bucket.insert(bel);
// Check to see if a cell type not in this partition can be
// placed at a BEL in this partition.
// Check to see if a cell type not in this bucket can be
// placed at a BEL in this bucket.
for(IdString cell_type : ctx->getCellTypes()) {
if(ctx->getPartitionForCellType(cell_type) == partition) {
if(ctx->getBelBucketForCellType(cell_type) == bucket) {
if(ctx->isValidBelForCellType(cell_type, bel)) {
cell_types_unused.erase(cell_type);
}
@ -238,11 +238,11 @@ void archcheck_partitions(const Context *ctx)
}
}
// Verify that any BEL not in this partition reports a different
// partition.
// Verify that any BEL not in this bucket reports a different
// bucket.
for(BelId bel : ctx->getBels()) {
if(ctx->getPartitionForBel(bel) != partition) {
log_assert(bels_in_partition.count(bel) == 0);
if(ctx->getBelBucketForBel(bel) != bucket) {
log_assert(bels_in_bucket.count(bel) == 0);
}
}
@ -262,7 +262,7 @@ void Context::archcheck() const
archcheck_names(this);
archcheck_locs(this);
archcheck_conn(this);
archcheck_partitions(this);
archcheck_buckets(this);
}
NEXTPNR_NAMESPACE_END

12
common/fast_bels.h
View File

@ -83,7 +83,7 @@ struct FastBels {
}
}
void addPartition(PartitionId partition) {
void addBelBucket(BelBucketId partition) {
auto iter = partition_types.find(partition);
if(iter != partition_types.end()) {
// This partition has already been added to the fast BEL lookup.
@ -98,7 +98,7 @@ struct FastBels {
auto &bel_data = fast_bels_by_partition_type.at(type_idx);
for (auto bel : ctx->getBels()) {
if(ctx->getPartitionForBel(bel) != partition) {
if(ctx->getBelBucketForBel(bel) != partition) {
continue;
}
@ -110,7 +110,7 @@ struct FastBels {
continue;
}
if(ctx->getPartitionForBel(bel) != partition) {
if(ctx->getBelBucketForBel(bel) != partition) {
continue;
}
@ -147,10 +147,10 @@ struct FastBels {
return cell_type_data.number_of_possible_bels;
}
size_t getBelsForPartition(PartitionId partition, FastBelsData **data) {
size_t getBelsForBelBucket(BelBucketId partition, FastBelsData **data) {
auto iter = partition_types.find(partition);
if(iter == partition_types.end()) {
addPartition(partition);
addBelBucket(partition);
iter = partition_types.find(partition);
NPNR_ASSERT(iter != partition_types.end());
}
@ -168,7 +168,7 @@ struct FastBels {
std::unordered_map<IdString, TypeData> cell_types;
std::vector<FastBelsData> fast_bels_by_cell_type;
std::unordered_map<PartitionId, TypeData> partition_types;
std::unordered_map<BelBucketId, TypeData> partition_types;
std::vector<FastBelsData> fast_bels_by_partition_type;
};

108
common/placer_heap.cc
View File

@ -177,21 +177,21 @@ class HeAPPlacer
std::vector<std::tuple<CellInfo *, BelId, PlaceStrength>> solution;
std::vector<std::unordered_set<PartitionId>> heap_runs;
std::unordered_set<PartitionId> all_partitions;
std::unordered_map<PartitionId, int> partition_count;
std::vector<std::unordered_set<BelBucketId>> heap_runs;
std::unordered_set<BelBucketId> all_buckets;
std::unordered_map<BelBucketId, int> bucket_count;
for (auto cell : place_cells) {
PartitionId partition = ctx->getPartitionForCellType(cell->type);
if (!all_partitions.count(partition)) {
heap_runs.push_back(std::unordered_set<PartitionId>{partition});
all_partitions.insert(partition);
BelBucketId bucket = ctx->getBelBucketForCellType(cell->type);
if (!all_buckets.count(bucket)) {
heap_runs.push_back(std::unordered_set<BelBucketId>{bucket});
all_buckets.insert(bucket);
}
partition_count[partition]++;
bucket_count[bucket]++;
}
// If more than 98% of cells are one cell type, always solve all at once
// Otherwise, follow full HeAP strategy of rotate&all
for (auto &c : partition_count) {
for (auto &c : bucket_count) {
if (c.second >= 0.98 * int(place_cells.size())) {
heap_runs.clear();
break;
@ -205,7 +205,7 @@ class HeAPPlacer
heap_runs.clear();
}
heap_runs.push_back(all_partitions);
heap_runs.push_back(all_buckets);
// The main HeAP placer loop
log_info("Running main analytical placer.\n");
while (stalled < 5 && (solved_hpwl <= legal_hpwl * 0.8)) {
@ -242,7 +242,7 @@ class HeAPPlacer
for (auto type : sorted(run))
if (std::all_of(cfg.cellGroups.begin(), cfg.cellGroups.end(),
[type](const std::unordered_set<PartitionId> &grp) { return !grp.count(type); }))
[type](const std::unordered_set<BelBucketId> &grp) { return !grp.count(type); }))
CutSpreader(this, {type}).run();
update_all_chains();
@ -253,9 +253,9 @@ class HeAPPlacer
legal_hpwl = total_hpwl();
auto run_stopt = std::chrono::high_resolution_clock::now();
IdString partition_name = ctx->getPartitionName(*run.begin());
IdString bucket_name = ctx->getBelBucketName(*run.begin());
log_info(" at iteration #%d, type %s: wirelen solved = %d, spread = %d, legal = %d; time = %.02fs\n",
iter + 1, (run.size() > 1 ? "ALL" : partition_name.c_str(ctx)), int(solved_hpwl),
iter + 1, (run.size() > 1 ? "ALL" : bucket_name.c_str(ctx)), int(solved_hpwl),
int(spread_hpwl), int(legal_hpwl),
std::chrono::duration<double>(run_stopt - run_startt).count());
}
@ -421,19 +421,19 @@ class HeAPPlacer
}
std::unordered_set<IdString> cell_types_in_use;
std::unordered_set<PartitionId> partitions_in_use;
std::unordered_set<BelBucketId> buckets_in_use;
for (auto cell : sorted(ctx->cells)) {
IdString cell_type = cell.second->type;
cell_types_in_use.insert(cell_type);
PartitionId partition = ctx->getPartitionForCellType(cell_type);
partitions_in_use.insert(partition);
BelBucketId bucket = ctx->getBelBucketForCellType(cell_type);
buckets_in_use.insert(bucket);
}
for(auto cell_type : cell_types_in_use) {
fast_bels.addCellType(cell_type);
}
for(auto partition : partitions_in_use) {
fast_bels.addPartition(partition);
for(auto bucket : buckets_in_use) {
fast_bels.addBelBucket(bucket);
}
// Determine bounding boxes of region constraints
@ -576,7 +576,7 @@ class HeAPPlacer
}
// Setup the cells to be solved, returns the number of rows
int setup_solve_cells(std::unordered_set<PartitionId> *partitions = nullptr)
int setup_solve_cells(std::unordered_set<BelBucketId> *buckets = nullptr)
{
int row = 0;
solve_cells.clear();
@ -585,7 +585,7 @@ class HeAPPlacer
cell.second->udata = dont_solve;
// Then update cells to be placed, which excludes cell children
for (auto cell : place_cells) {
if (partitions && !partitions->count(ctx->getPartitionForCellType(cell->type)))
if (buckets && !buckets->count(ctx->getBelBucketForCellType(cell->type)))
continue;
cell->udata = row++;
solve_cells.push_back(cell);
@ -1078,14 +1078,14 @@ class HeAPPlacer
class CutSpreader
{
public:
CutSpreader(HeAPPlacer *p, const std::unordered_set<PartitionId> &partitions) : p(p), ctx(p->ctx), partitions(partitions)
CutSpreader(HeAPPlacer *p, const std::unordered_set<BelBucketId> &buckets) : p(p), ctx(p->ctx), buckets(buckets)
{
// Get fast BELs data for all partitions being Cut/Spread.
// Get fast BELs data for all buckets being Cut/Spread.
size_t idx = 0;
for (PartitionId partition : sorted(partitions)) {
type_index[partition] = idx;
for (BelBucketId bucket : sorted(buckets)) {
type_index[bucket] = idx;
FastBels::FastBelsData *fast_bels;
p->fast_bels.getBelsForPartition(partition, &fast_bels);
p->fast_bels.getBelsForBelBucket(bucket, &fast_bels);
fb.push_back(fast_bels);
++idx;
NPNR_ASSERT(fb.size() == idx);
@ -1170,8 +1170,8 @@ class HeAPPlacer
private:
HeAPPlacer *p;
Context *ctx;
std::unordered_set<PartitionId> partitions;
std::unordered_map<PartitionId, size_t> type_index;
std::unordered_set<BelBucketId> buckets;
std::unordered_map<BelBucketId, size_t> type_index;
std::vector<std::vector<std::vector<int>>> occupancy;
std::vector<std::vector<int>> groups;
std::vector<std::vector<ChainExtent>> chaines;
@ -1194,23 +1194,23 @@ class HeAPPlacer
}
bool is_cell_fixed(const CellInfo & cell) const {
return partitions.count(ctx->getPartitionForCellType(cell.type)) == 0;
return buckets.count(ctx->getBelBucketForCellType(cell.type)) == 0;
}
size_t cell_index(const CellInfo & cell) const {
return type_index.at(ctx->getPartitionForCellType(cell.type));
return type_index.at(ctx->getBelBucketForCellType(cell.type));
}
void init()
{
occupancy.resize(p->max_x + 1,
std::vector<std::vector<int>>(p->max_y + 1, std::vector<int>(partitions.size(), 0)));
std::vector<std::vector<int>>(p->max_y + 1, std::vector<int>(buckets.size(), 0)));
groups.resize(p->max_x + 1, std::vector<int>(p->max_y + 1, -1));
chaines.resize(p->max_x + 1, std::vector<ChainExtent>(p->max_y + 1));
cells_at_location.resize(p->max_x + 1, std::vector<std::vector<CellInfo *>>(p->max_y + 1));
for (int x = 0; x <= p->max_x; x++)
for (int y = 0; y <= p->max_y; y++) {
for (int t = 0; t < int(partitions.size()); t++) {
for (int t = 0; t < int(buckets.size()); t++) {
occupancy.at(x).at(y).at(t) = 0;
}
groups.at(x).at(y) = -1;
@ -1292,7 +1292,7 @@ class HeAPPlacer
// log_info("%d %d\n", groups.at(x).at(y), mergee.id);
NPNR_ASSERT(groups.at(x).at(y) == mergee.id);
groups.at(x).at(y) = merged.id;
for (size_t t = 0; t < partitions.size(); t++) {
for (size_t t = 0; t < buckets.size(); t++) {
merged.cells.at(t) += occ_at(x, y, t);
merged.bels.at(t) += bels_at(x, y, t);
}
@ -1317,7 +1317,7 @@ class HeAPPlacer
auto process_location = [&](int x, int y) {
// Merge with any overlapping regions
if (groups.at(x).at(y) == -1) {
for (size_t t = 0; t < partitions.size(); t++) {
for (size_t t = 0; t < buckets.size(); t++) {
r.bels.at(t) += bels_at(x, y, t);
r.cells.at(t) += occ_at(x, y, t);
}
@ -1352,7 +1352,7 @@ class HeAPPlacer
if (groups.at(x).at(y) != -1)
continue;
bool overutilised = false;
for (size_t t = 0; t < partitions.size(); t++) {
for (size_t t = 0; t < buckets.size(); t++) {
if (occ_at(x, y, t) > bels_at(x, y, t)) {
overutilised = true;
break;
@ -1368,7 +1368,7 @@ class HeAPPlacer
reg.id = id;
reg.x0 = reg.x1 = x;
reg.y0 = reg.y1 = y;
for (size_t t = 0; t < partitions.size(); t++) {
for (size_t t = 0; t < buckets.size(); t++) {
reg.bels.push_back(bels_at(x, y, t));
reg.cells.push_back(occ_at(x, y, t));
}
@ -1385,7 +1385,7 @@ class HeAPPlacer
if (reg.x1 < p->max_x) {
bool over_occ_x = false;
for (int y1 = reg.y0; y1 <= reg.y1; y1++) {
for (size_t t = 0; t < partitions.size(); t++) {
for (size_t t = 0; t < buckets.size(); t++) {
if (occ_at(reg.x1 + 1, y1, t) > bels_at(reg.x1 + 1, y1, t)) {
over_occ_x = true;
break;
@ -1401,7 +1401,7 @@ class HeAPPlacer
if (reg.y1 < p->max_y) {
bool over_occ_y = false;
for (int x1 = reg.x0; x1 <= reg.x1; x1++) {
for (size_t t = 0; t < partitions.size(); t++) {
for (size_t t = 0; t < buckets.size(); t++) {
if (occ_at(x1, reg.y1 + 1, t) > bels_at(x1, reg.y1 + 1, t)) {
over_occ_y = true;
break;
@ -1463,12 +1463,12 @@ class HeAPPlacer
}
}
if (!changed) {
for (auto partition : sorted(partitions)) {
for (auto bucket : sorted(buckets)) {
if (reg.cells > reg.bels) {
IdString partition_name = ctx->getPartitionName(partition);
IdString bucket_name = ctx->getBelBucketName(bucket);
log_error("Failed to expand region (%d, %d) |_> (%d, %d) of %d %ss\n", reg.x0, reg.y0,
reg.x1, reg.y1, reg.cells.at(type_index.at(partition)),
partition_name.c_str(ctx));
reg.x1, reg.y1, reg.cells.at(type_index.at(bucket)),
bucket_name.c_str(ctx));
}
}
break;
@ -1490,7 +1490,7 @@ class HeAPPlacer
for (int x = r.x0; x <= r.x1; x++) {
for (int y = r.y0; y <= r.y1; y++) {
std::copy(cal.at(x).at(y).begin(), cal.at(x).at(y).end(), std::back_inserter(cut_cells));
for (size_t t = 0; t < partitions.size(); t++)
for (size_t t = 0; t < buckets.size(); t++)
total_bels += bels_at(x, y, t);
}
}
@ -1543,7 +1543,7 @@ class HeAPPlacer
while (trimmed_l < (dir ? r.y1 : r.x1)) {
bool have_bels = false;
for (int i = dir ? r.x0 : r.y0; i <= (dir ? r.x1 : r.y1); i++) {
for (size_t t = 0; t < partitions.size(); t++) {
for (size_t t = 0; t < buckets.size(); t++) {
if (bels_at(dir ? i : trimmed_l, dir ? trimmed_l : i, t) > 0) {
have_bels = true;
break;
@ -1559,7 +1559,7 @@ class HeAPPlacer
while (trimmed_r > (dir ? r.y0 : r.x0)) {
bool have_bels = false;
for (int i = dir ? r.x0 : r.y0; i <= (dir ? r.x1 : r.y1); i++) {
for (size_t t = 0; t < partitions.size(); t++) {
for (size_t t = 0; t < buckets.size(); t++) {
if (bels_at(dir ? i : trimmed_r, dir ? trimmed_r : i, t) > 0) {
have_bels = true;
break;
@ -1577,8 +1577,8 @@ class HeAPPlacer
return {};
// Now find the initial target cut that minimises utilisation imbalance, whilst
// meeting the clearance requirements for any large macros
std::vector<int> left_cells_v(partitions.size(), 0), right_cells_v(partitions.size(), 0);
std::vector<int> left_bels_v(partitions.size(), 0), right_bels_v(r.bels);
std::vector<int> left_cells_v(buckets.size(), 0), right_cells_v(buckets.size(), 0);
std::vector<int> left_bels_v(buckets.size(), 0), right_bels_v(r.bels);
for (int i = 0; i <= pivot; i++)
left_cells_v.at(cell_index(*cut_cells.at(i))) +=
p->chain_size.count(cut_cells.at(i)->name) ? p->chain_size.at(cut_cells.at(i)->name) : 1;
@ -1589,15 +1589,15 @@ class HeAPPlacer
int best_tgt_cut = -1;
double best_deltaU = std::numeric_limits<double>::max();
// std::pair<int, int> target_cut_bels;
std::vector<int> slither_bels(partitions.size(), 0);
std::vector<int> slither_bels(buckets.size(), 0);
for (int i = trimmed_l; i <= trimmed_r; i++) {
for (size_t t = 0; t < partitions.size(); t++)
for (size_t t = 0; t < buckets.size(); t++)
slither_bels.at(t) = 0;
for (int j = dir ? r.x0 : r.y0; j <= (dir ? r.x1 : r.y1); j++) {
for (size_t t = 0; t < partitions.size(); t++)
for (size_t t = 0; t < buckets.size(); t++)
slither_bels.at(t) += dir ? bels_at(j, i, t) : bels_at(i, j, t);
}
for (size_t t = 0; t < partitions.size(); t++) {
for (size_t t = 0; t < buckets.size(); t++) {
left_bels_v.at(t) += slither_bels.at(t);
right_bels_v.at(t) -= slither_bels.at(t);
}
@ -1605,7 +1605,7 @@ class HeAPPlacer
if (((i - trimmed_l) + 1) >= clearance_l && ((trimmed_r - i) + 1) >= clearance_r) {
// Solution is potentially valid
double aU = 0;
for (size_t t = 0; t < partitions.size(); t++)
for (size_t t = 0; t < buckets.size(); t++)
aU += (left_cells_v.at(t) + right_cells_v.at(t)) *
std::abs(double(left_cells_v.at(t)) / double(std::max(left_bels_v.at(t), 1)) -
double(right_cells_v.at(t)) / double(std::max(right_bels_v.at(t), 1)));
@ -1619,19 +1619,19 @@ class HeAPPlacer
return {};
// left_bels = target_cut_bels.first;
// right_bels = target_cut_bels.second;
for (size_t t = 0; t < partitions.size(); t++) {
for (size_t t = 0; t < buckets.size(); t++) {
left_bels_v.at(t) = 0;
right_bels_v.at(t) = 0;
}
for (int x = r.x0; x <= (dir ? r.x1 : best_tgt_cut); x++)
for (int y = r.y0; y <= (dir ? best_tgt_cut : r.y1); y++) {
for (size_t t = 0; t < partitions.size(); t++) {
for (size_t t = 0; t < buckets.size(); t++) {
left_bels_v.at(t) += bels_at(x, y, t);
}
}
for (int x = dir ? r.x0 : (best_tgt_cut + 1); x <= r.x1; x++)
for (int y = dir ? (best_tgt_cut + 1) : r.y0; y <= r.y1; y++) {
for (size_t t = 0; t < partitions.size(); t++) {
for (size_t t = 0; t < buckets.size(); t++) {
right_bels_v.at(t) += bels_at(x, y, t);
}
}

2
common/placer_heap.h
View File

@ -49,7 +49,7 @@ struct PlacerHeapCfg
std::unordered_set<IdString> ioBufTypes;
// These cell types are part of the same unit (e.g. slices split into
// components) so will always be spread together
std::vector<std::unordered_set<PartitionId>> cellGroups;
std::vector<std::unordered_set<BelBucketId>> cellGroups;
};
extern bool placer_heap(Context *ctx, PlacerHeapCfg cfg);

6
ecp5/arch.cc
View File

@ -124,9 +124,9 @@ Arch::Arch(ArchArgs args) : args(args)
for(IdString bel_type : bel_types) {
cell_types.push_back(bel_type);
PartitionId partition;
partition.name = bel_type;
partitions.push_back(partition);
BelBucketId bucket;
bucket.name = bel_type;
buckets.push_back(bucket);
}
}

38
ecp5/arch.h
View File

@ -958,36 +958,36 @@ struct Arch : BaseCtx
return cell_types;
}
std::vector<PartitionId> getPartitions() const {
return partitions;
std::vector<BelBucketId> getBelBuckets() const {
return buckets;
}
IdString getPartitionName(PartitionId partition) const {
return partition.name;
IdString getBelBucketName(BelBucketId bucket) const {
return bucket.name;
}
PartitionId getPartitionByName(IdString name) const {
PartitionId partition;
partition.name = name;
return partition;
BelBucketId getBelBucketByName(IdString name) const {
BelBucketId bucket;
bucket.name = name;
return bucket;
}
PartitionId getPartitionForBel(BelId bel) const {
PartitionId partition;
partition.name = getBelType(bel);
return partition;
BelBucketId getBelBucketForBel(BelId bel) const {
BelBucketId bucket;
bucket.name = getBelType(bel);
return bucket;
}
PartitionId getPartitionForCellType(IdString cell_type) const {
PartitionId partition;
partition.name = cell_type;
return partition;
BelBucketId getBelBucketForCellType(IdString cell_type) const {
BelBucketId bucket;
bucket.name = cell_type;
return bucket;
}
std::vector<BelId> getBelsForPartition(PartitionId partition) const {
std::vector<BelId> getBelsInBucket(BelBucketId bucket) const {
std::vector<BelId> bels;
for(BelId bel : getBels()) {
if(getBelType(bel) == partition.name) {
if(getBelType(bel) == bucket.name) {
bels.push_back(bel);
}
}
@ -1068,7 +1068,7 @@ struct Arch : BaseCtx
static const std::vector<std::string> availableRouters;
std::vector<IdString> cell_types;
std::vector<PartitionId> partitions;
std::vector<BelBucketId> buckets;
};
NEXTPNR_NAMESPACE_END

12
ecp5/archdefs.h
View File

@ -126,12 +126,12 @@ struct PipId
}
};
struct PartitionId {
struct BelBucketId {
IdString name;
bool operator==(const PartitionId &other) const { return (name == other.name); }
bool operator!=(const PartitionId &other) const { return (name != other.name); }
bool operator<(const PartitionId &other) const
bool operator==(const BelBucketId &other) const { return (name == other.name); }
bool operator!=(const BelBucketId &other) const { return (name != other.name); }
bool operator<(const BelBucketId &other) const
{
return name < other.name;
}
@ -273,9 +273,9 @@ template <> struct hash<NEXTPNR_NAMESPACE_PREFIX DecalId>
}
};
template <> struct hash<NEXTPNR_NAMESPACE_PREFIX PartitionId>
template <> struct hash<NEXTPNR_NAMESPACE_PREFIX BelBucketId>
{
std::size_t operator()(const NEXTPNR_NAMESPACE_PREFIX PartitionId &partition) const noexcept
std::size_t operator()(const NEXTPNR_NAMESPACE_PREFIX BelBucketId &partition) const noexcept
{
std::size_t seed = 0;
boost::hash_combine(seed, hash<NEXTPNR_NAMESPACE_PREFIX IdString>()(partition.name));

18
generic/arch.h
View File

@ -281,30 +281,30 @@ struct Arch : BaseCtx
return cell_types;
}
std::vector<PartitionId> getPartitions() const {
std::vector<BelBucketId> getBelBuckets() const {
return getCellTypes();
}
IdString getPartitionName(PartitionId partition) const {
return partition;
IdString getBelBucketName(BelBucketId bucket) const {
return bucket;
}
PartitionId getPartitionByName(IdString partition) const {
return partition;
BelBucketId getBelBucketByName(IdString bucket) const {
return bucket;
}
PartitionId getPartitionForBel(BelId bel) const {
BelBucketId getBelBucketForBel(BelId bel) const {
return getBelType(bel);
}
PartitionId getPartitionForCellType(IdString cell_type) const {
BelBucketId getBelBucketForCellType(IdString cell_type) const {
return cell_type;
}
std::vector<BelId> getBelsForPartition(PartitionId partition) const {
std::vector<BelId> getBelsInBucket(BelBucketId bucket) const {
std::vector<BelId> bels;
for(BelId bel : getBels()) {
if(partition == getPartitionForBel(bel)) {
if(bucket == getBelBucketForBel(bel)) {
bels.push_back(bel);
}
}

2
generic/archdefs.h
View File

@ -51,7 +51,7 @@ typedef IdString WireId;
typedef IdString PipId;
typedef IdString GroupId;
typedef IdString DecalId;
typedef IdString PartitionId;
typedef IdString BelBucketId;
struct ArchNetInfo
{

16
gowin/arch.h
View File

@ -430,30 +430,30 @@ struct Arch : BaseCtx
return cell_types;
}
std::vector<PartitionId> getPartitions() const {
std::vector<BelBucketId> getBelBuckets() const {
return cell_types;
}
IdString getPartitionName(PartitionId partition) const {
return partition;
IdString getBelBucketName(BelBucketId bucket) const {
return bucket;
}
PartitionId getPartitionByName(IdString name) const {
BelBucketId getBelBucketByName(IdString name) const {
return name;
}
PartitionId getPartitionForBel(BelId bel) const {
BelBucketId getBelBucketForBel(BelId bel) const {
return getBelType(bel);
}
PartitionId getPartitionForCellType(IdString cell_type) const {
BelBucketId getBelBucketForCellType(IdString cell_type) const {
return cell_type;
}
std::vector<BelId> getBelsForPartition(PartitionId partition) const {
std::vector<BelId> getBelsInBucket(BelBucketId bucket) const {
std::vector<BelId> bels;
for(BelId bel : getBels()) {
if(getBelType(bel) == partition) {
if(getBelType(bel) == bucket) {
bels.push_back(bel);
}
}

2
gowin/archdefs.h
View File

@ -72,7 +72,7 @@ typedef IdString WireId;
typedef IdString PipId;
typedef IdString GroupId;
typedef IdString DecalId;
typedef IdString PartitionId;
typedef IdString BelBucketId;
struct ArchNetInfo
{

6
ice40/arch.cc
View File

@ -124,9 +124,9 @@ Arch::Arch(ArchArgs args) : args(args)
for(IdString bel_type : bel_types) {
cell_types.push_back(bel_type);
PartitionId partition;
partition.name = bel_type;
partitions.push_back(partition);
BelBucketId bucket;
bucket.name = bel_type;
buckets.push_back(bucket);
}
}

38
ice40/arch.h
View File

@ -830,36 +830,36 @@ struct Arch : BaseCtx
return cell_types;
}
std::vector<PartitionId> getPartitions() const {
return partitions;
std::vector<BelBucketId> getBelBuckets() const {
return buckets;
}
IdString getPartitionName(PartitionId partition) const {
return partition.name;
IdString getBelBucketName(BelBucketId bucket) const {
return bucket.name;
}
PartitionId getPartitionByName(IdString name) const {
PartitionId partition;
partition.name = name;
return partition;
BelBucketId getBelBucketByName(IdString name) const {
BelBucketId bucket;
bucket.name = name;
return bucket;
}
PartitionId getPartitionForBel(BelId bel) const {
PartitionId partition;
partition.name = getBelType(bel);
return partition;
BelBucketId getBelBucketForBel(BelId bel) const {
BelBucketId bucket;
bucket.name = getBelType(bel);
return bucket;
}
PartitionId getPartitionForCellType(IdString cell_type) const {
PartitionId partition;
partition.name = cell_type;
return partition;
BelBucketId getBelBucketForCellType(IdString cell_type) const {
BelBucketId bucket;
bucket.name = cell_type;
return bucket;
}
std::vector<BelId> getBelsForPartition(PartitionId partition) const {
std::vector<BelId> getBelsInBucket(BelBucketId bucket) const {
std::vector<BelId> bels;
for(BelId bel : getBels()) {
if(getBelType(bel) == partition.name) {
if(getBelType(bel) == bucket.name) {
bels.push_back(bel);
}
}
@ -909,7 +909,7 @@ struct Arch : BaseCtx
static const std::vector<std::string> availableRouters;
std::vector<IdString> cell_types;
std::vector<PartitionId> partitions;
std::vector<BelBucketId> buckets;
};
void ice40DelayFuzzerMain(Context *ctx);

14
ice40/archdefs.h
View File

@ -170,12 +170,12 @@ struct ArchCellInfo
};
};
struct PartitionId {
struct BelBucketId {
IdString name;
bool operator==(const PartitionId &other) const { return (name == other.name); }
bool operator!=(const PartitionId &other) const { return (name != other.name); }
bool operator<(const PartitionId &other) const
bool operator==(const BelBucketId &other) const { return (name == other.name); }
bool operator!=(const BelBucketId &other) const { return (name != other.name); }
bool operator<(const BelBucketId &other) const
{
return name < other.name;
}
@ -225,12 +225,12 @@ template <> struct hash<NEXTPNR_NAMESPACE_PREFIX DecalId>
}
};
template <> struct hash<NEXTPNR_NAMESPACE_PREFIX PartitionId>
template <> struct hash<NEXTPNR_NAMESPACE_PREFIX BelBucketId>
{
std::size_t operator()(const NEXTPNR_NAMESPACE_PREFIX PartitionId &partition) const noexcept
std::size_t operator()(const NEXTPNR_NAMESPACE_PREFIX BelBucketId &bucket) const noexcept
{
std::size_t seed = 0;
boost::hash_combine(seed, hash<NEXTPNR_NAMESPACE_PREFIX IdString>()(partition.name));
boost::hash_combine(seed, hash<NEXTPNR_NAMESPACE_PREFIX IdString>()(bucket.name));
return seed;
}
};

6
nexus/arch.cc
View File

@ -180,9 +180,9 @@ Arch::Arch(ArchArgs args) : args(args)
for(IdString bel_type : bel_types) {
cell_types.push_back(bel_type);
PartitionId partition;
partition.name = bel_type;
partitions.push_back(partition);
BelBucketId bucket;
bucket.name = bel_type;
buckets.push_back(bucket);
}
}

38
nexus/arch.h
View File

@ -1344,36 +1344,36 @@ struct Arch : BaseCtx
return cell_types;
}
std::vector<PartitionId> getPartitions() const {
return partitions;
std::vector<BelBucketId> getBelBuckets() const {
return buckets;
}
IdString getPartitionName(PartitionId partition) const {
return partition.name;
IdString getBelBucketName(BelBucketId bucket) const {
return bucket.name;
}
PartitionId getPartitionByName(IdString name) const {
PartitionId partition;
partition.name = name;
return partition;
BelBucketId getBelBucketByName(IdString name) const {
BelBucketId bucket;
bucket.name = name;
return bucket;
}
PartitionId getPartitionForBel(BelId bel) const {
PartitionId partition;
partition.name = getBelType(bel);
return partition;
BelBucketId getBelBucketForBel(BelId bel) const {
BelBucketId bucket;
bucket.name = getBelType(bel);
return bucket;
}
PartitionId getPartitionForCellType(IdString cell_type) const {
PartitionId partition;
partition.name = cell_type;
return partition;
BelBucketId getBelBucketForCellType(IdString cell_type) const {
BelBucketId bucket;
bucket.name = cell_type;
return bucket;
}
std::vector<BelId> getBelsForPartition(PartitionId partition) const {
std::vector<BelId> getBelsInBucket(BelBucketId bucket) const {
std::vector<BelId> bels;
for(BelId bel : getBels()) {
if(getBelType(bel) == partition.name) {
if(getBelType(bel) == bucket.name) {
bels.push_back(bel);
}
}
@ -1583,7 +1583,7 @@ struct Arch : BaseCtx
void write_fasm(std::ostream &out) const;
std::vector<IdString> cell_types;
std::vector<PartitionId> partitions;
std::vector<BelBucketId> buckets;
};
NEXTPNR_NAMESPACE_END

14
nexus/archdefs.h
View File

@ -114,12 +114,12 @@ struct PipId
}
};
struct PartitionId {
struct BelBucketId {
IdString name;
bool operator==(const PartitionId &other) const { return (name == other.name); }
bool operator!=(const PartitionId &other) const { return (name != other.name); }
bool operator<(const PartitionId &other) const
bool operator==(const BelBucketId &other) const { return (name == other.name); }
bool operator!=(const BelBucketId &other) const { return (name != other.name); }
bool operator<(const BelBucketId &other) const
{
return name < other.name;
}
@ -262,12 +262,12 @@ template <> struct hash<NEXTPNR_NAMESPACE_PREFIX DecalId>
}
};
template <> struct hash<NEXTPNR_NAMESPACE_PREFIX PartitionId>
template <> struct hash<NEXTPNR_NAMESPACE_PREFIX BelBucketId>
{
std::size_t operator()(const NEXTPNR_NAMESPACE_PREFIX PartitionId &partition) const noexcept
std::size_t operator()(const NEXTPNR_NAMESPACE_PREFIX BelBucketId &bucket) const noexcept
{
std::size_t seed = 0;
boost::hash_combine(seed, hash<NEXTPNR_NAMESPACE_PREFIX IdString>()(partition.name));
boost::hash_combine(seed, hash<NEXTPNR_NAMESPACE_PREFIX IdString>()(bucket.name));
return seed;
}
};