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

Merge branch 'master' of gitlab.com:SymbioticEDA/nextpnr

Browse Source 
# Conflicts:
#	common/route.cc
This commit is contained in:
Clifford Wolf 2018-06-21 19:31:50 +02:00
commit bfae4663fc
18 changed files with 634 additions and 594 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
common/log.cc
View File

@ -150,12 +150,8 @@ void logv_error(const char *format, va_list ap)
#ifdef EMSCRIPTEN #ifdef EMSCRIPTEN
log_files = backup_log_files; log_files = backup_log_files;
throw 0;
#elif defined(_MSC_VER)
_exit(EXIT_FAILURE);
#else
_Exit(EXIT_FAILURE);
#endif #endif
throw log_execution_error_exception();
} }
void log(const char *format, ...) void log(const char *format, ...)

4
common/log.h
View File

@ -43,6 +43,10 @@ struct log_cmd_error_exception
{ {
}; };
struct log_execution_error_exception
{
};
extern std::vector<FILE *> log_files; extern std::vector<FILE *> log_files;
extern std::vector<std::ostream *> log_streams; extern std::vector<std::ostream *> log_streams;
extern FILE *log_errfile; extern FILE *log_errfile;

12
common/place_sa.cc
View File

@ -478,10 +478,14 @@ class SAPlacer
bool place_design_sa(Context *ctx) bool place_design_sa(Context *ctx)
{ {
SAPlacer placer(ctx); try {
placer.place(); SAPlacer placer(ctx);
log_info("Checksum: 0x%08x\n", ctx->checksum()); placer.place();
return true; log_info("Checksum: 0x%08x\n", ctx->checksum());
return true;
} catch (log_execution_error_exception) {
return false;
}
} }
NEXTPNR_NAMESPACE_END NEXTPNR_NAMESPACE_END

355
common/route.cc
View File

