From 49f178ed94b5fad00d25dbd12adea0bf4732f803 Mon Sep 17 00:00:00 2001 From: gatecat Date: Fri, 8 Apr 2022 13:42:54 +0100 Subject: Split up common into kernel,place,route Signed-off-by: gatecat --- common/kernel/pybindings.cc | 362 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 362 insertions(+) create mode 100644 common/kernel/pybindings.cc (limited to 'common/kernel/pybindings.cc') 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 + * Copyright (C) 2018 gatecat + * + * 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 +#include +#include +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 +{ + 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 +{ + 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_(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_(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_(m, "GraphicElement") + .def(py::init(), + 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_(m, "PortType") + .value("PORT_IN", PORT_IN) + .value("PORT_OUT", PORT_OUT) + .value("PORT_INOUT", PORT_INOUT) + .export_values(); + + py::enum_(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_(m, "DelayPair") + .def(py::init<>()) + .def(py::init()) + .def(py::init()) + .def_readwrite("min_delay", &DelayPair::min_delay) + .def_readwrite("max_delay", &DelayPair::max_delay) + .def("minDelay", &DelayPair::minDelay) + .def("maxDelay", &DelayPair::maxDelay); + + py::class_(m, "DelayQuad") + .def(py::init<>()) + .def(py::init()) + .def(py::init()) + .def(py::init()) + .def(py::init()) + .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 AttrMap; + typedef dict PortMap; + typedef dict IdIdMap; + typedef dict> RegionMap; + + py::class_(m, "BaseCtx"); + + auto loc_cls = py::class_(m, "Loc") + .def(py::init()) + .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_>(m, "CellInfo"); + readwrite_wrapper, + conv_from_str>::def_wrap(ci_cls, "name"); + readwrite_wrapper, + conv_from_str>::def_wrap(ci_cls, "type"); + readonly_wrapper>::def_wrap( + ci_cls, "attrs"); + readonly_wrapper>::def_wrap( + ci_cls, "params"); + readonly_wrapper>::def_wrap( + ci_cls, "ports"); + readwrite_wrapper, + conv_from_str>::def_wrap(ci_cls, "bel"); + readwrite_wrapper, + pass_through>::def_wrap(ci_cls, "belStrength"); + + fn_wrapper_1a_v>::def_wrap( + ci_cls, "addInput"); + fn_wrapper_1a_v>::def_wrap(ci_cls, "addOutput"); + fn_wrapper_1a_v>::def_wrap( + ci_cls, "addInout"); + + fn_wrapper_2a_v, + conv_from_str>::def_wrap(ci_cls, "setParam"); + fn_wrapper_1a_v>::def_wrap(ci_cls, "unsetParam"); + fn_wrapper_2a_v, + conv_from_str>::def_wrap(ci_cls, "setAttr"); + fn_wrapper_1a_v>::def_wrap(ci_cls, "unsetAttr"); + + auto pi_cls = py::class_>(m, "PortInfo"); + readwrite_wrapper, + conv_from_str>::def_wrap(pi_cls, "name"); + readonly_wrapper>::def_wrap(pi_cls, + "net"); + readwrite_wrapper, + pass_through>::def_wrap(pi_cls, "type"); + + typedef indexed_store PortRefVector; + typedef dict WireMap; + typedef pool BelSet; + typedef pool WireSet; + + auto ni_cls = py::class_>(m, "NetInfo"); + readwrite_wrapper, + conv_from_str>::def_wrap(ni_cls, "name"); + readonly_wrapper>::def_wrap( + ni_cls, "driver"); + readonly_wrapper>::def_wrap( + ni_cls, "users"); + readonly_wrapper>::def_wrap(ni_cls, + "wires"); + + auto pr_cls = py::class_>(m, "PortRef"); + readonly_wrapper>::def_wrap(pr_cls, + "cell"); + readonly_wrapper>::def_wrap(pr_cls, + "port"); + readonly_wrapper>::def_wrap(pr_cls, + "budget"); + + auto pm_cls = py::class_>(m, "PipMap"); + readwrite_wrapper, + conv_from_str>::def_wrap(pm_cls, "pip"); + readwrite_wrapper, + pass_through>::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_>(m, "Region"); + readwrite_wrapper, + conv_from_str>::def_wrap(region_cls, "name"); + readwrite_wrapper, + pass_through>::def_wrap(region_cls, "constr_bels"); + readwrite_wrapper, + pass_through>::def_wrap(region_cls, "constr_bels"); + readwrite_wrapper, + pass_through>::def_wrap(region_cls, "constr_pips"); + readonly_wrapper>::def_wrap(region_cls, + "bels"); + readonly_wrapper>::def_wrap(region_cls, + "wires"); + + auto hierarchy_cls = py::class_>(m, "HierarchicalCell"); + readwrite_wrapper, conv_from_str>::def_wrap(hierarchy_cls, "name"); + readwrite_wrapper, conv_from_str>::def_wrap(hierarchy_cls, "type"); + readwrite_wrapper, conv_from_str>::def_wrap(hierarchy_cls, "parent"); + readwrite_wrapper, conv_from_str>::def_wrap(hierarchy_cls, "fullpath"); + + readonly_wrapper>::def_wrap(hierarchy_cls, "leaf_cells"); + readonly_wrapper>::def_wrap(hierarchy_cls, "nets"); + readonly_wrapper>::def_wrap(hierarchy_cls, "hier_cells"); + WRAP_MAP(m, AttrMap, conv_to_str, "AttrMap"); + WRAP_MAP(m, PortMap, wrap_context, "PortMap"); + WRAP_MAP(m, IdIdMap, conv_to_str, "IdIdMap"); + WRAP_MAP(m, WireMap, wrap_context, "WireMap"); + WRAP_MAP_UPTR(m, RegionMap, "RegionMap"); + + WRAP_INDEXSTORE(m, PortRefVector, wrap_context); + + typedef dict ClockFmaxMap; + WRAP_MAP(m, ClockFmaxMap, pass_through, "ClockFmaxMap"); + + auto clk_fmax_cls = py::class_(m, "ClockFmax") + .def_readonly("achieved", &ClockFmax::achieved) + .def_readonly("constraint", &ClockFmax::constraint); + + auto tmg_result_cls = py::class_>(m, "TimingResult"); + readonly_wrapper>::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 -- cgit v1.2.3