Add implementations for generic arch db API

Signed-off-by: Clifford Wolf <clifford@clifford.at>

2 files changed, 248 insertions, 94 deletions

diff --git a/generic/arch.cc b/generic/arch.cc
index 0e4a3365..16fe2935 100644
--- a/generic/arch.cc
+++ b/generic/arch.cc
@@ -22,163 +22,304 @@
 
 NEXTPNR_NAMESPACE_BEGIN
 
-Arch::Arch(ArchArgs) {}
+void Arch::addWire(IdString name, int x, int y)
+{
+    assert(wires.count(name) == 0);
+    WireInfo &wi = wires[name];
+    wi.name = name;
+    wi.grid_x = x;
+    wi.grid_y = y;
 
-void IdString::initialize_arch(const BaseCtx *ctx) {}
+    wire_ids.push_back(name);
+}
 
-// ---------------------------------------------------------------
+void Arch::addPip(IdString name, IdString srcWire, IdString dstWire, DelayInfo delay)
+{
+    assert(pips.count(name) == 0);
+    PipInfo &pi = pips[name];
+    pi.name = name;
+    pi.srcWire = srcWire;
+    pi.dstWire = dstWire;
+    pi.delay = delay;
+
+    wires.at(srcWire).downhill.push_back(name);
+    wires.at(dstWire).uphill.push_back(name);
+    pip_ids.push_back(name);
+}
 
-BelId Arch::getBelByName(IdString name) const { return BelId(); }
+void Arch::addAlias(IdString name, IdString srcWire, IdString dstWire, DelayInfo delay)
+{
+    assert(pips.count(name) == 0);
+    PipInfo &pi = pips[name];
+    pi.name = name;
+    pi.srcWire = srcWire;
+    pi.dstWire = dstWire;
+    pi.delay = delay;
+
+    wires.at(srcWire).aliases.push_back(name);
+    pip_ids.push_back(name);
+}
 
-IdString Arch::getBelName(BelId bel) const { return IdString(); }
+void Arch::addBel(IdString name, IdString type, int x, int y, bool gb)
+{
+    assert(bels.count(name) == 0);
+    BelInfo &bi = bels[name];
+    bi.name = name;
+    bi.type = type;
+    bi.grid_x = x;
+    bi.grid_y = y;
+    bi.gb = gb;
+
+    bel_ids.push_back(name);
+    bel_ids_by_type[type].push_back(name);
+}
 
-uint32_t Arch::getBelChecksum(BelId bel) const { return 0; }
+void Arch::addBelInput(IdString bel, IdString name, IdString wire)
+{
+    assert(bels.at(bel).pins.count(name) == 0);
+    PinInfo &pi = bels.at(bel).pins[name];
+    pi.name = name;
+    pi.wire = wire;
+    pi.type = PORT_IN;
 
-void Arch::bindBel(BelId bel, IdString cell, PlaceStrength strength) {}
+    wires.at(wire).downhill_bel_pins.push_back(BelPin{bel, name});
+}
 
-void Arch::unbindBel(BelId bel) {}
+void Arch::addBelOutput(IdString bel, IdString name, IdString wire)
+{
+    assert(bels.at(bel).pins.count(name) == 0);
+    PinInfo &pi = bels.at(bel).pins[name];
+    pi.name = name;
+    pi.wire = wire;
+    pi.type = PORT_OUT;
 
-bool Arch::checkBelAvail(BelId bel) const { return false; }
+    wires.at(wire).uphill_bel_pin = BelPin{bel, name};
+}
 
-IdString Arch::getBoundBelCell(BelId bel) const { return IdString(); }
+void Arch::addBelInout(IdString bel, IdString name, IdString wire)
+{
+    assert(bels.at(bel).pins.count(name) == 0);
+    PinInfo &pi = bels.at(bel).pins[name];
+    pi.name = name;
+    pi.wire = wire;
+    pi.type = PORT_INOUT;
 
-IdString Arch::getConflictingBelCell(BelId bel) const { return IdString(); }
+    wires.at(wire).downhill_bel_pins.push_back(BelPin{bel, name});
+}
 
