FMKWayGainMgr.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <span>
 
#include "FMGainMgr.hpp"
#include "FMKWayGainCalc.hpp"
 
// forward declare
template <typename Node> struct MoveInfo;
template <typename Node> struct MoveInfoV;
 
template <typename Gnl> class FMKWayGainMgr
    : public FMGainMgr<Gnl, FMKWayGainCalc<Gnl>, FMKWayGainMgr<Gnl>> {
  private:
    fun::Robin<std::uint8_t> rr;
 
  public:
    using Base = FMGainMgr<Gnl, FMKWayGainCalc<Gnl>, FMKWayGainMgr<Gnl>>;
    using GainCalc_ = FMKWayGainCalc<Gnl>;
    using node_t = typename Gnl::node_t;
 
    FMKWayGainMgr(const Gnl& hyprgraph, std::uint8_t num_parts)
        : Base{hyprgraph, num_parts}, rr{num_parts} {}
 
    auto init(std::span<const std::uint8_t> part) -> int;
 
    auto modify_key(const node_t& w, std::uint8_t part_w, std::span<const int> keys) -> void {
        for (auto k : this->rr.exclude(part_w)) {
            auto& item = this->gain_calc.vertex_list[k][w];
            if (item.is_locked()) {
                continue;
            }
            this->gain_bucket[k].modify_key(item, keys[k]);
        }
    }
 
    auto update_move_v(const MoveInfoV<node_t>& move_info_v, int gain) -> void;
 
    auto lock(uint8_t whichPart, const node_t& v) -> void {
        auto& vlink = this->gain_calc.vertex_list[whichPart][v];
        this->gain_bucket[whichPart].detach(vlink);
        vlink.lock();
    }
 
    auto lock_all(uint8_t /*from_part*/, const node_t& v) -> void {
        // for (const auto& [vlist, bckt] :
        //     views::zip(this->gain_calc.vertex_list, this->gain_bucket))
        auto bckt_it = this->gain_bucket.begin();
        for (auto& vlist : this->gain_calc.vertex_list) {
            auto& vlink = vlist[v];
            bckt_it->detach(vlink);
            vlink.lock();  // lock
            ++bckt_it;
        }
    }
 
  private:
    auto _set_key(uint8_t whichPart, const node_t& v, int key) -> void {
        this->gain_bucket[whichPart].set_key(this->gain_calc.vertex_list[whichPart][v], key);
    }
};