@ -406,233 +406,242 @@ NEXTPNR_NAMESPACE_BEGIN
bool route_design(Context *ctx) bool route_design(Context *ctx)
{ {
delay_t ripup_penalty = ctx->getRipupDelayPenalty(); try {
RipupScoreboard scores; delay_t ripup_penalty = ctx->getRipupDelayPenalty();
RipupScoreboard scores;
log_break(); log_break();
log_info("Routing..\n"); log_info("Routing..\n");
std::unordered_set<IdString> netsQueue; std::unordered_set<IdString> netsQueue;
for (auto &net_it : ctx->nets) { for (auto &net_it : ctx->nets) {
auto net_name = net_it.first; auto net_name = net_it.first;
auto net_info = net_it.second; auto net_info = net_it.second;
if (net_info->driver.cell == nullptr) if (net_info->driver.cell == nullptr)
continue;
if (!net_info->wires.empty())
continue;
netsQueue.insert(net_name);
}
if (netsQueue.empty()) {
log_info("found no unrouted nets. no routing necessary.\n");
return true;
}
log_info("found %d unrouted nets. starting routing procedure.\n",
int(netsQueue.size()));
delay_t estimatedTotalDelay = 0.0;
int estimatedTotalDelayCnt = 0;
for (auto net_name : netsQueue) {
auto net_info = ctx->nets.at(net_name);
auto src_bel = net_info->driver.cell->bel;
if (src_bel == BelId())
continue;
IdString driver_port = net_info->driver.port;
auto driver_port_it = net_info->driver.cell->pins.find(driver_port);
if (driver_port_it != net_info->driver.cell->pins.end())
driver_port = driver_port_it->second;
auto src_wire =
ctx->getWireBelPin(src_bel, ctx->portPinFromId(driver_port));
if (src_wire == WireId())
continue;
for (auto &user_it : net_info->users) {
auto dst_bel = user_it.cell->bel;
if (dst_bel == BelId())
continue; continue;
IdString user_port = user_it.port; if (!net_info->wires.empty())
auto user_port_it = user_it.cell->pins.find(user_port);
if (user_port_it != user_it.cell->pins.end())
user_port = user_port_it->second;
auto dst_wire =
ctx->getWireBelPin(dst_bel, ctx->portPinFromId(user_port));
if (dst_wire == WireId())
continue; continue;
estimatedTotalDelay += ctx->estimateDelay(src_wire, dst_wire); netsQueue.insert(net_name);
estimatedTotalDelayCnt++;
}
}
log_info("estimated total wire delay: %.2f (avg %.2f)\n",
float(estimatedTotalDelay),
float(estimatedTotalDelay) / estimatedTotalDelayCnt);
int iterCnt = 0;
while (!netsQueue.empty()) {
if (iterCnt == 200) {
log_warning("giving up after %d iterations.\n", iterCnt);
log_info("Checksum: 0x%08x\n", ctx->checksum());
return false;
} }
iterCnt++; if (netsQueue.empty()) {
if (ctx->verbose) log_info("found no unrouted nets. no routing necessary.\n");
log_info("-- %d --\n", iterCnt); return true;
}
int visitCnt = 0, revisitCnt = 0, overtimeRevisitCnt = 0, netCnt = 0; log_info("found %d unrouted nets. starting routing procedure.\n",
int(netsQueue.size()));
std::unordered_set<IdString> ripupQueue; delay_t estimatedTotalDelay = 0.0;
int estimatedTotalDelayCnt = 0;
if (ctx->verbose || iterCnt == 1) for (auto net_name : netsQueue) {
log_info("routing queue contains %d nets.\n", auto net_info = ctx->nets.at(net_name);
int(netsQueue.size()));
bool printNets = ctx->verbose && (netsQueue.size() < 10); auto src_bel = net_info->driver.cell->bel;
std::vector<IdString> netsArray(netsQueue.begin(), netsQueue.end()); if (src_bel == BelId())
ctx->sorted_shuffle(netsArray); continue;
netsQueue.clear();
for (auto net_name : netsArray) { IdString driver_port = net_info->driver.port;
if (printNets)
log_info(" routing net %s. (%d users)\n", net_name.c_str(ctx),
int(ctx->nets.at(net_name)->users.size()));
Router router(ctx, scores, net_name, false); auto driver_port_it = net_info->driver.cell->pins.find(driver_port);
if (driver_port_it != net_info->driver.cell->pins.end())
driver_port = driver_port_it->second;
netCnt++; auto src_wire = ctx->getWireBelPin(src_bel,
visitCnt += router.visitCnt; ctx->portPinFromId(driver_port));
revisitCnt += router.revisitCnt;
overtimeRevisitCnt += router.overtimeRevisitCnt;
if (!router.routedOkay) { if (src_wire == WireId())
if (printNets) continue;
log_info(" failed to route to %s.\n",
ctx->getWireName(router.failedDest).c_str(ctx)); for (auto &user_it : net_info->users) {
ripupQueue.insert(net_name); auto dst_bel = user_it.cell->bel;
if (dst_bel == BelId())
continue;
IdString user_port = user_it.port;
auto user_port_it = user_it.cell->pins.find(user_port);
if (user_port_it != user_it.cell->pins.end())
user_port = user_port_it->second;
auto dst_wire = ctx->getWireBelPin(
dst_bel, ctx->portPinFromId(user_port));
if (dst_wire == WireId())
continue;
estimatedTotalDelay += ctx->estimateDelay(src_wire, dst_wire);
estimatedTotalDelayCnt++;
}
}
log_info("estimated total wire delay: %.2f (avg %.2f)\n",
float(estimatedTotalDelay),
float(estimatedTotalDelay) / estimatedTotalDelayCnt);
int iterCnt = 0;
while (!netsQueue.empty()) {
if (iterCnt == 200) {
log_warning("giving up after %d iterations.\n", iterCnt);
log_info("Checksum: 0x%08x\n", ctx->checksum());
return false;
} }
if ((ctx->verbose || iterCnt == 1) && !printNets && iterCnt++;
(netCnt % 100 == 0)) if (ctx->verbose)
log_info(" processed %d nets. (%d routed, %d failed)\n", log_info("-- %d --\n", iterCnt);
netCnt, netCnt - int(ripupQueue.size()),
int(ripupQueue.size()));
}
int normalRouteCnt = netCnt - int(ripupQueue.size()); int visitCnt = 0, revisitCnt = 0, overtimeRevisitCnt = 0, netCnt = 0;
if ((ctx->verbose || iterCnt == 1) && (netCnt % 100 != 0)) std::unordered_set<IdString> ripupQueue;
log_info(" processed %d nets. (%d routed, %d failed)\n", netCnt,
normalRouteCnt, int(ripupQueue.size()));
if (ctx->verbose)
log_info(" visited %d PIPs (%.2f%% revisits, %.2f%% overtime revisits).\n",
visitCnt, (100.0 * revisitCnt) / visitCnt, (100.0 * overtimeRevisitCnt) / visitCnt);
if (!ripupQueue.empty()) {
if (ctx->verbose || iterCnt == 1) if (ctx->verbose || iterCnt == 1)
log_info("failed to route %d nets. re-routing in ripup mode.\n", log_info("routing queue contains %d nets.\n",
int(ripupQueue.size())); int(netsQueue.size()));
printNets = ctx->verbose && (ripupQueue.size() < 10); bool printNets = ctx->verbose && (netsQueue.size() < 10);
visitCnt = 0; std::vector<IdString> netsArray(netsQueue.begin(), netsQueue.end());
revisitCnt = 0; ctx->sorted_shuffle(netsArray);
overtimeRevisitCnt = 0; netsQueue.clear();
netCnt = 0;
int ripCnt = 0;
std::vector<IdString> ripupArray(ripupQueue.begin(), for (auto net_name : netsArray) {
ripupQueue.end());
ctx->sorted_shuffle(ripupArray);
for (auto net_name : ripupArray) {
if (printNets) if (printNets)
log_info(" routing net %s. (%d users)\n", log_info(" routing net %s. (%d users)\n",
net_name.c_str(ctx), net_name.c_str(ctx),
int(ctx->nets.at(net_name)->users.size())); int(ctx->nets.at(net_name)->users.size()));
Router router(ctx, scores, net_name, true, ripup_penalty); Router router(ctx, scores, net_name, false);
netCnt++; netCnt++;
visitCnt += router.visitCnt; visitCnt += router.visitCnt;
revisitCnt += router.revisitCnt; revisitCnt += router.revisitCnt;
overtimeRevisitCnt += router.overtimeRevisitCnt; overtimeRevisitCnt += router.overtimeRevisitCnt;
if (!router.routedOkay) if (!router.routedOkay) {
log_error("Net %s is impossible to route.\n", if (printNets)
net_name.c_str(ctx)); log_info(
" failed to route to %s.\n",
for (auto it : router.rippedNets) ctx->getWireName(router.failedDest).c_str(ctx));
netsQueue.insert(it); ripupQueue.insert(net_name);
if (printNets) {
if (router.rippedNets.size() < 10) {
log_info(" ripped up %d other nets:\n",
int(router.rippedNets.size()));
for (auto n : router.rippedNets)
log_info(" %s (%d users)\n", n.c_str(ctx),
int(ctx->nets.at(n)->users.size()));
} else {
log_info(" ripped up %d other nets.\n",
int(router.rippedNets.size()));
}
} }
ripCnt += router.rippedNets.size();
if ((ctx->verbose || iterCnt == 1) && !printNets && if ((ctx->verbose || iterCnt == 1) && !printNets &&
(netCnt % 100 == 0)) (netCnt % 100 == 0))
log_info(" routed %d nets, ripped %d nets.\n", netCnt, log_info(" processed %d nets. (%d routed, %d failed)\n",
ripCnt); netCnt, netCnt - int(ripupQueue.size()),
int(ripupQueue.size()));
} }
int normalRouteCnt = netCnt - int(ripupQueue.size());
if ((ctx->verbose || iterCnt == 1) && (netCnt % 100 != 0)) if ((ctx->verbose || iterCnt == 1) && (netCnt % 100 != 0))
log_info(" routed %d nets, ripped %d nets.\n", netCnt, ripCnt); log_info(" processed %d nets. (%d routed, %d failed)\n",
netCnt, normalRouteCnt, int(ripupQueue.size()));
if (ctx->verbose) if (ctx->verbose)
log_info(" visited %d PIPs (%.2f%% revisits, %.2f%% overtime revisits).\n", log_info(" visited %d PIPs (%.2f%% revisits, %.2f%% overtime revisits).\n",
visitCnt, (100.0 * revisitCnt) / visitCnt, (100.0 * overtimeRevisitCnt) / visitCnt); visitCnt, (100.0 * revisitCnt) / visitCnt, (100.0 * overtimeRevisitCnt) / visitCnt);
if (ctx->verbose && !netsQueue.empty()) if (!ripupQueue.empty()) {
log_info(" ripped up %d previously routed nets. continue " if (ctx->verbose || iterCnt == 1)
"routing.\n", log_info("failed to route %d nets. re-routing in ripup "
int(netsQueue.size())); "mode.\n",
int(ripupQueue.size()));
printNets = ctx->verbose && (ripupQueue.size() < 10);
visitCnt = 0;
revisitCnt = 0;
overtimeRevisitCnt = 0;
netCnt = 0;
int ripCnt = 0;
std::vector<IdString> ripupArray(ripupQueue.begin(),
ripupQueue.end());
ctx->sorted_shuffle(ripupArray);
for (auto net_name : ripupArray) {
if (printNets)
log_info(" routing net %s. (%d users)\n",
net_name.c_str(ctx),
int(ctx->nets.at(net_name)->users.size()));
Router router(ctx, scores, net_name, true, ripup_penalty);
netCnt++;
visitCnt += router.visitCnt;
revisitCnt += router.revisitCnt;
overtimeRevisitCnt += router.overtimeRevisitCnt;
if (!router.routedOkay)
log_error("Net %s is impossible to route.\n",
net_name.c_str(ctx));
for (auto it : router.rippedNets)
netsQueue.insert(it);
if (printNets) {
if (router.rippedNets.size() < 10) {
log_info(" ripped up %d other nets:\n",
int(router.rippedNets.size()));
for (auto n : router.rippedNets)
log_info(" %s (%d users)\n", n.c_str(ctx),
int(ctx->nets.at(n)->users.size()));
} else {
log_info(" ripped up %d other nets.\n",
int(router.rippedNets.size()));
}
}
ripCnt += router.rippedNets.size();
if ((ctx->verbose || iterCnt == 1) && !printNets &&
(netCnt % 100 == 0))
log_info(" routed %d nets, ripped %d nets.\n", netCnt,
ripCnt);
}
if ((ctx->verbose || iterCnt == 1) && (netCnt % 100 != 0))
log_info(" routed %d nets, ripped %d nets.\n", netCnt,
ripCnt);
if (ctx->verbose)
log_info(" visited %d PIPs (%.2f%% revisits, %.2f%% overtime revisits).\n",
visitCnt, (100.0 * revisitCnt) / visitCnt, (100.0 * overtimeRevisitCnt) / visitCnt);
if (ctx->verbose && !netsQueue.empty())
log_info(" ripped up %d previously routed nets. continue "
"routing.\n",
int(netsQueue.size()));
}
if (!ctx->verbose)
log_info(
"iteration %d: routed %d nets without ripup, routed %d "
"nets with ripup.\n",
iterCnt, normalRouteCnt, int(ripupQueue.size()));
if (iterCnt == 8 || iterCnt == 16 || iterCnt == 32 ||
iterCnt == 64 || iterCnt == 128)
ripup_penalty += ctx->getRipupDelayPenalty();
} }
if (!ctx->verbose) log_info("routing complete after %d iterations.\n", iterCnt);
log_info("iteration %d: routed %d nets without ripup, routed %d " log_info("Checksum: 0x%08x\n", ctx->checksum());
"nets with ripup.\n", return true;
iterCnt, normalRouteCnt, int(ripupQueue.size())); } catch (log_execution_error_exception) {
return false;
if (iterCnt == 8 || iterCnt == 16 || iterCnt == 32 || iterCnt == 64 ||
iterCnt == 128)
ripup_penalty += ctx->getRipupDelayPenalty();
} }
log_info("routing complete after %d iterations.\n", iterCnt);
log_info("Checksum: 0x%08x\n", ctx->checksum());
return true;
} }
bool get_actual_route_delay(Context *ctx, WireId src_wire, WireId dst_wire, bool get_actual_route_delay(Context *ctx, WireId src_wire, WireId dst_wire,

163
dummy/main.cc
View File

@ -32,87 +32,96 @@ USING_NEXTPNR_NAMESPACE
int main(int argc, char *argv[]) int main(int argc, char *argv[])
{ {
namespace po = boost::program_options;
int rc = 0;
log_files.push_back(stdout);
po::options_description options("Allowed options");
options.add_options()("help,h", "show help");
options.add_options()("verbose,v", "verbose output");
options.add_options()("force,f", "keep running after errors");
options.add_options()("gui", "start gui");
options.add_options()("run", po::value<std::vector<std::string>>(),
"python file to execute");
options.add_options()("version,V", "show version");
po::positional_options_description pos;
pos.add("run", -1);
po::variables_map vm;
try { try {
po::parsed_options parsed = po::command_line_parser(argc, argv)
.options(options)
.positional(pos)
.run();
po::store(parsed, vm); namespace po = boost::program_options;
int rc = 0;
po::notify(vm); log_files.push_back(stdout);
po::options_description options("Allowed options");
options.add_options()("help,h", "show help");
options.add_options()("verbose,v", "verbose output");
options.add_options()("force,f", "keep running after errors");
options.add_options()("gui", "start gui");
options.add_options()("run", po::value<std::vector<std::string>>(),
"python file to execute");
options.add_options()("version,V", "show version");
po::positional_options_description pos;
pos.add("run", -1);
po::variables_map vm;
try {
po::parsed_options parsed = po::command_line_parser(argc, argv)
.options(options)
.positional(pos)
.run();
po::store(parsed, vm);
po::notify(vm);
}
catch (std::exception &e) {
std::cout << e.what() << "\n";
return 1;
}
if (vm.count("help") || argc == 1) {
std::cout << boost::filesystem::basename(argv[0])
<< " -- Next Generation Place and Route (git "
"sha1 " GIT_COMMIT_HASH_STR ")\n";
std::cout << "\n";
std::cout << options << "\n";
return argc != 1;
}
if (vm.count("version")) {
std::cout << boost::filesystem::basename(argv[0])
<< " -- Next Generation Place and Route (git "
"sha1 " GIT_COMMIT_HASH_STR ")\n";
return 1;
}
Context ctx(ArchArgs{});
init_python(argv[0]);
python_export_global("ctx", ctx);
if (vm.count("verbose")) {
ctx.verbose = true;
}
if (vm.count("force")) {
ctx.force = true;
}
if (vm.count("seed")) {
ctx.rngseed(vm["seed"].as<int>());
}
if (vm.count("run")) {
std::vector<std::string> files =
vm["run"].as<std::vector<std::string>>();
for (auto filename : files)
execute_python_file(filename.c_str());
}
if (vm.count("gui")) {
QApplication a(argc, argv);
MainWindow w(&ctx);
w.show();
rc = a.exec();
}
deinit_python();
return rc;
} catch (log_execution_error_exception) {
#if defined(_MSC_VER)
_exit(EXIT_FAILURE);
#else
_Exit(EXIT_FAILURE);
#endif
} }
catch (std::exception &e) {
std::cout << e.what() << "\n";
return 1;
}
if (vm.count("help") || argc == 1) {
std::cout << boost::filesystem::basename(argv[0])
<< " -- Next Generation Place and Route (git "
"sha1 " GIT_COMMIT_HASH_STR ")\n";
std::cout << "\n";
std::cout << options << "\n";
return argc != 1;
}
if (vm.count("version")) {
std::cout << boost::filesystem::basename(argv[0])
<< " -- Next Generation Place and Route (git "
"sha1 " GIT_COMMIT_HASH_STR ")\n";
return 1;
}
Context ctx(ArchArgs{});
init_python(argv[0]);
python_export_global("ctx", ctx);
if (vm.count("verbose")) {
ctx.verbose = true;
}
if (vm.count("force")) {
ctx.force = true;
}
if (vm.count("seed")) {
ctx.rngseed(vm["seed"].as<int>());
}
if (vm.count("run")) {
std::vector<std::string> files =
vm["run"].as<std::vector<std::string>>();
for (auto filename : files)
execute_python_file(filename.c_str());
}
if (vm.count("gui")) {
QApplication a(argc, argv);
MainWindow w(&ctx);
w.show();
rc = a.exec();
}
deinit_python();
return rc;
} }
#endif #endif

33
frontend/json/jsonparse.cc
View File

@ -797,27 +797,32 @@ void json_import(Context *ctx, string modname, JsonNode *node)
} }
}; // End Namespace JsonParser }; // End Namespace JsonParser
void parse_json_file(std::istream &f, std::string &filename, Context *ctx) bool parse_json_file(std::istream &f, std::string &filename, Context *ctx)
{ {
using namespace JsonParser; try {
using namespace JsonParser;
JsonNode root(f); JsonNode root(f);
if (root.type != 'D') if (root.type != 'D')
log_error("JSON root node is not a dictionary.\n"); log_error("JSON root node is not a dictionary.\n");
if (root.data_dict.count("modules") != 0) { if (root.data_dict.count("modules") != 0) {
JsonNode *modules = root.data_dict.at("modules"); JsonNode *modules = root.data_dict.at("modules");
if (modules->type != 'D') if (modules->type != 'D')
log_error("JSON modules node is not a dictionary.\n"); log_error("JSON modules node is not a dictionary.\n");
for (auto &it : modules->data_dict) for (auto &it : modules->data_dict)
json_import(ctx, it.first, it.second); json_import(ctx, it.first, it.second);
}
log_info("Checksum: 0x%08x\n", ctx->checksum());
log_break();
return true;
} catch (log_execution_error_exception) {
return false;
} }
log_info("Checksum: 0x%08x\n", ctx->checksum());
log_break();
} }
NEXTPNR_NAMESPACE_END NEXTPNR_NAMESPACE_END

