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

Add default implementation of bel bucket functions

Browse Source 
Signed-off-by: D. Shah <dave@ds0.me>
This commit is contained in:
D. Shah 2021-02-04 11:57:08 +00:00
parent ed8e3c83d9
commit 297cd026b9
5 changed files with 94 additions and 88 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

94
common/nextpnr.h
View File

@ -1012,6 +1012,7 @@ struct BaseCtx
void attributesToArchInfo();
};
namespace {
// For several functions; such as bel/wire/pip attributes; the trivial implementation is to return an empty vector
// But an arch might want to do something fancy with a custom range type that doesn't provide a constructor
// So some cursed C++ is needed to return an empty object if possible; or error out if not; is needed
@ -1025,6 +1026,44 @@ template <typename Tc> typename std::enable_if<!std::is_constructible<Tc>::value
"default constructor!");
}
// Provide a default implementation of bel bucket name if typedef'd to IdString
template <typename Tbbid>
typename std::enable_if<std::is_same<Tbbid, IdString>::value, IdString>::type bbid_to_name(Tbbid id)
{
return id;
}
template <typename Tbbid>
typename std::enable_if<!std::is_same<Tbbid, IdString>::value, IdString>::type bbid_to_name(Tbbid id)
{
NPNR_ASSERT_FALSE("getBelBucketName must be implemented when BelBucketId is a type other than IdString!");
}
template <typename Tbbid>
typename std::enable_if<std::is_same<Tbbid, IdString>::value, BelBucketId>::type bbid_from_name(IdString name)
{
return name;
}
template <typename Tbbid>
typename std::enable_if<!std::is_same<Tbbid, IdString>::value, BelBucketId>::type bbid_from_name(IdString name)
{
NPNR_ASSERT_FALSE("getBelBucketByName must be implemented when BelBucketId is a type other than IdString!");
}
// For the cell type and bel type ranges; we want to return our stored vectors only if the type matches
template <typename Tret, typename Tc>
typename std::enable_if<std::is_same<Tret, Tc>::value, Tret>::type return_if_match(Tret r)
{
return r;
}
template <typename Tret, typename Tc>
typename std::enable_if<!std::is_same<Tret, Tc>::value, Tret>::type return_if_match(Tret r)
{
NPNR_ASSERT_FALSE("default implementations of cell type and bel bucket range functions only available when the "
"respective range types are 'const std::vector&'");
}
} // namespace
template <typename R> struct ArchBase : BaseCtx
{
// --------------------------------------------------------------
@ -1235,15 +1274,27 @@ template <typename R> struct ArchBase : BaseCtx
// Placement validity checks
virtual bool isValidBelForCellType(IdString cell_type, BelId bel) const { return cell_type == getBelType(bel); }
virtual IdString getBelBucketName(BelBucketId bucket) const = 0;
virtual BelBucketId getBelBucketByName(IdString name) const = 0;
virtual IdString getBelBucketName(BelBucketId bucket) const { return bbid_to_name<BelBucketId>(bucket); }
virtual BelBucketId getBelBucketByName(IdString name) const { return bbid_from_name<BelBucketId>(name); }
virtual BelBucketId getBelBucketForBel(BelId bel) const { return getBelBucketForCellType(getBelType(bel)); };
virtual BelBucketId getBelBucketForCellType(IdString cell_type) const { return getBelBucketByName(cell_type); };
virtual bool isValidBelForCell(CellInfo *cell, BelId bel) const { return true; }
virtual bool isBelLocationValid(BelId bel) const { return true; }
virtual typename R::CellTypeRange getCellTypes() const = 0;
virtual typename R::BelBucketRange getBelBuckets() const = 0;
virtual typename R::BucketBelRange getBelsInBucket(BelBucketId bucket) const = 0;
virtual typename R::CellTypeRange getCellTypes() const
{
NPNR_ASSERT(cell_types_initialised);
return return_if_match<const std::vector<IdString> &, typename R::CellTypeRange>(cell_types);
}
virtual typename R::BelBucketRange getBelBuckets() const
{
NPNR_ASSERT(bel_buckets_initialised);
return return_if_match<const std::vector<BelBucketId> &, typename R::BelBucketRange>(bel_buckets);
}
virtual typename R::BucketBelRange getBelsInBucket(BelBucketId bucket) const
{
NPNR_ASSERT(bel_buckets_initialised);
return return_if_match<const std::vector<BelId> &, typename R::BucketBelRange>(bucket_bels.at(bucket));
}
// Flow methods
virtual bool pack() = 0;
@ -1258,6 +1309,39 @@ template <typename R> struct ArchBase : BaseCtx
std::unordered_map<BelId, CellInfo *> base_bel2cell;
std::unordered_map<WireId, NetInfo *> base_wire2net;
std::unordered_map<PipId, NetInfo *> base_pip2net;
// For the default cell/bel bucket implementations
std::vector<IdString> cell_types;
std::vector<BelBucketId> bel_buckets;
std::unordered_map<BelBucketId, std::vector<BelId>> bucket_bels;
// Arches that want to use the default cell types and bel buckets *must* call these functions in their constructor
bool cell_types_initialised = false;
bool bel_buckets_initialised = false;
void init_cell_types()
{
std::unordered_set<IdString> bel_types;
for (auto bel : getBels())
bel_types.insert(getBelType(bel));
std::copy(bel_types.begin(), bel_types.end(), std::back_inserter(cell_types));
std::sort(cell_types.begin(), cell_types.end());
cell_types_initialised = true;
}
void init_bel_buckets()
{
for (auto cell_type : getCellTypes()) {
auto bucket = getBelBucketForCellType(cell_type);
bucket_bels[bucket]; // create empty bucket
}
for (auto bel : getBels()) {
auto bucket = getBelBucketForBel(bel);
bucket_bels[bucket].push_back(bel);
}
for (auto &b : bucket_bels)
bel_buckets.push_back(b.first);
std::sort(bel_buckets.begin(), bel_buckets.end());
bel_buckets_initialised = true;
}
};
NEXTPNR_NAMESPACE_END

