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

Run "make clangformat".

Browse Source 
Signed-off-by: Keith Rothman <537074+litghost@users.noreply.github.com>
This commit is contained in:
Keith Rothman 2021-02-01 14:28:32 -08:00
parent 01509ec7c9
commit da74a425d2
22 changed files with 174 additions and 210 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
common/arch_pybindings_shared.h
View File

@ -112,17 +112,17 @@ fn_wrapper_2a_v<Context, decltype(&Context::writeSVG), &Context::writeSVG, pass_
pass_through<std::string>>::def_wrap(ctx_cls, "writeSVG");
// const\_range\<BelBucketId\> getBelBuckets() const
fn_wrapper_0a<Context, decltype(&Context::getBelBuckets), &Context::getBelBuckets, wrap_context<BelBucketRange>>::def_wrap(ctx_cls,
"getBelBuckets");
fn_wrapper_0a<Context, decltype(&Context::getBelBuckets), &Context::getBelBuckets,
wrap_context<BelBucketRange>>::def_wrap(ctx_cls, "getBelBuckets");
// BelBucketId getBelBucketForBel(BelId bel) const
fn_wrapper_1a<Context, decltype(&Context::getBelBucketForBel), &Context::getBelBucketForBel, conv_to_str<BelBucketId>,
conv_from_str<BelId>>::def_wrap(ctx_cls, "getBelBucketForBel");
// BelBucketId getBelBucketForCellType(IdString cell\_type) const
fn_wrapper_1a<Context, decltype(&Context::getBelBucketForCellType), &Context::getBelBucketForCellType, conv_to_str<BelBucketId>,
conv_from_str<IdString>>::def_wrap(ctx_cls, "getBelBucketForCellType");
fn_wrapper_1a<Context, decltype(&Context::getBelBucketForCellType), &Context::getBelBucketForCellType,
conv_to_str<BelBucketId>, conv_from_str<IdString>>::def_wrap(ctx_cls, "getBelBucketForCellType");
// const\_range\<BelId\> getBelsInBucket(BelBucketId bucket) const
fn_wrapper_1a<Context, decltype(&Context::getBelsInBucket), &Context::getBelsInBucket, wrap_context<BelRangeForBelBucket>,
conv_from_str<BelBucketId>>::def_wrap(ctx_cls, "getBelsInBucket");
fn_wrapper_1a<Context, decltype(&Context::getBelsInBucket), &Context::getBelsInBucket,
wrap_context<BelRangeForBelBucket>, conv_from_str<BelBucketId>>::def_wrap(ctx_cls, "getBelsInBucket");
// bool isValidBelForCellType(IdString cell\_type, BelId bel) const
fn_wrapper_2a<Context, decltype(&Context::isValidBelForCellType), &Context::isValidBelForCellType, pass_through<bool>,
conv_from_str<IdString>, conv_from_str<BelId>>::def_wrap(ctx_cls, "isValidBelForCellType");

20
common/archcheck.cc
View File