2
frontend/json/jsonparse.h
View File

@ -26,7 +26,7 @@
NEXTPNR_NAMESPACE_BEGIN NEXTPNR_NAMESPACE_BEGIN
extern void parse_json_file(std::istream &, std::string &, Context *); extern bool parse_json_file(std::istream &, std::string &, Context *);
NEXTPNR_NAMESPACE_END NEXTPNR_NAMESPACE_END

1
gui/basewindow.cc
View File

@ -10,7 +10,6 @@
#include "mainwindow.h" #include "mainwindow.h"
#include "pythontab.h" #include "pythontab.h"
BaseMainWindow::BaseMainWindow(Context *_ctx, QWidget *parent) BaseMainWindow::BaseMainWindow(Context *_ctx, QWidget *parent)
: QMainWindow(parent), ctx(_ctx) : QMainWindow(parent), ctx(_ctx)
{ {

2
gui/basewindow.h
View File

@ -30,7 +30,7 @@ class BaseMainWindow : public QMainWindow
protected Q_SLOTS: protected Q_SLOTS:
void writeInfo(std::string text); void writeInfo(std::string text);
virtual void open() = 0; virtual void open() = 0;
virtual bool save() = 0; virtual bool save() = 0;

9
gui/dummy/mainwindow.cc
View File

@ -17,11 +17,6 @@ void MainWindow::createMenu()
menuBar->addAction(menu_Custom->menuAction()); menuBar->addAction(menu_Custom->menuAction());
} }
void MainWindow::open() void MainWindow::open() {}
{
}
bool MainWindow::save() bool MainWindow::save() { return false; }
{
return false;
}