-const std::vector<BelId> &Arch::getBels() const
+void Arch::addFrameGraphic(const GraphicElement &graphic)
 {
-    static std::vector<BelId> ret;
-    return ret;
+    frame_graphics.push_back(graphic);
+    frameGraphicsReload = true;
 }
 
-const std::vector<BelId> &Arch::getBelsByType(BelType type) const
+void Arch::addWireGraphic(WireId wire, const GraphicElement &graphic)
 {
-    static std::vector<BelId> ret;
-    return ret;
+    wires.at(wire).graphics.push_back(graphic);
+    wireGraphicsReload.insert(wire);
 }
 
-BelType Arch::getBelType(BelId bel) const { return BelType(); }
-
-WireId Arch::getWireBelPin(BelId bel, PortPin pin) const { return WireId(); }
-
-BelPin Arch::getBelPinUphill(WireId wire) const { return BelPin(); }
+void Arch::addPipGraphic(PipId pip, const GraphicElement &graphic)
+{
+    pips.at(pip).graphics.push_back(graphic);
+    pipGraphicsReload.insert(pip);
+}
 
-const std::vector<BelPin> &Arch::getBelPinsDownhill(WireId wire) const
+void Arch::addBelGraphic(BelId bel, const GraphicElement &graphic)
 {
-    static std::vector<BelPin> ret;
-    return ret;
+    bels.at(bel).graphics.push_back(graphic);
+    belGraphicsReload.insert(bel);
 }
 
 // ---------------------------------------------------------------
 
-WireId Arch::getWireByName(IdString name) const { return WireId(); }
-
-IdString Arch::getWireName(WireId wire) const { return IdString(); }
+Arch::Arch(ArchArgs) {}
 
-uint32_t Arch::getWireChecksum(WireId wire) const { return 0; }
+void IdString::initialize_arch(const BaseCtx *ctx) {}
 
-void Arch::bindWire(WireId wire, IdString net, PlaceStrength strength) {}
+// ---------------------------------------------------------------
 
-void Arch::unbindWire(WireId wire) {}
+BelId Arch::getBelByName(IdString name) const
+{
+    if (bels.count(name))
+        return name;
+    return BelId();
+}
 
-bool Arch::checkWireAvail(WireId wire) const { return false; }
+IdString Arch::getBelName(BelId bel) const { return bel; }
 
-IdString Arch::getBoundWireNet(WireId wire) const { return IdString(); }
+uint32_t Arch::getBelChecksum(BelId bel) const
+{
+    // FIXME
+    return 0;
+}
 
-IdString Arch::getConflictingWireNet(WireId wire) const { return IdString(); }
+void Arch::bindBel(BelId bel, IdString cell, PlaceStrength strength)
+{
+    bels.at(bel).bound_cell = cell;
+    cells.at(cell)->bel = bel;
+    cells.at(cell)->belStrength = strength;
+}
 
-const std::vector<WireId> &Arch::getWires() const
+void Arch::unbindBel(BelId bel)
 {
-    static std::vector<WireId> ret;
-    return ret;
+    cells.at(bels.at(bel).bound_cell)->bel = BelId();
+    cells.at(bels.at(bel).bound_cell)->belStrength = STRENGTH_NONE;
+    bels.at(bel).bound_cell = IdString();
 }
 
-// ---------------------------------------------------------------
+bool Arch::checkBelAvail(BelId bel) const { return bels.at(bel).bound_cell == IdString(); }
 
-PipId Arch::getPipByName(IdString name) const { return PipId(); }
+IdString Arch::getBoundBelCell(BelId bel) const { return bels.at(bel).bound_cell; }
 
-IdString Arch::getPipName(PipId pip) const { return IdString(); }
+IdString Arch::getConflictingBelCell(BelId bel) const { return bels.at(bel).bound_cell; }
 