@ -53,7 +53,7 @@ void archcheck_names(const Context *ctx)
}
log_info("Checking bucket names..\n");
for(BelBucketId bucket : ctx->getBelBuckets()) {
for (BelBucketId bucket : ctx->getBelBuckets()) {
IdString name = ctx->getBelBucketName(bucket);
BelBucketId bucket2 = ctx->getBelBucketByName(name);
if (bucket != bucket2) {
@ -204,12 +204,12 @@ void archcheck_buckets(const Context *ctx)
// 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()) {
for (BelBucketId bucket : ctx->getBelBuckets()) {
// 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->getBelBucketForCellType(cell_type) == bucket) {
for (IdString cell_type : ctx->getCellTypes()) {
if (ctx->getBelBucketForCellType(cell_type) == bucket) {
cell_types_in_bucket.insert(cell_type);
}
}
@ -219,7 +219,7 @@ void archcheck_buckets(const Context *ctx)
std::unordered_set<IdString> cell_types_unused;
std::unordered_set<BelId> bels_in_bucket;
for(BelId bel : ctx->getBelsInBucket(bucket)) {
for (BelId bel : ctx->getBelsInBucket(bucket)) {
BelBucketId bucket2 = ctx->getBelBucketForBel(bel);
log_assert(bucket == bucket2);
@ -227,9 +227,9 @@ void archcheck_buckets(const Context *ctx)
// 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->getBelBucketForCellType(cell_type) == bucket) {
if(ctx->isValidBelForCellType(cell_type, bel)) {
for (IdString cell_type : ctx->getCellTypes()) {
if (ctx->getBelBucketForCellType(cell_type) == bucket) {
if (ctx->isValidBelForCellType(cell_type, bel)) {
cell_types_unused.erase(cell_type);
}
} else {
@ -240,8 +240,8 @@ void archcheck_buckets(const Context *ctx)
// Verify that any BEL not in this bucket reports a different
// bucket.
for(BelId bel : ctx->getBels()) {
if(ctx->getBelBucketForBel(bel) != bucket) {
for (BelId bel : ctx->getBels()) {
if (ctx->getBelBucketForBel(bel) != bucket) {
log_assert(bels_in_bucket.count(bel) == 0);
}
}

45
common/fast_bels.h
View File

@ -20,24 +20,30 @@
#pragma once
#include "nextpnr.h"
#include <cstddef>
#include "nextpnr.h"
NEXTPNR_NAMESPACE_BEGIN
// FastBels is a lookup class that provides a fast lookup for finding BELs
// that support a given cell type.
struct FastBels {
struct TypeData {
struct FastBels
{
struct TypeData
{
size_t type_index;
int number_of_possible_bels;
};
FastBels(Context *ctx, bool check_bel_available, int minBelsForGridPick) : ctx(ctx), check_bel_available(check_bel_available), minBelsForGridPick(minBelsForGridPick) {}
FastBels(Context *ctx, bool check_bel_available, int minBelsForGridPick)
: ctx(ctx), check_bel_available(check_bel_available), minBelsForGridPick(minBelsForGridPick)
{
}
void addCellType(IdString cell_type) {
void addCellType(IdString cell_type)
{
auto iter = cell_types.find(cell_type);
if(iter != cell_types.end()) {
if (iter != cell_types.end()) {
// This cell type has already been added to the fast BEL lookup.
return;
}
@ -50,7 +56,7 @@ struct FastBels {
auto &bel_data = fast_bels_by_cell_type.at(type_idx);
for (auto bel : ctx->getBels()) {
if(!ctx->isValidBelForCellType(cell_type, bel)) {
if (!ctx->isValidBelForCellType(cell_type, bel)) {
continue;
}
@ -58,11 +64,11 @@ struct FastBels {
}
for (auto bel : ctx->getBels()) {
if(check_bel_available && !ctx->checkBelAvail(bel)) {
if (check_bel_available && !ctx->checkBelAvail(bel)) {
continue;
}
if(!ctx->isValidBelForCellType(cell_type, bel)) {
if (!ctx->isValidBelForCellType(cell_type, bel)) {
continue;
}
@ -83,9 +89,10 @@ struct FastBels {
}
}
void addBelBucket(BelBucketId partition) {
void addBelBucket(BelBucketId partition)
{
auto iter = partition_types.find(partition);
if(iter != partition_types.end()) {
if (iter != partition_types.end()) {
// This partition has already been added to the fast BEL lookup.
return;
}
@ -98,7 +105,7 @@ struct FastBels {
auto &bel_data = fast_bels_by_partition_type.at(type_idx);
for (auto bel : ctx->getBels()) {
if(ctx->getBelBucketForBel(bel) != partition) {
if (ctx->getBelBucketForBel(bel) != partition) {
continue;
}
@ -106,11 +113,11 @@ struct FastBels {
}
for (auto bel : ctx->getBels()) {
if(check_bel_available && !ctx->checkBelAvail(bel)) {
if (check_bel_available && !ctx->checkBelAvail(bel)) {
continue;
}
if(ctx->getBelBucketForBel(bel) != partition) {
if (ctx->getBelBucketForBel(bel) != partition) {
continue;
}
@ -133,9 +140,10 @@ struct FastBels {
typedef std::vector<std::vector<std::vector<BelId>>> FastBelsData;
int getBelsForCellType(IdString cell_type, FastBelsData **data) {
int getBelsForCellType(IdString cell_type, FastBelsData **data)
{
auto iter = cell_types.find(cell_type);
if(iter == cell_types.end()) {
if (iter == cell_types.end()) {
addCellType(cell_type);
iter = cell_types.find(cell_type);
NPNR_ASSERT(iter != cell_types.end());
@ -147,9 +155,10 @@ struct FastBels {
return cell_type_data.number_of_possible_bels;
}
size_t getBelsForBelBucket(BelBucketId partition, FastBelsData **data) {
size_t getBelsForBelBucket(BelBucketId partition, FastBelsData **data)
{
auto iter = partition_types.find(partition);
if(iter == partition_types.end()) {
if (iter == partition_types.end()) {
addBelBucket(partition);
iter = partition_types.find(partition);
NPNR_ASSERT(iter != partition_types.end());

3
common/place_common.cc
View File

@ -118,7 +118,8 @@ bool place_single_cell(Context *ctx, CellInfo *cell, bool require_legality)
}
IdString targetType = cell->type;
for (auto bel : ctx->getBels()) {
if (ctx->isValidBelForCellType(targetType, bel) && (!require_legality || ctx->isValidBelForCell(cell, bel))) {
if (ctx->isValidBelForCellType(targetType, bel) &&
(!require_legality || ctx->isValidBelForCell(cell, bel))) {
if (ctx->checkBelAvail(bel)) {
wirelen_t wirelen = get_cell_metric_at_bel(ctx, cell, bel, MetricType::COST);
if (iters >= 4)

7
common/placer1.cc
View File

@ -39,11 +39,11 @@
#include <stdlib.h>
#include <string.h>
#include <vector>
#include "fast_bels.h"
#include "log.h"
#include "place_common.h"
#include "timing.h"
#include "util.h"
#include "fast_bels.h"
namespace std {
template <> struct hash<std::pair<NEXTPNR_NAMESPACE_PREFIX IdString, std::size_t>>
@ -76,7 +76,8 @@ class SAPlacer
};
public:
SAPlacer(Context *ctx, Placer1Cfg cfg) : ctx(ctx), fast_bels(ctx, /*check_bel_available=*/false, cfg.minBelsForGridPick), cfg(cfg)
SAPlacer(Context *ctx, Placer1Cfg cfg)
: ctx(ctx), fast_bels(ctx, /*check_bel_available=*/false, cfg.minBelsForGridPick), cfg(cfg)
{
for (auto bel : ctx->getBels()) {
Loc loc = ctx->getBelLocation(bel);
@ -91,7 +92,7 @@ class SAPlacer
cell_types_in_use.insert(cell_type);
}
for(auto cell_type : cell_types_in_use) {
for (auto cell_type : cell_types_in_use) {
fast_bels.addCellType(cell_type);
}

49
common/placer_heap.cc
View File

@ -44,13 +44,13 @@
#include <queue>
#include <tuple>
#include <unordered_map>
#include "fast_bels.h"
#include "log.h"
#include "nextpnr.h"
#include "place_common.h"
#include "placer1.h"
#include "timing.h"
#include "util.h"
#include "fast_bels.h"
NEXTPNR_NAMESPACE_BEGIN
@ -138,7 +138,10 @@ template <typename T> struct EquationSystem
class HeAPPlacer
{
public:
HeAPPlacer(Context *ctx, PlacerHeapCfg cfg) : ctx(ctx), cfg(cfg), fast_bels(ctx, /*check_bel_available=*/true, -1) { Eigen::initParallel(); }
HeAPPlacer(Context *ctx, PlacerHeapCfg cfg) : ctx(ctx), cfg(cfg), fast_bels(ctx, /*check_bel_available=*/true, -1)
{
Eigen::initParallel();
}
bool place()
{
@ -429,10 +432,10 @@ class HeAPPlacer
buckets_in_use.insert(bucket);
}
for(auto cell_type : cell_types_in_use) {
for (auto cell_type : cell_types_in_use) {
fast_bels.addCellType(cell_type);
}
for(auto bucket : buckets_in_use) {
for (auto bucket : buckets_in_use) {
fast_bels.addBelBucket(bucket);
}
@ -500,8 +503,8 @@ class HeAPPlacer
continue;
}
for(auto cell_type : cell_types) {
if(ctx->isValidBelForCellType(cell_type, bel)) {
for (auto cell_type : cell_types) {
if (ctx->isValidBelForCellType(cell_type, bel)) {
available_bels[cell_type].push_back(bel);
}
}
@ -532,23 +535,21 @@ class HeAPPlacer
// all.
if (!available_bels.count(ci->type)) {
log_error("Unable to place cell '%s', no BELs remaining to implement cell type '%s'\n",
ci->name.c_str(ctx),
ci->type.c_str(ctx));
ci->name.c_str(ctx), ci->type.c_str(ctx));
}
// Find an unused BEL from bels_for_cell_type.
auto &bels_for_cell_type = available_bels.at(ci->type);
BelId bel;
while(true) {
while (true) {
if (bels_for_cell_type.empty()) {
log_error("Unable to place cell '%s', no BELs remaining to implement cell type '%s'\n",
ci->name.c_str(ctx),
ci->type.c_str(ctx));
ci->name.c_str(ctx), ci->type.c_str(ctx));
}
BelId candidate_bel = bels_for_cell_type.back();
bels_for_cell_type.pop_back();
if(bels_used.count(candidate_bel)) {
if (bels_used.count(candidate_bel)) {
// candidate_bel has already been used by another
// cell type, skip it.
continue;
@ -1202,13 +1203,12 @@ class HeAPPlacer
return int(fb.at(type)->at(x).at(y).size());
}
bool is_cell_fixed(const CellInfo & cell) const {
bool is_cell_fixed(const CellInfo &cell) const
{
return buckets.count(ctx->getBelBucketForCellType(cell.type)) == 0;
}
size_t cell_index(const CellInfo & cell) const {
return type_index.at(ctx->getBelBucketForCellType(cell.type));
}
size_t cell_index(const CellInfo &cell) const { return type_index.at(ctx->getBelBucketForCellType(cell.type)); }
void init()
{
@ -1239,9 +1239,9 @@ class HeAPPlacer
for (auto &cell_loc : p->cell_locs) {
IdString cell_name = cell_loc.first;
const CellInfo & cell = *ctx->cells.at(cell_name);
const CellLocation & loc = cell_loc.second;
if(is_cell_fixed(cell)) {
const CellInfo &cell = *ctx->cells.at(cell_name);
const CellLocation &loc = cell_loc.second;
if (is_cell_fixed(cell)) {
continue;
}
@ -1261,9 +1261,9 @@ class HeAPPlacer
for (auto &cell_loc : p->cell_locs) {
IdString cell_name = cell_loc.first;
const CellInfo & cell = *ctx->cells.at(cell_name);
const CellLocation & loc = cell_loc.second;
if(is_cell_fixed(cell)) {
const CellInfo &cell = *ctx->cells.at(cell_name);
const CellLocation &loc = cell_loc.second;
if (is_cell_fixed(cell)) {
continue;
}
@ -1285,7 +1285,7 @@ class HeAPPlacer
}
for (auto cell : p->solve_cells) {
if(is_cell_fixed(*cell)) {
if (is_cell_fixed(*cell)) {
continue;
}
@ -1476,8 +1476,7 @@ class HeAPPlacer
if (reg.cells > reg.bels) {
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(bucket)),
bucket_name.c_str(ctx));
reg.x1, reg.y1, reg.cells.at(type_index.at(bucket)), bucket_name.c_str(ctx));
}
}
break;

4
ecp5/arch.cc
View File

@ -117,11 +117,11 @@ Arch::Arch(ArchArgs args) : args(args)
bel_to_cell.resize(chip_info->height * chip_info->width * max_loc_bels, nullptr);
std::unordered_set<IdString> bel_types;
for(BelId bel : getBels()) {
for (BelId bel : getBels()) {
bel_types.insert(getBelType(bel));
}
for(IdString bel_type : bel_types) {
for (IdString bel_type : bel_types) {
cell_types.push_back(bel_type);
BelBucketId bucket;

32
ecp5/arch.h
View File

@ -950,44 +950,40 @@ struct Arch : BaseCtx
// -------------------------------------------------
// Placement validity checks
bool isValidBelForCellType(IdString cell_type, BelId bel) const {
return cell_type == getBelType(bel);
}
bool isValidBelForCellType(IdString cell_type, BelId bel) const { return cell_type == getBelType(bel); }
const std::vector<IdString> &getCellTypes() const {
return cell_types;
}
const std::vector<IdString> &getCellTypes() const { return cell_types; }
std::vector<BelBucketId> getBelBuckets() const {
return buckets;
}
std::vector<BelBucketId> getBelBuckets() const { return buckets; }
IdString getBelBucketName(BelBucketId bucket) const {
return bucket.name;
}
IdString getBelBucketName(BelBucketId bucket) const { return bucket.name; }
BelBucketId getBelBucketByName(IdString name) const {
BelBucketId getBelBucketByName(IdString name) const
{
BelBucketId bucket;
bucket.name = name;
return bucket;
}
BelBucketId getBelBucketForBel(BelId bel) const {
BelBucketId getBelBucketForBel(BelId bel) const
{
BelBucketId bucket;
bucket.name = getBelType(bel);
return bucket;
}
BelBucketId getBelBucketForCellType(IdString cell_type) const {
BelBucketId getBelBucketForCellType(IdString cell_type) const
{
BelBucketId bucket;
bucket.name = cell_type;
return bucket;
}
std::vector<BelId> getBelsInBucket(BelBucketId bucket) const {
std::vector<BelId> getBelsInBucket(BelBucketId bucket) const
{
std::vector<BelId> bels;
for(BelId bel : getBels()) {
if(getBelType(bel) == bucket.name) {
for (BelId bel : getBels()) {
if (getBelType(bel) == bucket.name) {
bels.push_back(bel);
}
}

4
ecp5/arch_pybindings.cc
View File

@ -59,8 +59,8 @@ void arch_wrap_python(py::module &m)
typedef const PipRange UphillPipRange;
typedef const PipRange DownhillPipRange;
typedef const std::vector<BelBucketId> & BelBucketRange;
typedef const std::vector<BelId> & BelRangeForBelBucket;
typedef const std::vector<BelBucketId> &BelBucketRange;
typedef const std::vector<BelId> &BelRangeForBelBucket;
#include "arch_pybindings_shared.h"
WRAP_RANGE(m, Bel, conv_to_str<BelId>);

8
ecp5/archdefs.h
View File

@ -126,15 +126,13 @@ struct PipId
}
};
struct BelBucketId {
struct BelBucketId
{
IdString name;
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;
}
bool operator<(const BelBucketId &other) const { return name < other.name; }
};
struct GroupId

36
generic/arch.h
View File

@ -271,40 +271,32 @@ struct Arch : BaseCtx
bool place();
bool route();
std::vector<IdString> getCellTypes() const {
std::vector<IdString> getCellTypes() const
{
std::vector<IdString> cell_types;
cell_types.reserve(bels.size());
for(auto bel : bels) {
for (auto bel : bels) {
cell_types.push_back(bel.first);
}
return cell_types;
}
std::vector<BelBucketId> getBelBuckets() const {
return getCellTypes();
}
std::vector<BelBucketId> getBelBuckets() const { return getCellTypes(); }
IdString getBelBucketName(BelBucketId bucket) const {
return bucket;
}
IdString getBelBucketName(BelBucketId bucket) const { return bucket; }
BelBucketId getBelBucketByName(IdString bucket) const {
return bucket;
}
BelBucketId getBelBucketByName(IdString bucket) const { return bucket; }
BelBucketId getBelBucketForBel(BelId bel) const {
return getBelType(bel);
}
BelBucketId getBelBucketForBel(BelId bel) const { return getBelType(bel); }
BelBucketId getBelBucketForCellType(IdString cell_type) const {
return cell_type;
}
BelBucketId getBelBucketForCellType(IdString cell_type) const { return cell_type; }
std::vector<BelId> getBelsInBucket(BelBucketId bucket) const {
std::vector<BelId> getBelsInBucket(BelBucketId bucket) const
{
std::vector<BelId> bels;
for(BelId bel : getBels()) {
if(bucket == getBelBucketForBel(bel)) {
for (BelId bel : getBels()) {
if (bucket == getBelBucketForBel(bel)) {
bels.push_back(bel);
}
}
@ -323,9 +315,7 @@ struct Arch : BaseCtx
// Get the TimingClockingInfo of a port
TimingClockingInfo getPortClockingInfo(const CellInfo *cell, IdString port, int index) const;
bool isValidBelForCellType(IdString cell_type, BelId bel) const {
return cell_type == getBelType(bel);
}
bool isValidBelForCellType(IdString cell_type, BelId bel) const { return cell_type == getBelType(bel); }
bool isValidBelForCell(CellInfo *cell, BelId bel) const;
bool isBelLocationValid(BelId bel) const;

28
generic/arch_pybindings.cc
View File

@ -227,30 +227,26 @@ void arch_wrap_python(py::module &m)
"clock"_a, "clktoq"_a);
// const\_range\<BelBucketId\> getBelBuckets() const
fn_wrapper_0a<Context, decltype(&Context::getBelBuckets),
&Context::getBelBuckets,
wrap_context<const std::vector<BelBucketId> &>>::def_wrap(ctx_cls, "getBelBuckets");
fn_wrapper_0a<Context, decltype(&Context::getBelBuckets), &Context::getBelBuckets,
wrap_context<const std::vector<BelBucketId> &>>::def_wrap(ctx_cls, "getBelBuckets");
// BelBucketId getBelBucketForBel(BelId bel) const
fn_wrapper_1a<Context, decltype(&Context::getBelBucketForBel),
&Context::getBelBucketForBel, conv_to_str<BelBucketId>,
conv_from_str<BelId>>::def_wrap(ctx_cls, "getBelBucketForBel");
fn_wrapper_1a<Context, decltype(&Context::getBelBucketForBel), &Context::getBelBucketForBel,
conv_to_str<BelBucketId>, conv_from_str<BelId>>::def_wrap(ctx_cls, "getBelBucketForBel");
// BelBucketId getBelBucketForCellType(IdString cell\_type) const
fn_wrapper_1a<Context, decltype(&Context::getBelBucketForCellType),
&Context::getBelBucketForCellType, conv_to_str<BelBucketId>,
conv_from_str<IdString>>::def_wrap(ctx_cls, "getBelBucketForCellType");
fn_wrapper_1a<Context, decltype(&Context::getBelBucketForCellType), &Context::getBelBucketForCellType,
conv_to_str<BelBucketId>, conv_from_str<IdString>>::def_wrap(ctx_cls, "getBelBucketForCellType");
// const\_range\<BelId\> getBelsInBucket(BelBucketId bucket) const
fn_wrapper_1a<Context, decltype(&Context::getBelsInBucket),
&Context::getBelsInBucket, wrap_context<const std::vector<BelId> &>,
conv_from_str<BelBucketId>>::def_wrap(ctx_cls, "getBelsInBucket");
fn_wrapper_1a<Context, decltype(&Context::getBelsInBucket), &Context::getBelsInBucket,
wrap_context<const std::vector<BelId> &>, conv_from_str<BelBucketId>>::def_wrap(ctx_cls,
"getBelsInBucket");
// bool isValidBelForCellType(IdString cell\_type, BelId bel) const
fn_wrapper_2a<Context, decltype(&Context::isValidBelForCellType),
&Context::isValidBelForCellType, pass_through<bool>,
conv_from_str<IdString>, conv_from_str<BelId>>::def_wrap(
ctx_cls, "isValidBelForCellType");
fn_wrapper_2a<Context, decltype(&Context::isValidBelForCellType), &Context::isValidBelForCellType,
pass_through<bool>, conv_from_str<IdString>, conv_from_str<BelId>>::def_wrap(ctx_cls,
"isValidBelForCellType");
WRAP_MAP_UPTR(m, CellMap, "IdCellMap");
WRAP_MAP_UPTR(m, NetMap, "IdNetMap");

4
gowin/arch.cc
View File

@ -741,11 +741,11 @@ Arch::Arch(ArchArgs args) : args(args)
decal_graphics[IdString()];
std::unordered_set<IdString> bel_types;
for(BelId bel : getBels()) {
for (BelId bel : getBels()) {
bel_types.insert(getBelType(bel));
}
for(IdString bel_type : bel_types) {
for (IdString bel_type : bel_types) {
cell_types.push_back(bel_type);
}
}

35
gowin/arch.h
View File

@ -422,38 +422,25 @@ struct Arch : BaseCtx
// Get the TimingClockingInfo of a port
TimingClockingInfo getPortClockingInfo(const CellInfo *cell, IdString port, int index) const;
bool isValidBelForCellType(IdString cell_type, BelId bel) const {
return cell_type == getBelType(bel);
}
bool isValidBelForCellType(IdString cell_type, BelId bel) const { return cell_type == getBelType(bel); }
const std::vector<IdString> &getCellTypes() const {
return cell_types;
}
const std::vector<IdString> &getCellTypes() const { return cell_types; }
std::vector<BelBucketId> getBelBuckets() const {
return cell_types;
}
std::vector<BelBucketId> getBelBuckets() const { return cell_types; }
IdString getBelBucketName(BelBucketId bucket) const {
return bucket;
}
IdString getBelBucketName(BelBucketId bucket) const { return bucket; }
BelBucketId getBelBucketByName(IdString name) const {
return name;
}
BelBucketId getBelBucketByName(IdString name) const { return name; }
BelBucketId getBelBucketForBel(BelId bel) const {
return getBelType(bel);
}
BelBucketId getBelBucketForBel(BelId bel) const { return getBelType(bel); }
BelBucketId getBelBucketForCellType(IdString cell_type) const {
return cell_type;
}
BelBucketId getBelBucketForCellType(IdString cell_type) const { return cell_type; }
std::vector<BelId> getBelsInBucket(BelBucketId bucket) const {
std::vector<BelId> getBelsInBucket(BelBucketId bucket) const
{
std::vector<BelId> bels;
for(BelId bel : getBels()) {
if(getBelType(bel) == bucket) {
for (BelId bel : getBels()) {
if (getBelType(bel) == bucket) {
bels.push_back(bel);
}
}

4
ice40/arch.cc
View File

@ -117,11 +117,11 @@ Arch::Arch(ArchArgs args) : args(args)
switches_locked.resize(chip_info->num_switches);
std::unordered_set<IdString> bel_types;
for(BelId bel : getBels()) {
for (BelId bel : getBels()) {
bel_types.insert(getBelType(bel));
}
for(IdString bel_type : bel_types) {
for (IdString bel_type : bel_types) {
cell_types.push_back(bel_type);
BelBucketId bucket;

32
ice40/arch.h
View File

@ -822,44 +822,40 @@ struct Arch : BaseCtx
// implemented in arch_place.cc)
// Whether this cell type can be placed at this BEL.
bool isValidBelForCellType(IdString cell_type, BelId bel) const {
return cell_type == getBelType(bel);
}
bool isValidBelForCellType(IdString cell_type, BelId bel) const { return cell_type == getBelType(bel); }
const std::vector<IdString> &getCellTypes() const {
return cell_types;
}
const std::vector<IdString> &getCellTypes() const { return cell_types; }
std::vector<BelBucketId> getBelBuckets() const {
return buckets;
}
std::vector<BelBucketId> getBelBuckets() const { return buckets; }
IdString getBelBucketName(BelBucketId bucket) const {
return bucket.name;
}
IdString getBelBucketName(BelBucketId bucket) const { return bucket.name; }
BelBucketId getBelBucketByName(IdString name) const {
BelBucketId getBelBucketByName(IdString name) const
{
BelBucketId bucket;
bucket.name = name;
return bucket;
}
BelBucketId getBelBucketForBel(BelId bel) const {
BelBucketId getBelBucketForBel(BelId bel) const
{
BelBucketId bucket;
bucket.name = getBelType(bel);
return bucket;
}
BelBucketId getBelBucketForCellType(IdString cell_type) const {
BelBucketId getBelBucketForCellType(IdString cell_type) const
{
BelBucketId bucket;
bucket.name = cell_type;
return bucket;
}
std::vector<BelId> getBelsInBucket(BelBucketId bucket) const {
std::vector<BelId> getBelsInBucket(BelBucketId bucket) const
{
std::vector<BelId> bels;
for(BelId bel : getBels()) {
if(getBelType(bel) == bucket.name) {
for (BelId bel : getBels()) {
if (getBelType(bel) == bucket.name) {
bels.push_back(bel);
}
}

5
ice40/arch_pybindings.cc
View File

@ -75,8 +75,8 @@ void arch_wrap_python(py::module &m)
typedef const PipRange UphillPipRange;
typedef const PipRange DownhillPipRange;
typedef const std::vector<BelBucketId> & BelBucketRange;
typedef const std::vector<BelId> & BelRangeForBelBucket;
typedef const std::vector<BelBucketId> &BelBucketRange;
typedef const std::vector<BelId> &BelRangeForBelBucket;
#include "arch_pybindings_shared.h"
WRAP_RANGE(m, Bel, conv_to_str<BelId>);
@ -85,7 +85,6 @@ void arch_wrap_python(py::module &m)
WRAP_RANGE(m, Pip, conv_to_str<PipId>);
WRAP_RANGE(m, BelPin, wrap_context<BelPin>);
WRAP_MAP_UPTR(m, CellMap, "IdCellMap");
WRAP_MAP_UPTR(m, NetMap, "IdNetMap");
WRAP_MAP(m, HierarchyMap, wrap_context<HierarchicalCell &>, "HierarchyMap");

8
ice40/archdefs.h
View File

@ -170,15 +170,13 @@ struct ArchCellInfo
};
};
struct BelBucketId {
struct BelBucketId
{
IdString name;
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;
}
bool operator<(const BelBucketId &other) const { return name < other.name; }
};
NEXTPNR_NAMESPACE_END

4
nexus/arch.cc
View File

@ -173,11 +173,11 @@ Arch::Arch(ArchArgs args) : args(args)
log_error("Unknown speed grade '%s'.\n", speed.c_str());
std::unordered_set<IdString> bel_types;
for(BelId bel : getBels()) {
for (BelId bel : getBels()) {
bel_types.insert(getBelType(bel));
}
for(IdString bel_type : bel_types) {
for (IdString bel_type : bel_types) {
cell_types.push_back(bel_type);
BelBucketId bucket;

32
nexus/arch.h
View File

@ -1336,44 +1336,40 @@ struct Arch : BaseCtx
// implemented in arch_place.cc)
// Whether this cell type can be placed at this BEL.
bool isValidBelForCellType(IdString cell_type, BelId bel) const {
return cell_type == getBelType(bel);
}
bool isValidBelForCellType(IdString cell_type, BelId bel) const { return cell_type == getBelType(bel); }
const std::vector<IdString> &getCellTypes() const {
return cell_types;
}
const std::vector<IdString> &getCellTypes() const { return cell_types; }
std::vector<BelBucketId> getBelBuckets() const {
return buckets;
}
std::vector<BelBucketId> getBelBuckets() const { return buckets; }
IdString getBelBucketName(BelBucketId bucket) const {
return bucket.name;
}
IdString getBelBucketName(BelBucketId bucket) const { return bucket.name; }
BelBucketId getBelBucketByName(IdString name) const {
BelBucketId getBelBucketByName(IdString name) const
{
BelBucketId bucket;
bucket.name = name;
return bucket;
}
BelBucketId getBelBucketForBel(BelId bel) const {
BelBucketId getBelBucketForBel(BelId bel) const
{
BelBucketId bucket;
bucket.name = getBelType(bel);
return bucket;
}
BelBucketId getBelBucketForCellType(IdString cell_type) const {
BelBucketId getBelBucketForCellType(IdString cell_type) const
{
BelBucketId bucket;
bucket.name = cell_type;
return bucket;
}
std::vector<BelId> getBelsInBucket(BelBucketId bucket) const {
std::vector<BelId> getBelsInBucket(BelBucketId bucket) const
{
std::vector<BelId> bels;
for(BelId bel : getBels()) {
if(getBelType(bel) == bucket.name) {
for (BelId bel : getBels()) {
if (getBelType(bel) == bucket.name) {
bels.push_back(bel);
}
}

4
nexus/arch_pybindings.cc
View File

@ -55,8 +55,8 @@ void arch_wrap_python(py::module &m)
typedef UpDownhillPipRange DownhillPipRange;
typedef WireBelPinRange BelPinRange;
typedef const std::vector<BelBucketId> & BelBucketRange;
typedef const std::vector<BelId> & BelRangeForBelBucket;
typedef const std::vector<BelBucketId> &BelBucketRange;
typedef const std::vector<BelId> &BelRangeForBelBucket;
#include "arch_pybindings_shared.h"

8
nexus/archdefs.h
View File

@ -114,15 +114,13 @@ struct PipId
}
};
struct BelBucketId {
struct BelBucketId
{
IdString name;
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;
}
bool operator<(const BelBucketId &other) const { return name < other.name; }
};
struct GroupId