2
gui/dummy/mainwindow.h
View File

@ -19,7 +19,7 @@ class MainWindow : public BaseMainWindow
protected Q_SLOTS: protected Q_SLOTS:
virtual void open(); virtual void open();
virtual bool save(); virtual bool save();
}; };
#endif // MAINWINDOW_H #endif // MAINWINDOW_H

8
gui/ice40/mainwindow.cc
View File

@ -20,8 +20,7 @@ MainWindow::MainWindow(Context *_ctx, QWidget *parent)
createMenu(); createMenu();
task = new TaskManager(_ctx); task = new TaskManager(_ctx);
connect(task, SIGNAL(log(std::string)), this, connect(task, SIGNAL(log(std::string)), this, SLOT(writeInfo(std::string)));
SLOT(writeInfo(std::string)));
} }
MainWindow::~MainWindow() {} MainWindow::~MainWindow() {}
@ -43,7 +42,4 @@ void MainWindow::open()
task->parsejson(fn); task->parsejson(fn);
} }
} }
bool MainWindow::save() bool MainWindow::save() { return false; }
{
return false;
}

44
gui/ice40/worker.cc
View File

@ -1,13 +1,13 @@
#include "worker.h" #include "worker.h"
#include <fstream> #include <fstream>
#include "bitstream.h"
#include "design_utils.h"
#include "jsonparse.h" #include "jsonparse.h"
#include "log.h" #include "log.h"
#include "pack.h" #include "pack.h"
#include "pcf.h" #include "pcf.h"
#include "place_sa.h" #include "place_sa.h"
#include "route.h" #include "route.h"
#include "bitstream.h"
#include "design_utils.h"
#include "timing.h" #include "timing.h"
Worker::Worker(Context *_ctx) : ctx(_ctx) Worker::Worker(Context *_ctx) : ctx(_ctx)
@ -15,28 +15,29 @@ Worker::Worker(Context *_ctx) : ctx(_ctx)
log_write_function = [this](std::string text) { Q_EMIT log(text); }; log_write_function = [this](std::string text) { Q_EMIT log(text); };
} }
void Worker::parsejson(const std::string &filename) void Worker::parsejson(const std::string &filename)
{ {
std::string fn = filename; std::string fn = filename;
std::ifstream f(fn); std::ifstream f(fn);
try {
if (!parse_json_file(f, fn, ctx))
log_error("Loading design failed.\n");
if (!pack_design(ctx))
log_error("Packing design failed.\n");
double freq = 50e6;
assign_budget(ctx, freq);
print_utilisation(ctx);
parse_json_file(f, fn, ctx); if (!place_design_sa(ctx))
if (!pack_design(ctx)) log_error("Placing design failed.\n");
log_error("Packing design failed.\n"); if (!route_design(ctx))
double freq = 50e6; log_error("Routing design failed.\n");
assign_budget(ctx, freq); Q_EMIT log("done");
print_utilisation(ctx); } catch (log_execution_error_exception) {
}
if (!place_design_sa(ctx))
log_error("Placing design failed.\n");
if (!route_design(ctx))
log_error("Routing design failed.\n");
print_utilisation(ctx);
Q_EMIT log("done");
} }
TaskManager::TaskManager(Context *ctx)
TaskManager::TaskManager(Context *ctx)
{ {
Worker *worker = new Worker(ctx); Worker *worker = new Worker(ctx);
worker->moveToThread(&workerThread); worker->moveToThread(&workerThread);
@ -46,13 +47,10 @@ TaskManager::TaskManager(Context *ctx)
workerThread.start(); workerThread.start();
} }
TaskManager::~TaskManager() TaskManager::~TaskManager()
{ {
workerThread.quit(); workerThread.quit();
workerThread.wait(); workerThread.wait();
} }
void TaskManager::info(const std::string &result) void TaskManager::info(const std::string &result) { Q_EMIT log(result); }
{
Q_EMIT log(result);
}

