diff options
Diffstat (limited to 'common/kernel/pybindings.cc')
| -rw-r--r-- | common/kernel/pybindings.cc | 362 |
1 files changed, 362 insertions, 0 deletions
diff --git a/common/kernel/pybindings.cc b/common/kernel/pybindings.cc new file mode 100644 index 00000000..9a783eb4 --- /dev/null +++ b/common/kernel/pybindings.cc @@ -0,0 +1,362 @@ +/* + * nextpnr -- Next Generation Place and Route + * + * Copyright (C) 2018 Claire Xenia Wolf <claire@yosyshq.com> + * Copyright (C) 2018 gatecat <gatecat@ds0.me> + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + */ + +#ifndef NO_PYTHON + +#include "pybindings.h" +#include "arch_pybindings.h" +#include "json_frontend.h" +#include "log.h" +#include "nextpnr.h" + +#include <fstream> +#include <memory> +#include <signal.h> +NEXTPNR_NAMESPACE_BEGIN + +// Required to determine concatenated module name (which differs for different +// archs) +#define PASTER(x, y) x##_##y +#define EVALUATOR(x, y) PASTER(x, y) +#define MODULE_NAME EVALUATOR(nextpnrpy, ARCHNAME) +#define PYINIT_MODULE_NAME EVALUATOR(&PyInit_nextpnrpy, ARCHNAME) +#define STRINGIFY(x) #x +#define TOSTRING(x) STRINGIFY(x) + +// Architecture-specific bindings should be created in the below function, which +// must be implemented in all architectures +void arch_wrap_python(py::module &m); + +bool operator==(const PortRef &a, const PortRef &b) { return (a.cell == b.cell) && (a.port == b.port); } + +// Load a JSON file into a design +void parse_json_shim(std::string filename, Context &d) +{ + std::ifstream inf(filename); + if (!inf) + throw std::runtime_error("failed to open file " + filename); + parse_json(inf, filename, &d); +} + +// Create a new Chip and load design from json file +Context *load_design_shim(std::string filename, ArchArgs args) +{ + Context *d = new Context(args); + parse_json_shim(filename, *d); + return d; +} + +namespace PythonConversion { +template <> struct string_converter<PortRef &> +{ + inline PortRef from_str(Context *ctx, std::string name) { NPNR_ASSERT_FALSE("PortRef from_str not implemented"); } + + inline std::string to_str(Context *ctx, const PortRef &pr) + { + return pr.cell->name.str(ctx) + "." + pr.port.str(ctx); + } +}; + +template <> struct string_converter<Property> +{ + inline Property from_str(Context *ctx, std::string s) { return Property::from_string(s); } + + inline std::string to_str(Context *ctx, Property p) { return p.to_string(); } +}; + +} // namespace PythonConversion + +std::string loc_repr_py(Loc loc) { return stringf("Loc(%d, %d, %d)", loc.x, loc.y, loc.z); } + +PYBIND11_EMBEDDED_MODULE(MODULE_NAME, m) +{ + py::register_exception_translator([](std::exception_ptr p) { + try { + if (p) + std::rethrow_exception(p); + } catch (const assertion_failure &e) { + PyErr_SetString(PyExc_AssertionError, e.what()); + } + }); + + using namespace PythonConversion; + + py::enum_<GraphicElement::type_t>(m, "GraphicElementType") + .value("TYPE_NONE", GraphicElement::TYPE_NONE) + .value("TYPE_LINE", GraphicElement::TYPE_LINE) + .value("TYPE_ARROW", GraphicElement::TYPE_ARROW) + .value("TYPE_BOX", GraphicElement::TYPE_BOX) + .value("TYPE_CIRCLE", GraphicElement::TYPE_CIRCLE) + .value("TYPE_LABEL", GraphicElement::TYPE_LABEL) + .export_values(); + + py::enum_<GraphicElement::style_t>(m, "GraphicElementStyle") + .value("STYLE_GRID", GraphicElement::STYLE_GRID) + .value("STYLE_FRAME", GraphicElement::STYLE_FRAME) + .value("STYLE_HIDDEN", GraphicElement::STYLE_HIDDEN) + .value("STYLE_INACTIVE", GraphicElement::STYLE_INACTIVE) + .value("STYLE_ACTIVE", GraphicElement::STYLE_ACTIVE) + .export_values(); + + py::class_<GraphicElement>(m, "GraphicElement") + .def(py::init<GraphicElement::type_t, GraphicElement::style_t, float, float, float, float, float>(), + py::arg("type"), py::arg("style"), py::arg("x1"), py::arg("y1"), py::arg("x2"), py::arg("y2"), + py::arg("z")) + .def_readwrite("type", &GraphicElement::type) + .def_readwrite("x1", &GraphicElement::x1) + .def_readwrite("y1", &GraphicElement::y1) + .def_readwrite("x2", &GraphicElement::x2) + .def_readwrite("y2", &GraphicElement::y2) + .def_readwrite("text", &GraphicElement::text); + + py::enum_<PortType>(m, "PortType") + .value("PORT_IN", PORT_IN) + .value("PORT_OUT", PORT_OUT) + .value("PORT_INOUT", PORT_INOUT) + .export_values(); + + py::enum_<PlaceStrength>(m, "PlaceStrength") + .value("STRENGTH_NONE", STRENGTH_NONE) + .value("STRENGTH_WEAK", STRENGTH_WEAK) + .value("STRENGTH_STRONG", STRENGTH_STRONG) + .value("STRENGTH_FIXED", STRENGTH_FIXED) + .value("STRENGTH_LOCKED", STRENGTH_LOCKED) + .value("STRENGTH_USER", STRENGTH_USER) + .export_values(); + + py::class_<DelayPair>(m, "DelayPair") + .def(py::init<>()) + .def(py::init<delay_t>()) + .def(py::init<delay_t, delay_t>()) + .def_readwrite("min_delay", &DelayPair::min_delay) + .def_readwrite("max_delay", &DelayPair::max_delay) + .def("minDelay", &DelayPair::minDelay) + .def("maxDelay", &DelayPair::maxDelay); + + py::class_<DelayQuad>(m, "DelayQuad") + .def(py::init<>()) + .def(py::init<delay_t>()) + .def(py::init<delay_t, delay_t>()) + .def(py::init<delay_t, delay_t, delay_t, delay_t>()) + .def(py::init<DelayPair, DelayPair>()) + .def_readwrite("rise", &DelayQuad::rise) + .def_readwrite("fall", &DelayQuad::fall) + .def("minDelay", &DelayQuad::minDelay) + .def("minRiseDelay", &DelayQuad::minRiseDelay) + .def("minFallDelay", &DelayQuad::minFallDelay) + .def("maxDelay", &DelayQuad::maxDelay) + .def("maxRiseDelay", &DelayQuad::maxRiseDelay) + .def("maxFallDelay", &DelayQuad::maxFallDelay) + .def("delayPair", &DelayQuad::delayPair); + + typedef dict<IdString, Property> AttrMap; + typedef dict<IdString, PortInfo> PortMap; + typedef dict<IdString, IdString> IdIdMap; + typedef dict<IdString, std::unique_ptr<Region>> RegionMap; + + py::class_<BaseCtx>(m, "BaseCtx"); + + auto loc_cls = py::class_<Loc>(m, "Loc") + .def(py::init<int, int, int>()) + .def_readwrite("x", &Loc::x) + .def_readwrite("y", &Loc::y) + .def_readwrite("z", &Loc::z) + .def("__repr__", loc_repr_py); + + auto ci_cls = py::class_<ContextualWrapper<CellInfo &>>(m, "CellInfo"); + readwrite_wrapper<CellInfo &, decltype(&CellInfo::name), &CellInfo::name, conv_to_str<IdString>, + conv_from_str<IdString>>::def_wrap(ci_cls, "name"); + readwrite_wrapper<CellInfo &, decltype(&CellInfo::type), &CellInfo::type, conv_to_str<IdString>, + conv_from_str<IdString>>::def_wrap(ci_cls, "type"); + readonly_wrapper<CellInfo &, decltype(&CellInfo::attrs), &CellInfo::attrs, wrap_context<AttrMap &>>::def_wrap( + ci_cls, "attrs"); + readonly_wrapper<CellInfo &, decltype(&CellInfo::params), &CellInfo::params, wrap_context<AttrMap &>>::def_wrap( + ci_cls, "params"); + readonly_wrapper<CellInfo &, decltype(&CellInfo::ports), &CellInfo::ports, wrap_context<PortMap &>>::def_wrap( + ci_cls, "ports"); + readwrite_wrapper<CellInfo &, decltype(&CellInfo::bel), &CellInfo::bel, conv_to_str<BelId>, + conv_from_str<BelId>>::def_wrap(ci_cls, "bel"); + readwrite_wrapper<CellInfo &, decltype(&CellInfo::belStrength), &CellInfo::belStrength, pass_through<PlaceStrength>, + pass_through<PlaceStrength>>::def_wrap(ci_cls, "belStrength"); + + fn_wrapper_1a_v<CellInfo &, decltype(&CellInfo::addInput), &CellInfo::addInput, conv_from_str<IdString>>::def_wrap( + ci_cls, "addInput"); + fn_wrapper_1a_v<CellInfo &, decltype(&CellInfo::addOutput), &CellInfo::addOutput, + conv_from_str<IdString>>::def_wrap(ci_cls, "addOutput"); + fn_wrapper_1a_v<CellInfo &, decltype(&CellInfo::addInout), &CellInfo::addInout, conv_from_str<IdString>>::def_wrap( + ci_cls, "addInout"); + + fn_wrapper_2a_v<CellInfo &, decltype(&CellInfo::setParam), &CellInfo::setParam, conv_from_str<IdString>, + conv_from_str<Property>>::def_wrap(ci_cls, "setParam"); + fn_wrapper_1a_v<CellInfo &, decltype(&CellInfo::unsetParam), &CellInfo::unsetParam, + conv_from_str<IdString>>::def_wrap(ci_cls, "unsetParam"); + fn_wrapper_2a_v<CellInfo &, decltype(&CellInfo::setAttr), &CellInfo::setAttr, conv_from_str<IdString>, + conv_from_str<Property>>::def_wrap(ci_cls, "setAttr"); + fn_wrapper_1a_v<CellInfo &, decltype(&CellInfo::unsetAttr), &CellInfo::unsetAttr, + conv_from_str<IdString>>::def_wrap(ci_cls, "unsetAttr"); + + auto pi_cls = py::class_<ContextualWrapper<PortInfo &>>(m, "PortInfo"); + readwrite_wrapper<PortInfo &, decltype(&PortInfo::name), &PortInfo::name, conv_to_str<IdString>, + conv_from_str<IdString>>::def_wrap(pi_cls, "name"); + readonly_wrapper<PortInfo &, decltype(&PortInfo::net), &PortInfo::net, deref_and_wrap<NetInfo>>::def_wrap(pi_cls, + "net"); + readwrite_wrapper<PortInfo &, decltype(&PortInfo::type), &PortInfo::type, pass_through<PortType>, + pass_through<PortType>>::def_wrap(pi_cls, "type"); + + typedef indexed_store<PortRef> PortRefVector; + typedef dict<WireId, PipMap> WireMap; + typedef pool<BelId> BelSet; + typedef pool<WireId> WireSet; + + auto ni_cls = py::class_<ContextualWrapper<NetInfo &>>(m, "NetInfo"); + readwrite_wrapper<NetInfo &, decltype(&NetInfo::name), &NetInfo::name, conv_to_str<IdString>, + conv_from_str<IdString>>::def_wrap(ni_cls, "name"); + readonly_wrapper<NetInfo &, decltype(&NetInfo::driver), &NetInfo::driver, wrap_context<PortRef>>::def_wrap( + ni_cls, "driver"); + readonly_wrapper<NetInfo &, decltype(&NetInfo::users), &NetInfo::users, wrap_context<PortRefVector &>>::def_wrap( + ni_cls, "users"); + readonly_wrapper<NetInfo &, decltype(&NetInfo::wires), &NetInfo::wires, wrap_context<WireMap &>>::def_wrap(ni_cls, + "wires"); + + auto pr_cls = py::class_<ContextualWrapper<PortRef>>(m, "PortRef"); + readonly_wrapper<PortRef, decltype(&PortRef::cell), &PortRef::cell, deref_and_wrap<CellInfo>>::def_wrap(pr_cls, + "cell"); + readonly_wrapper<PortRef, decltype(&PortRef::port), &PortRef::port, conv_to_str<IdString>>::def_wrap(pr_cls, + "port"); + readonly_wrapper<PortRef, decltype(&PortRef::budget), &PortRef::budget, pass_through<delay_t>>::def_wrap(pr_cls, + "budget"); + + auto pm_cls = py::class_<ContextualWrapper<PipMap &>>(m, "PipMap"); + readwrite_wrapper<PipMap &, decltype(&PipMap::pip), &PipMap::pip, conv_to_str<PipId>, + conv_from_str<PipId>>::def_wrap(pm_cls, "pip"); + readwrite_wrapper<PipMap &, decltype(&PipMap::strength), &PipMap::strength, pass_through<PlaceStrength>, + pass_through<PlaceStrength>>::def_wrap(pm_cls, "strength"); + + m.def("parse_json", parse_json_shim); + m.def("load_design", load_design_shim, py::return_value_policy::take_ownership); + + auto region_cls = py::class_<ContextualWrapper<Region &>>(m, "Region"); + readwrite_wrapper<Region &, decltype(&Region::name), &Region::name, conv_to_str<IdString>, + conv_from_str<IdString>>::def_wrap(region_cls, "name"); + readwrite_wrapper<Region &, decltype(&Region::constr_bels), &Region::constr_bels, pass_through<bool>, + pass_through<bool>>::def_wrap(region_cls, "constr_bels"); + readwrite_wrapper<Region &, decltype(&Region::constr_wires), &Region::constr_wires, pass_through<bool>, + pass_through<bool>>::def_wrap(region_cls, "constr_bels"); + readwrite_wrapper<Region &, decltype(&Region::constr_pips), &Region::constr_pips, pass_through<bool>, + pass_through<bool>>::def_wrap(region_cls, "constr_pips"); + readonly_wrapper<Region &, decltype(&Region::bels), &Region::bels, wrap_context<BelSet &>>::def_wrap(region_cls, + "bels"); + readonly_wrapper<Region &, decltype(&Region::wires), &Region::wires, wrap_context<WireSet &>>::def_wrap(region_cls, + "wires"); + + auto hierarchy_cls = py::class_<ContextualWrapper<HierarchicalCell &>>(m, "HierarchicalCell"); + readwrite_wrapper<HierarchicalCell &, decltype(&HierarchicalCell::name), &HierarchicalCell::name, + conv_to_str<IdString>, conv_from_str<IdString>>::def_wrap(hierarchy_cls, "name"); + readwrite_wrapper<HierarchicalCell &, decltype(&HierarchicalCell::type), &HierarchicalCell::type, + conv_to_str<IdString>, conv_from_str<IdString>>::def_wrap(hierarchy_cls, "type"); + readwrite_wrapper<HierarchicalCell &, decltype(&HierarchicalCell::parent), &HierarchicalCell::parent, + conv_to_str<IdString>, conv_from_str<IdString>>::def_wrap(hierarchy_cls, "parent"); + readwrite_wrapper<HierarchicalCell &, decltype(&HierarchicalCell::fullpath), &HierarchicalCell::fullpath, + conv_to_str<IdString>, conv_from_str<IdString>>::def_wrap(hierarchy_cls, "fullpath"); + + readonly_wrapper<HierarchicalCell &, decltype(&HierarchicalCell::leaf_cells), &HierarchicalCell::leaf_cells, + wrap_context<IdIdMap &>>::def_wrap(hierarchy_cls, "leaf_cells"); + readonly_wrapper<HierarchicalCell &, decltype(&HierarchicalCell::nets), &HierarchicalCell::nets, + wrap_context<IdIdMap &>>::def_wrap(hierarchy_cls, "nets"); + readonly_wrapper<HierarchicalCell &, decltype(&HierarchicalCell::hier_cells), &HierarchicalCell::hier_cells, + wrap_context<IdIdMap &>>::def_wrap(hierarchy_cls, "hier_cells"); + WRAP_MAP(m, AttrMap, conv_to_str<Property>, "AttrMap"); + WRAP_MAP(m, PortMap, wrap_context<PortInfo &>, "PortMap"); + WRAP_MAP(m, IdIdMap, conv_to_str<IdString>, "IdIdMap"); + WRAP_MAP(m, WireMap, wrap_context<PipMap &>, "WireMap"); + WRAP_MAP_UPTR(m, RegionMap, "RegionMap"); + + WRAP_INDEXSTORE(m, PortRefVector, wrap_context<PortRef>); + + typedef dict<IdString, ClockFmax> ClockFmaxMap; + WRAP_MAP(m, ClockFmaxMap, pass_through<ClockFmax>, "ClockFmaxMap"); + + auto clk_fmax_cls = py::class_<ClockFmax>(m, "ClockFmax") + .def_readonly("achieved", &ClockFmax::achieved) + .def_readonly("constraint", &ClockFmax::constraint); + + auto tmg_result_cls = py::class_<ContextualWrapper<TimingResult &>>(m, "TimingResult"); + readonly_wrapper<TimingResult &, decltype(&TimingResult::clock_fmax), &TimingResult::clock_fmax, + wrap_context<ClockFmaxMap &>>::def_wrap(tmg_result_cls, "clock_fmax"); + arch_wrap_python(m); +} + +#ifdef MAIN_EXECUTABLE +static wchar_t *program; +#endif + +void (*python_sighandler)(int) = nullptr; + +void init_python(const char *executable) +{ +#ifdef MAIN_EXECUTABLE + program = Py_DecodeLocale(executable, NULL); + if (program == NULL) { + fprintf(stderr, "Fatal error: cannot decode executable filename\n"); + exit(1); + } + Py_SetProgramName(program); + py::initialize_interpreter(); + py::module::import(TOSTRING(MODULE_NAME)); + PyRun_SimpleString("from " TOSTRING(MODULE_NAME) " import *"); + python_sighandler = signal(SIGINT, SIG_DFL); +#endif +} + +void deinit_python() +{ +#ifdef MAIN_EXECUTABLE + py::finalize_interpreter(); + PyMem_RawFree(program); +#endif +} + +void execute_python_file(const char *python_file) +{ + try { + FILE *fp = fopen(python_file, "r"); + if (fp == NULL) { + fprintf(stderr, "Fatal error: file not found %s\n", python_file); + exit(1); + } + if (python_sighandler) + signal(SIGINT, python_sighandler); + int result = PyRun_SimpleFile(fp, python_file); + signal(SIGINT, SIG_DFL); + fclose(fp); + if (result == -1) { + log_error("Error occurred while executing Python script %s\n", python_file); + } + } catch (py::error_already_set const &) { + // Parse and output the exception + std::string perror_str = parse_python_exception(); + signal(SIGINT, SIG_DFL); + log_error("Error in Python: %s\n", perror_str.c_str()); + } +} + +NEXTPNR_NAMESPACE_END + +#endif // NO_PYTHON |