-uint32_t Arch::getPipChecksum(PipId wire) const { return 0; }
+const std::vector<BelId> &Arch::getBels() const { return bel_ids; }
 
-void Arch::bindPip(PipId pip, IdString net, PlaceStrength strength) {}
+const std::vector<BelId> &Arch::getBelsByType(BelType type) const
+{
+    static std::vector<BelId> empty_list;
+    if (bel_ids_by_type.count(type))
+        return bel_ids_by_type.at(type);
+    return empty_list;
+}
+
+BelType Arch::getBelType(BelId bel) const { return bels.at(bel).type; }
 
-void Arch::unbindPip(PipId pip) {}
+WireId Arch::getWireBelPin(BelId bel, PortPin pin) const { return bels.at(bel).pins.at(pin).wire; }
 
-bool Arch::checkPipAvail(PipId pip) const { return false; }
+BelPin Arch::getBelPinUphill(WireId wire) const { return wires.at(wire).uphill_bel_pin; }
 
-IdString Arch::getBoundPipNet(PipId pip) const { return IdString(); }
+const std::vector<BelPin> &Arch::getBelPinsDownhill(WireId wire) const { return wires.at(wire).downhill_bel_pins; }
 
-IdString Arch::getConflictingPipNet(PipId pip) const { return IdString(); }
+// ---------------------------------------------------------------
 
-const std::vector<PipId> &Arch::getPips() const
+WireId Arch::getWireByName(IdString name) const
 {
-    static std::vector<PipId> ret;
-    return ret;
+    if (wires.count(name))
+        return name;
+    return WireId();
 }
 
-WireId Arch::getPipSrcWire(PipId pip) const { return WireId(); }
-
-WireId Arch::getPipDstWire(PipId pip) const { return WireId(); }
-
-DelayInfo Arch::getPipDelay(PipId pip) const { return DelayInfo(); }
+IdString Arch::getWireName(WireId wire) const { return wire; }
 
-const std::vector<PipId> &Arch::getPipsDownhill(WireId wire) const
+uint32_t Arch::getWireChecksum(WireId wire) const
 {
-    static std::vector<PipId> ret;
-    return ret;
+    // FIXME
+    return 0;
 }
 
-const std::vector<PipId> &Arch::getPipsUphill(WireId wire) const
+void Arch::bindWire(WireId wire, IdString net, PlaceStrength strength)
 {
-    static std::vector<PipId> ret;
-    return ret;
+    wires.at(wire).bound_net = net;
+    nets.at(net)->wires[wire].pip = PipId();
+    nets.at(net)->wires[wire].strength = strength;
 }
 
-const std::vector<PipId> &Arch::getWireAliases(WireId wire) const
+void Arch::unbindWire(WireId wire)
 {
-    static std::vector<PipId> ret;
-    return ret;
+    auto &net_wires = nets[wires.at(wire).bound_net]->wires;
+
+    auto pip = net_wires.at(wire).pip;
+    if (pip != PipId())
+        pips.at(pip).bound_net = IdString();
+
+    net_wires.erase(wire);
+    wires.at(wire).bound_net = IdString();
 }
 
+bool Arch::checkWireAvail(WireId wire) const { return wires.at(wire).bound_net == IdString(); }
+
+IdString Arch::getBoundWireNet(WireId wire) const { return wires.at(wire).bound_net; }
+
+IdString Arch::getConflictingWireNet(WireId wire) const { return wires.at(wire).bound_net; }
+
+const std::vector<WireId> &Arch::getWires() const { return wire_ids; }
+
 // ---------------------------------------------------------------
 
-void Arch::estimatePosition(BelId bel, int &x, int &y, bool &gb) const
+PipId Arch::getPipByName(IdString name) const
 {
-    x = 0;
-    y = 0;
-    gb = false;
+    if (pips.count(name))
+        return name;
+    return PipId();
 }
 