18
gui/ice40/worker.h
View File

@ -1,8 +1,8 @@
#ifndef WORKER_H #ifndef WORKER_H
#define WORKER_H #define WORKER_H
#include "nextpnr.h"
#include <QThread> #include <QThread>
#include "nextpnr.h"
// FIXME // FIXME
USING_NEXTPNR_NAMESPACE USING_NEXTPNR_NAMESPACE
@ -10,13 +10,14 @@ USING_NEXTPNR_NAMESPACE
class Worker : public QObject class Worker : public QObject
{ {
Q_OBJECT Q_OBJECT
public: public:
Worker(Context *ctx); Worker(Context *ctx);
public Q_SLOTS: public Q_SLOTS:
void parsejson(const std::string &filename); void parsejson(const std::string &filename);
Q_SIGNALS: Q_SIGNALS:
void log(const std::string &text); void log(const std::string &text);
private:
private:
Context *ctx; Context *ctx;
}; };
@ -24,12 +25,13 @@ class TaskManager : public QObject
{ {
Q_OBJECT Q_OBJECT
QThread workerThread; QThread workerThread;
public:
public:
TaskManager(Context *ctx); TaskManager(Context *ctx);
~TaskManager(); ~TaskManager();
public Q_SLOTS: public Q_SLOTS:
void info(const std::string &text); void info(const std::string &text);
Q_SIGNALS: Q_SIGNALS:
void parsejson(const std::string &); void parsejson(const std::string &);
void log(const std::string &text); void log(const std::string &text);
}; };

470
ice40/main.cc
View File

