PartMgrBase.hpp

Go to the documentation of this file.

 
#pragma once
 
// **Special code for two-pin nets**
// Take a snapshot when a move make **negative** gain.
// Snapshot in the form of "interface"???
 
#include <cstdint>  // for uint8_t
#include <span>     // for span
#include <vector>   // for vector
// #include <xnetwork/classes/graph.hpp>
 
// forward declare
// template <typename graph_t> struct Netlist;
// using SimpleNetlist = Netlist<xnetwork::SimpleGraph>;
 
enum class LegalCheck;
 
template <typename Gnl, typename GainMgr, typename ConstrMgr>  //
class PartMgrBase {
  public:
    using GainCalc_ = typename GainMgr::GainCalc_;
    using GainMgr_ = GainMgr;
    using ConstrMgr_ = ConstrMgr;
 
    // using Der = Derived<Gnl, GainMgr, ConstrMgr>;
 
  protected:
    const Gnl& hyprgraph;
    GainMgr& gain_mgr;
    ConstrMgr& validator;
    size_t num_parts;
    // std::vector<std::uint8_t> snapshot;
    // std::vector<std::uint8_t> part;
 
  public:
    int total_cost{};
 
    PartMgrBase(const Gnl& hyprgraph, GainMgr& gain_mgr, ConstrMgr& constr_mgr, size_t num_parts)
        : hyprgraph{hyprgraph}, gain_mgr{gain_mgr}, validator{constr_mgr}, num_parts{num_parts} {}
 
    void init(std::span<std::uint8_t> part);
 
    auto legalize(std::span<std::uint8_t> part) -> LegalCheck;
 
    void optimize(std::span<std::uint8_t> part);
 
  private:
    void _optimize_1pass(std::span<std::uint8_t> part);
 
    auto final_check(std::span<const std::uint8_t> part) -> bool {
        return this->validator.final_check(part);
    }
 
    auto take_snapshot(std::span<const std::uint8_t> part) -> std::vector<std::uint8_t> {
        // const auto N = part.size();
        // auto snapshot = std::vector<std::uint8_t>(N, 0U);
        // // snapshot.reserve(N);
        // for (auto i = 0U; i != N; ++i)
        // {
        //     snapshot[i] = part[i];
        // }
        auto snapshot = std::vector<std::uint8_t>(part.begin(), part.end());
        return snapshot;
    }
 
    auto restore_part(const std::vector<std::uint8_t>& snapshot, std::span<std::uint8_t> part)
        -> void {
        // std::copy(snapshot.begin(), snapshot.end(), part.begin());
        const auto N = part.size();
        for (auto idx = 0U; idx != N; ++idx) {
            part[idx] = snapshot[idx];
        }
    }
};