-delay_t Arch::estimateDelay(WireId src, WireId dst) const { return 0.0; }
+IdString Arch::getPipName(PipId pip) const { return pip; }
 
-// ---------------------------------------------------------------
+uint32_t Arch::getPipChecksum(PipId wire) const
+{
+    // FIXME
+    return 0;
+}
 
-std::vector<GraphicElement> Arch::getFrameGraphics() const
+void Arch::bindPip(PipId pip, IdString net, PlaceStrength strength)
 {
-    static std::vector<GraphicElement> ret;
-    return ret;
+    WireId wire = pips.at(pip).dstWire;
+    pips.at(pip).bound_net = net;
+    wires.at(wire).bound_net = net;
+    nets.at(net)->wires[wire].pip = pip;
+    nets.at(net)->wires[wire].strength = strength;
 }
 
-std::vector<GraphicElement> Arch::getBelGraphics(BelId bel) const
+void Arch::unbindPip(PipId pip)
 {
-    static std::vector<GraphicElement> ret;
-    return ret;
+    WireId wire = pips.at(pip).dstWire;
+    nets.at(wires.at(wire).bound_net)->wires.erase(wire);
+    pips.at(pip).bound_net = IdString();
+    wires.at(wire).bound_net = IdString();
 }
 
-std::vector<GraphicElement> Arch::getWireGraphics(WireId wire) const
+bool Arch::checkPipAvail(PipId pip) const { return pips.at(pip).bound_net == IdString(); }
+
+IdString Arch::getBoundPipNet(PipId pip) const { return pips.at(pip).bound_net; }
+
+IdString Arch::getConflictingPipNet(PipId pip) const { return pips.at(pip).bound_net; }
+
+const std::vector<PipId> &Arch::getPips() const { return pip_ids; }
+
+WireId Arch::getPipSrcWire(PipId pip) const { return pips.at(pip).srcWire; }
+
+WireId Arch::getPipDstWire(PipId pip) const { return pips.at(pip).dstWire; }
+
+DelayInfo Arch::getPipDelay(PipId pip) const { return pips.at(pip).delay; }
+
+const std::vector<PipId> &Arch::getPipsDownhill(WireId wire) const { return wires.at(wire).downhill; }
+
+const std::vector<PipId> &Arch::getPipsUphill(WireId wire) const { return wires.at(wire).uphill; }
+
+const std::vector<PipId> &Arch::getWireAliases(WireId wire) const { return wires.at(wire).aliases; }
+
+// ---------------------------------------------------------------
+
+void Arch::estimatePosition(BelId bel, int &x, int &y, bool &gb) const
 {
-    static std::vector<GraphicElement> ret;
-    return ret;
+    x = bels.at(bel).grid_x;
+    y = bels.at(bel).grid_y;
+    gb = bels.at(bel).gb;
 }
 
-std::vector<GraphicElement> Arch::getPipGraphics(PipId pip) const
+delay_t Arch::estimateDelay(WireId src, WireId dst) const
 {
-    static std::vector<GraphicElement> ret;
-    return ret;
+    const WireInfo &s = wires.at(src);
+    const WireInfo &d = wires.at(dst);
+    int dx = abs(s.grid_x - d.grid_x);
+    int dy = abs(s.grid_y - d.grid_y);
+    return (dx + dy) * grid_distance_to_delay;
 }
 
 // ---------------------------------------------------------------
 