@ -60,276 +60,288 @@ void svg_dump_el(const GraphicElement &el)
int main(int argc, char *argv[]) int main(int argc, char *argv[])
{ {
namespace po = boost::program_options;
int rc = 0;
std::string str;
log_files.push_back(stdout);
po::options_description options("Allowed options");
options.add_options()("help,h", "show help");
options.add_options()("verbose,v", "verbose output");
options.add_options()("debug", "debug output");
options.add_options()("force,f", "keep running after errors");
options.add_options()("gui", "start gui");
options.add_options()("svg", "dump SVG file");
options.add_options()("pack-only",
"pack design only without placement or routing");
options.add_options()("run", po::value<std::vector<std::string>>(),
"python file to execute");
options.add_options()("json", po::value<std::string>(),
"JSON design file to ingest");
options.add_options()("pcf", po::value<std::string>(),
"PCF constraints file to ingest");
options.add_options()("asc", po::value<std::string>(),
"asc bitstream file to write");
options.add_options()("seed", po::value<int>(),
"seed value for random number generator");
options.add_options()("version,V", "show version");
options.add_options()("tmfuzz", "run path delay estimate fuzzer");
options.add_options()("lp384", "set device type to iCE40LP384");
options.add_options()("lp1k", "set device type to iCE40LP1K");
options.add_options()("lp8k", "set device type to iCE40LP8K");
options.add_options()("hx1k", "set device type to iCE40HX1K");
options.add_options()("hx8k", "set device type to iCE40HX8K");
options.add_options()("up5k", "set device type to iCE40UP5K");
options.add_options()("freq", po::value<double>(),
"set target frequency for design in MHz");
options.add_options()("package", po::value<std::string>(),
"set device package");
po::positional_options_description pos;
pos.add("run", -1);
po::variables_map vm;
try { try {
po::parsed_options parsed = po::command_line_parser(argc, argv) namespace po = boost::program_options;
.options(options) int rc = 0;
.positional(pos) std::string str;
.run();
po::store(parsed, vm); log_files.push_back(stdout);
po::notify(vm); po::options_description options("Allowed options");
} options.add_options()("help,h", "show help");
options.add_options()("verbose,v", "verbose output");
options.add_options()("debug", "debug output");
options.add_options()("force,f", "keep running after errors");
options.add_options()("gui", "start gui");
options.add_options()("svg", "dump SVG file");
options.add_options()("pack-only",
"pack design only without placement or routing");
catch (std::exception &e) { options.add_options()("run", po::value<std::vector<std::string>>(),
std::cout << e.what() << "\n"; "python file to execute");
return 1; options.add_options()("json", po::value<std::string>(),
} "JSON design file to ingest");
options.add_options()("pcf", po::value<std::string>(),
"PCF constraints file to ingest");
options.add_options()("asc", po::value<std::string>(),
"asc bitstream file to write");
options.add_options()("seed", po::value<int>(),
"seed value for random number generator");
options.add_options()("version,V", "show version");
options.add_options()("tmfuzz", "run path delay estimate fuzzer");
options.add_options()("lp384", "set device type to iCE40LP384");
options.add_options()("lp1k", "set device type to iCE40LP1K");
options.add_options()("lp8k", "set device type to iCE40LP8K");
options.add_options()("hx1k", "set device type to iCE40HX1K");
options.add_options()("hx8k", "set device type to iCE40HX8K");
options.add_options()("up5k", "set device type to iCE40UP5K");
options.add_options()("freq", po::value<double>(),
"set target frequency for design in MHz");
options.add_options()("package", po::value<std::string>(),
"set device package");
po::positional_options_description pos;
pos.add("run", -1);
if (vm.count("help") || argc == 1) { po::variables_map vm;
help: try {
std::cout << boost::filesystem::basename(argv[0]) po::parsed_options parsed = po::command_line_parser(argc, argv)
<< " -- Next Generation Place and Route (git " .options(options)
"sha1 " GIT_COMMIT_HASH_STR ")\n"; .positional(pos)
std::cout << "\n"; .run();
std::cout << options << "\n";
return argc != 1;
}
if (vm.count("version")) { po::store(parsed, vm);
std::cout << boost::filesystem::basename(argv[0])
<< " -- Next Generation Place and Route (git "
"sha1 " GIT_COMMIT_HASH_STR ")\n";
return 1;
}
ArchArgs chipArgs; po::notify(vm);
}
if (vm.count("lp384")) { catch (std::exception &e) {
if (chipArgs.type != ArchArgs::NONE) std::cout << e.what() << "\n";
goto help; return 1;
chipArgs.type = ArchArgs::LP384; }
chipArgs.package = "qn32";
}
if (vm.count("lp1k")) { if (vm.count("help") || argc == 1) {
if (chipArgs.type != ArchArgs::NONE) help:
goto help; std::cout << boost::filesystem::basename(argv[0])
chipArgs.type = ArchArgs::LP1K; << " -- Next Generation Place and Route (git "
chipArgs.package = "tq144"; "sha1 " GIT_COMMIT_HASH_STR ")\n";
} std::cout << "\n";
std::cout << options << "\n";
return argc != 1;
}
if (vm.count("lp8k")) { if (vm.count("version")) {
if (chipArgs.type != ArchArgs::NONE) std::cout << boost::filesystem::basename(argv[0])
goto help; << " -- Next Generation Place and Route (git "
chipArgs.type = ArchArgs::LP8K; "sha1 " GIT_COMMIT_HASH_STR ")\n";
chipArgs.package = "ct256"; return 1;
} }
if (vm.count("hx1k")) { ArchArgs chipArgs;
if (chipArgs.type != ArchArgs::NONE)
goto help;
chipArgs.type = ArchArgs::HX1K;
chipArgs.package = "tq144";
}
if (vm.count("hx8k")) { if (vm.count("lp384")) {
if (chipArgs.type != ArchArgs::NONE) if (chipArgs.type != ArchArgs::NONE)
goto help; goto help;
chipArgs.type = ArchArgs::HX8K; chipArgs.type = ArchArgs::LP384;
chipArgs.package = "ct256"; chipArgs.package = "qn32";
} }
if (vm.count("up5k")) { if (vm.count("lp1k")) {
if (chipArgs.type != ArchArgs::NONE) if (chipArgs.type != ArchArgs::NONE)
goto help; goto help;
chipArgs.type = ArchArgs::UP5K; chipArgs.type = ArchArgs::LP1K;
chipArgs.package = "sg48"; chipArgs.package = "tq144";
} }
if (chipArgs.type == ArchArgs::NONE) { if (vm.count("lp8k")) {
chipArgs.type = ArchArgs::HX1K; if (chipArgs.type != ArchArgs::NONE)
chipArgs.package = "tq144"; goto help;
} chipArgs.type = ArchArgs::LP8K;
chipArgs.package = "ct256";
}
if (vm.count("hx1k")) {
if (chipArgs.type != ArchArgs::NONE)
goto help;
chipArgs.type = ArchArgs::HX1K;
chipArgs.package = "tq144";
}
if (vm.count("hx8k")) {
if (chipArgs.type != ArchArgs::NONE)
goto help;
chipArgs.type = ArchArgs::HX8K;
chipArgs.package = "ct256";
}
if (vm.count("up5k")) {
if (chipArgs.type != ArchArgs::NONE)
goto help;
chipArgs.type = ArchArgs::UP5K;
chipArgs.package = "sg48";
}
if (chipArgs.type == ArchArgs::NONE) {
chipArgs.type = ArchArgs::HX1K;
chipArgs.package = "tq144";
}
#ifdef ICE40_HX1K_ONLY #ifdef ICE40_HX1K_ONLY
if (chipArgs.type != ArchArgs::HX1K) { if (chipArgs.type != ArchArgs::HX1K) {
std::cout << "This version of nextpnr-ice40 is built with HX1K-support " std::cout << "This version of nextpnr-ice40 is built with "
"only.\n"; "HX1K-support "
return 1; "only.\n";
} return 1;
}
#endif #endif
if (vm.count("package")) if (vm.count("package"))
chipArgs.package = vm["package"].as<std::string>(); chipArgs.package = vm["package"].as<std::string>();
Context ctx(chipArgs); Context ctx(chipArgs);
init_python(argv[0]); init_python(argv[0]);
python_export_global("ctx", ctx); python_export_global("ctx", ctx);
if (vm.count("verbose")) { if (vm.count("verbose")) {
ctx.verbose = true; ctx.verbose = true;
} }
if (vm.count("debug")) { if (vm.count("debug")) {
ctx.verbose = true; ctx.verbose = true;
ctx.debug = true; ctx.debug = true;
} }
if (vm.count("force")) { if (vm.count("force")) {
ctx.force = true; ctx.force = true;
} }
if (vm.count("seed")) { if (vm.count("seed")) {
ctx.rngseed(vm["seed"].as<int>()); ctx.rngseed(vm["seed"].as<int>());
} }
if (vm.count("svg")) { if (vm.count("svg")) {
std::cout << "<svg xmlns=\"http://www.w3.org/2000/svg\" " std::cout << "<svg xmlns=\"http://www.w3.org/2000/svg\" "
"xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n"; "xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n";
for (auto bel : ctx.getBels()) { for (auto bel : ctx.getBels()) {
std::cout << "<!-- " << ctx.getBelName(bel).str(&ctx) << " -->\n"; std::cout << "<!-- " << ctx.getBelName(bel).str(&ctx)
for (auto &el : ctx.getBelGraphics(bel)) << " -->\n";
for (auto &el : ctx.getBelGraphics(bel))
svg_dump_el(el);
}
std::cout << "<!-- Frame -->\n";
for (auto &el : ctx.getFrameGraphics())
svg_dump_el(el); svg_dump_el(el);
std::cout << "</svg>\n";
} }
std::cout << "<!-- Frame -->\n";
for (auto &el : ctx.getFrameGraphics())
svg_dump_el(el);
std::cout << "</svg>\n";
}
if (vm.count("tmfuzz")) { if (vm.count("tmfuzz")) {
std::vector<WireId> src_wires, dst_wires; std::vector<WireId> src_wires, dst_wires;
/*for (auto w : ctx.getWires()) /*for (auto w : ctx.getWires())
src_wires.push_back(w);*/ src_wires.push_back(w);*/
for (auto b : ctx.getBels()) { for (auto b : ctx.getBels()) {
if (ctx.getBelType(b) == TYPE_ICESTORM_LC) { if (ctx.getBelType(b) == TYPE_ICESTORM_LC) {
src_wires.push_back(ctx.getWireBelPin(b, PIN_O)); src_wires.push_back(ctx.getWireBelPin(b, PIN_O));
}
if (ctx.getBelType(b) == TYPE_SB_IO) {
src_wires.push_back(ctx.getWireBelPin(b, PIN_D_IN_0));
}
} }
if (ctx.getBelType(b) == TYPE_SB_IO) {
src_wires.push_back(ctx.getWireBelPin(b, PIN_D_IN_0)); for (auto b : ctx.getBels()) {
if (ctx.getBelType(b) == TYPE_ICESTORM_LC) {
dst_wires.push_back(ctx.getWireBelPin(b, PIN_I0));
dst_wires.push_back(ctx.getWireBelPin(b, PIN_I1));
dst_wires.push_back(ctx.getWireBelPin(b, PIN_I2));
dst_wires.push_back(ctx.getWireBelPin(b, PIN_I3));
dst_wires.push_back(ctx.getWireBelPin(b, PIN_CEN));
dst_wires.push_back(ctx.getWireBelPin(b, PIN_CIN));
}
if (ctx.getBelType(b) == TYPE_SB_IO) {
dst_wires.push_back(ctx.getWireBelPin(b, PIN_D_OUT_0));
dst_wires.push_back(
ctx.getWireBelPin(b, PIN_OUTPUT_ENABLE));
}
}
ctx.shuffle(src_wires);
ctx.shuffle(dst_wires);
for (int i = 0;
i < int(src_wires.size()) && i < int(dst_wires.size()); i++) {
delay_t actual_delay;
WireId src = src_wires[i], dst = dst_wires[i];
if (!get_actual_route_delay(&ctx, src, dst, actual_delay))
continue;
printf("%s %s %.3f %.3f %d %d %d %d %d %d\n",
ctx.getWireName(src).c_str(&ctx),
ctx.getWireName(dst).c_str(&ctx),
ctx.getDelayNS(actual_delay),
ctx.getDelayNS(ctx.estimateDelay(src, dst)),
ctx.chip_info->wire_data[src.index].x,
ctx.chip_info->wire_data[src.index].y,
ctx.chip_info->wire_data[src.index].type,
ctx.chip_info->wire_data[dst.index].x,
ctx.chip_info->wire_data[dst.index].y,
ctx.chip_info->wire_data[dst.index].type);
} }
} }
for (auto b : ctx.getBels()) { if (vm.count("json")) {
if (ctx.getBelType(b) == TYPE_ICESTORM_LC) { std::string filename = vm["json"].as<std::string>();
dst_wires.push_back(ctx.getWireBelPin(b, PIN_I0)); std::ifstream f(filename);
dst_wires.push_back(ctx.getWireBelPin(b, PIN_I1)); if (!parse_json_file(f, filename, &ctx))
dst_wires.push_back(ctx.getWireBelPin(b, PIN_I2)); log_error("Loading design failed.\n");
dst_wires.push_back(ctx.getWireBelPin(b, PIN_I3));
dst_wires.push_back(ctx.getWireBelPin(b, PIN_CEN)); if (vm.count("pcf")) {
dst_wires.push_back(ctx.getWireBelPin(b, PIN_CIN)); std::ifstream pcf(vm["pcf"].as<std::string>());
if (!apply_pcf(&ctx, pcf))
log_error("Loading PCF failed.\n");
} }
if (ctx.getBelType(b) == TYPE_SB_IO) {
dst_wires.push_back(ctx.getWireBelPin(b, PIN_D_OUT_0)); if (!pack_design(&ctx) && !ctx.force)
dst_wires.push_back(ctx.getWireBelPin(b, PIN_OUTPUT_ENABLE)); log_error("Packing design failed.\n");
double freq = 50e6;
if (vm.count("freq"))
freq = vm["freq"].as<double>() * 1e6;
assign_budget(&ctx, freq);
print_utilisation(&ctx);
if (!vm.count("pack-only")) {
if (!place_design_sa(&ctx) && !ctx.force)
log_error("Placing design failed.\n");
if (!route_design(&ctx) && !ctx.force)
log_error("Routing design failed.\n");
} }
} }
ctx.shuffle(src_wires); if (vm.count("asc")) {
ctx.shuffle(dst_wires); std::string filename = vm["asc"].as<std::string>();
std::ofstream f(filename);
for (int i = 0; i < int(src_wires.size()) && i < int(dst_wires.size()); write_asc(&ctx, f);
i++) {
delay_t actual_delay;
WireId src = src_wires[i], dst = dst_wires[i];
if (!get_actual_route_delay(&ctx, src, dst, actual_delay))
continue;
printf("%s %s %.3f %.3f %d %d %d %d %d %d\n",
ctx.getWireName(src).c_str(&ctx),
ctx.getWireName(dst).c_str(&ctx),
ctx.getDelayNS(actual_delay),
ctx.getDelayNS(ctx.estimateDelay(src, dst)),
ctx.chip_info->wire_data[src.index].x,
ctx.chip_info->wire_data[src.index].y,
ctx.chip_info->wire_data[src.index].type,
ctx.chip_info->wire_data[dst.index].x,
ctx.chip_info->wire_data[dst.index].y,
ctx.chip_info->wire_data[dst.index].type);
}
}
if (vm.count("json")) {
std::string filename = vm["json"].as<std::string>();
std::ifstream f(filename);
parse_json_file(f, filename, &ctx);
if (vm.count("pcf")) {
std::ifstream pcf(vm["pcf"].as<std::string>());
apply_pcf(&ctx, pcf);
} }
if (!pack_design(&ctx) && !ctx.force) if (vm.count("run")) {
log_error("Packing design failed.\n"); std::vector<std::string> files =
double freq = 50e6; vm["run"].as<std::vector<std::string>>();
if (vm.count("freq")) for (auto filename : files)
freq = vm["freq"].as<double>() * 1e6; execute_python_file(filename.c_str());
assign_budget(&ctx, freq);
print_utilisation(&ctx);
if (!vm.count("pack-only")) {
if (!place_design_sa(&ctx) && !ctx.force)
log_error("Placing design failed.\n");
if (!route_design(&ctx) && !ctx.force)
log_error("Routing design failed.\n");
} }
}
if (vm.count("asc")) { if (vm.count("gui")) {
std::string filename = vm["asc"].as<std::string>(); QApplication a(argc, argv);
std::ofstream f(filename); MainWindow w(&ctx);
write_asc(&ctx, f); w.show();
}
if (vm.count("run")) { rc = a.exec();
std::vector<std::string> files = }
vm["run"].as<std::vector<std::string>>(); deinit_python();
for (auto filename : files) return rc;
execute_python_file(filename.c_str()); } catch (log_execution_error_exception) {
#if defined(_MSC_VER)
_exit(EXIT_FAILURE);
#else
_Exit(EXIT_FAILURE);
#endif
} }
if (vm.count("gui")) {
QApplication a(argc, argv);
MainWindow w(&ctx);
w.show();
rc = a.exec();
}
deinit_python();
return rc;
} }
#endif #endif