14
ecp5/arch.cc
View File

@ -105,18 +105,8 @@ 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()) {
bel_types.insert(getBelType(bel));
}
for (IdString bel_type : bel_types) {
cell_types.push_back(bel_type);
BelBucketId bucket;
bucket.name = bel_type;
buckets.push_back(bucket);
}
ArchBase::init_cell_types();
ArchBase::init_bel_buckets();
for (int i = 0; i < chip_info->width; i++)
x_ids.push_back(id(stringf("X%d", i)));

43
ecp5/arch.h
View File

@ -461,8 +461,8 @@ struct ArchRanges
using DecalGfxRange = std::vector<GraphicElement>;
// Placement validity
using CellTypeRange = const std::vector<IdString> &;
using BelBucketRange = std::vector<BelBucketId>;
using BucketBelRange = std::vector<BelId>;
using BelBucketRange = const std::vector<BelBucketId> &;
using BucketBelRange = const std::vector<BelId> &;
};
struct Arch : ArchBase<ArchRanges>
@ -878,45 +878,6 @@ struct Arch : ArchBase<ArchRanges>
// -------------------------------------------------
// Placement validity checks
const std::vector<IdString> &getCellTypes() const override { return cell_types; }
std::vector<BelBucketId> getBelBuckets() const override { return buckets; }
IdString getBelBucketName(BelBucketId bucket) const override { return bucket.name; }
BelBucketId getBelBucketByName(IdString name) const override
{
BelBucketId bucket;
bucket.name = name;
return bucket;
}
BelBucketId getBelBucketForBel(BelId bel) const override
{
BelBucketId bucket;
bucket.name = getBelType(bel);
return bucket;
}
BelBucketId getBelBucketForCellType(IdString cell_type) const override
{
BelBucketId bucket;
bucket.name = cell_type;
return bucket;
}
std::vector<BelId> getBelsInBucket(BelBucketId bucket) const override
{
std::vector<BelId> bels;
for (BelId bel : getBels()) {
if (getBelType(bel) == bucket.name) {
bels.push_back(bel);
}
}
return bels;
}
bool isValidBelForCell(CellInfo *cell, BelId bel) const override;
bool isBelLocationValid(BelId bel) const override;

12
ecp5/arch_pybindings.h
View File

@ -76,18 +76,6 @@ template <> struct string_converter<PipId>
}
};
template <> struct string_converter<BelBucketId>
{
BelBucketId from_str(Context *ctx, std::string name) { return ctx->getBelBucketByName(ctx->id(name)); }
std::string to_str(Context *ctx, BelBucketId id)
{
if (id == BelBucketId())
throw bad_wrap();
return ctx->getBelBucketName(id).str(ctx);
}
};
template <> struct string_converter<BelPin>
{
BelPin from_str(Context *ctx, std::string name)

19
ecp5/archdefs.h
View File

@ -126,14 +126,7 @@ struct PipId
}
};
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; }
};
typedef IdString BelBucketId;
struct GroupId
{
@ -271,14 +264,4 @@ template <> struct hash<NEXTPNR_NAMESPACE_PREFIX DecalId>
}
};
template <> struct hash<NEXTPNR_NAMESPACE_PREFIX BelBucketId>
{
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));
return seed;
}
};
} // namespace std