+const std::vector<GraphicElement> &Arch::getFrameGraphics() const { return frame_graphics; }
+
+const std::vector<GraphicElement> &Arch::getBelGraphics(BelId bel) const { return bels.at(bel).graphics; }
+
+const std::vector<GraphicElement> &Arch::getWireGraphics(WireId wire) const { return wires.at(wire).graphics; }
+
+const std::vector<GraphicElement> &Arch::getPipGraphics(PipId pip) const { return pips.at(pip).graphics; }
+
+// ---------------------------------------------------------------
+
 bool Arch::getCellDelay(const CellInfo *cell, IdString fromPort, IdString toPort, delay_t &delay) const
 {
     return false;
diff --git a/generic/arch.h b/generic/arch.h
index 4280951c..9c2bee2e 100644
--- a/generic/arch.h
+++ b/generic/arch.h
@@ -32,7 +32,7 @@ struct WireInfo;
 struct PipInfo
 {
     IdString name, bound_net;
-    WireInfo *srcWire, *dstWire;
+    WireId srcWire, dstWire;
     DelayInfo delay;
     std::vector<GraphicElement> graphics;
 };
@@ -41,13 +41,16 @@ struct WireInfo
 {
     IdString name, bound_net;
     std::vector<GraphicElement> graphics;
-    std::vector<PipInfo*> downhill, uphill, aliases;
+    std::vector<PipId> downhill, uphill, aliases;
+    BelPin uphill_bel_pin;
+    std::vector<BelPin> downhill_bel_pins;
+    int grid_x, grid_y;
 };
 
 struct PinInfo
 {
     IdString name;
-    WireInfo *wire;
+    WireId wire;
     PortType type;
 };
 
@@ -56,6 +59,8 @@ struct BelInfo
     IdString name, type, bound_cell;
     std::unordered_map<IdString, PinInfo> pins;
     std::vector<GraphicElement> graphics;
+    int grid_x, grid_y;
+    bool gb;
 };
 
 struct Arch : BaseCtx
@@ -69,14 +74,22 @@ struct Arch : BaseCtx
     std::vector<IdString> bel_ids, wire_ids, pip_ids;
     std::unordered_map<IdString, std::vector<IdString>> bel_ids_by_type;
 
-    void addWire(IdString name);
+    std::vector<GraphicElement> frame_graphics;
+    float grid_distance_to_delay;
+
+    void addWire(IdString name, int x, int y);
     void addPip(IdString name, IdString srcWire, IdString dstWire, DelayInfo delay);
-    void addAias(IdString name, IdString srcWire, IdString dstWire, DelayInfo delay);
+    void addAlias(IdString name, IdString srcWire, IdString dstWire, DelayInfo delay);
+
+    void addBel(IdString name, IdString type, int x, int y, bool gb);
+    void addBelInput(IdString bel, IdString name, IdString wire);
+    void addBelOutput(IdString bel, IdString name, IdString wire);
+    void addBelInout(IdString bel, IdString name, IdString wire);
 
-    void addBel(IdString name, IdString type);
-    void addBelInput(IdString cell, IdString name, IdString wire);
-    void addBwlOutput(IdString cell, IdString name, IdString wire);
-    void addBelInout(IdString cell, IdString name, IdString wire);
+    void addFrameGraphic(const GraphicElement &graphic);
+    void addWireGraphic(WireId wire, const GraphicElement &graphic);
+    void addPipGraphic(PipId pip, const GraphicElement &graphic);
+    void addBelGraphic(BelId bel, const GraphicElement &graphic);
 
     // ---------------------------------------------------------------
 
@@ -141,10 +154,10 @@ struct Arch : BaseCtx
     float getDelayNS(delay_t v) const { return v; }
     uint32_t getDelayChecksum(delay_t v) const { return 0; }
 
-    std::vector<GraphicElement> getFrameGraphics() const;
-    std::vector<GraphicElement> getBelGraphics(BelId bel) const;
-    std::vector<GraphicElement> getWireGraphics(WireId wire) const;
-    std::vector<GraphicElement> getPipGraphics(PipId pip) const;
+    const std::vector<GraphicElement> &getFrameGraphics() const;
+    const std::vector<GraphicElement> &getBelGraphics(BelId bel) const;
+    const std::vector<GraphicElement> &getWireGraphics(WireId wire) const;
+    const std::vector<GraphicElement> &getPipGraphics(PipId pip) const;
 
     bool allGraphicsReload = false;
     bool frameGraphicsReload = false;