22
ice40/pack.cc
View File

@ -487,15 +487,19 @@ static void promote_globals(Context *ctx)
// Main pack function // Main pack function
bool pack_design(Context *ctx) bool pack_design(Context *ctx)
{ {
log_break(); try {
pack_constants(ctx); log_break();
promote_globals(ctx); pack_constants(ctx);
pack_io(ctx); promote_globals(ctx);
pack_lut_lutffs(ctx); pack_io(ctx);
pack_nonlut_ffs(ctx); pack_lut_lutffs(ctx);
pack_ram(ctx); pack_nonlut_ffs(ctx);
log_info("Checksum: 0x%08x\n", ctx->checksum()); pack_ram(ctx);
return true; log_info("Checksum: 0x%08x\n", ctx->checksum());
return true;
} catch (log_execution_error_exception) {
return false;
}
} }
NEXTPNR_NAMESPACE_END NEXTPNR_NAMESPACE_END

75
ice40/pcf.cc
View File

@ -27,44 +27,51 @@ NEXTPNR_NAMESPACE_BEGIN
// Read a w // Read a w
// Apply PCF constraints to a pre-packing design // Apply PCF constraints to a pre-packing design
void apply_pcf(Context *ctx, std::istream &in) bool apply_pcf(Context *ctx, std::istream &in)
{ {
if (!in) try {
log_error("failed to open PCF file"); if (!in)
std::string line; log_error("failed to open PCF file");
while (std::getline(in, line)) { std::string line;
size_t cstart = line.find("#"); while (std::getline(in, line)) {
if (cstart != std::string::npos) size_t cstart = line.find("#");
line = line.substr(0, cstart); if (cstart != std::string::npos)
std::stringstream ss(line); line = line.substr(0, cstart);
std::vector<std::string> words; std::stringstream ss(line);
std::string tmp; std::vector<std::string> words;
while (ss >> tmp) std::string tmp;
words.push_back(tmp); while (ss >> tmp)
if (words.size() == 0) words.push_back(tmp);
continue; if (words.size() == 0)
std::string cmd = words.at(0); continue;
if (cmd == "set_io") { std::string cmd = words.at(0);
size_t args_end = 1; if (cmd == "set_io") {
while (args_end < words.size() && words.at(args_end).at(0) == '-') size_t args_end = 1;
args_end++; while (args_end < words.size() &&
std::string cell = words.at(args_end); words.at(args_end).at(0) == '-')
std::string pin = words.at(args_end + 1); args_end++;
auto fnd_cell = ctx->cells.find(cell); std::string cell = words.at(args_end);
if (fnd_cell == ctx->cells.end()) { std::string pin = words.at(args_end + 1);
log_warning("unmatched pcf constraint %s\n", cell.c_str()); auto fnd_cell = ctx->cells.find(cell);
if (fnd_cell == ctx->cells.end()) {
log_warning("unmatched pcf constraint %s\n", cell.c_str());
} else {
BelId pin_bel = ctx->getPackagePinBel(pin);
if (pin_bel == BelId())
log_error("package does not have a pin named %s\n",
pin.c_str());
fnd_cell->second->attrs["BEL"] =
ctx->getBelName(pin_bel).str();
log_info("constrained '%s' to bel '%s'\n", cell.c_str(),
fnd_cell->second->attrs["BEL"].c_str());
}
} else { } else {
BelId pin_bel = ctx->getPackagePinBel(pin); log_error("unsupported pcf command '%s'\n", cmd.c_str());
if (pin_bel == BelId())
log_error("package does not have a pin named %s\n",
pin.c_str());
fnd_cell->second->attrs["BEL"] = ctx->getBelName(pin_bel).str();
log_info("constrained '%s' to bel '%s'\n", cell.c_str(),
fnd_cell->second->attrs["BEL"].c_str());
} }
} else {
log_error("unsupported pcf command '%s'\n", cmd.c_str());
} }
return true;
} catch (log_execution_error_exception) {
return false;
} }
} }

2
ice40/pcf.h
View File

@ -27,7 +27,7 @@
NEXTPNR_NAMESPACE_BEGIN NEXTPNR_NAMESPACE_BEGIN
// Apply PCF constraints to a pre-packing design // Apply PCF constraints to a pre-packing design
void apply_pcf(Context *ctx, std::istream &in); bool apply_pcf(Context *ctx, std::istream &in);
NEXTPNR_NAMESPACE_END NEXTPNR_NAMESPACE_END