ClusterPlacer.h

Go to the documentation of this file.

 
#ifndef _CLUSTERPLACER
#define _CLUSTERPLACER
 
#include "DesignInfo.h"
#include "DeviceInfo.h"
#include "GraphPartitioner.h"
#include "PlacementInfo.h"
#include "SAPlacer.h"
#include "sysInfo.h"
#include <assert.h>
#include <fstream>
#include <iostream>
#include <map>
#include <mutex>
#include <semaphore.h>
#include <set>
#include <sstream>
#include <string>
#include <thread>
#include <vector>
 
class ClusterPlacer
{
  public:
    ClusterPlacer(PlacementInfo *placementInfo, std::map<std::string, std::string> &JSONCfg,
                  float connectionToFixedFactor = 5.0);
    ~ClusterPlacer()
    {
        if (saPlacer)
            delete saPlacer;
        if (basicGraphPartitioner)
            delete basicGraphPartitioner;
        if (userDefinedClusterBasedGraphPartitioner)
            delete userDefinedClusterBasedGraphPartitioner;
        for (auto tmpClusterUnit : clusterUnits)
        {
            delete tmpClusterUnit;
        }
        for (auto tmpClusterNet : clusterNets)
        {
            delete tmpClusterNet;
        }
    }
 
    void ClusterPlacement();
 
  private:
    PlacementInfo *placementInfo;
 
    std::vector<std::set<int>> clusters;
    std::map<std::string, std::string> &JSONCfg;
 
    float connectionToFixedFactor;
 
    float y2xRatio = 1.0;
    bool verbose;
 
    bool randomInitialPlacement = false;
 
    int avgClusterSizeRequirement = 40000;
 
    double maxMinCutRate = 0.0333;
 
    std::vector<std::pair<int, int>> cluster2XY;
 
    std::vector<std::pair<float, float>> cluster2FP_XY;
 
    //  the cluster-level netlist information
 
    std::vector<std::vector<float>> clusterAdjMat;
    std::vector<float> clusterCLBCellWeights;
    std::vector<float> clusterDSPCellWeights;
    std::vector<float> clusterBRAMCellWeights;
 
    std::vector<std::vector<float>> cluster2FixedUnitMat;
    std::vector<float> fixedX;
    std::vector<float> fixedY;
 
    std::vector<int> placementUnit2ClusterId;
 
    std::vector<int> placementUnitId2ClusterUnitId;
    std::vector<PlacementInfo::ClusterUnit *> clusterUnits;
    std::vector<PlacementInfo::ClusterNet *> clusterNets;
 
    int clockRegionXNum, clockRegionYNum;
 
    int jobs;
 
    SAPlacer *saPlacer = nullptr;
 
    GraphPartitioner<std::vector<PlacementInfo::PlacementUnit *>, std::vector<PlacementInfo::PlacementNet *>>
        *basicGraphPartitioner = nullptr;
 
    GraphPartitioner<std::vector<PlacementInfo::ClusterUnit *>, std::vector<PlacementInfo::ClusterNet *>>
        *userDefinedClusterBasedGraphPartitioner = nullptr;
 
    GraphPartitioner<std::vector<PlacementInfo::ClusterUnit *>, std::vector<PlacementInfo::ClusterNet *>>
        *clockBasedGraphPartitioner = nullptr;
 
    inline bool isDensePlacement()
    {
        return ((float)clusters.size() / (float)placementInfo->getDeviceInfo()->getClockRegionNumX() /
                (float)placementInfo->getDeviceInfo()->getClockRegionNumY()) > 0.6;
    }
 
    void resetClusterInfo()
    {
        placementUnitId2ClusterUnitId = std::vector<int>(placementInfo->getPlacementUnits().size(), -1);
        clusterUnits.clear();
        clusterNets.clear();
    }
 
    void creaeClusterNets()
    {
        // create the nets between the cluster units
        for (auto tmpNet : placementInfo->getPlacementNets())
        {
            PlacementInfo::ClusterNet *curClusterNet = new PlacementInfo::ClusterNet(clusterNets.size());
            clusterNets.push_back(curClusterNet);
            for (auto tmpPU : tmpNet->getUnits())
            {
                curClusterNet->addClusterUnit(clusterUnits[placementUnitId2ClusterUnitId[tmpPU->getId()]]);
            }
        }
 
        print_info("ClusterPlacer: #clusterNet=" + std::to_string(clusterNets.size()));
    }
 
    void setClusterNetsAdjMat();
 
    void hypergraphPartitioning();
 
    void basicPartitioning(int minClusterCellNum, int eachClusterDSPNum, int eachClusterBRAMNum);
 
    void clockBasedPartitioning(int minClusterCellNum, int eachClusterDSPNum, int eachClusterBRAMNum);
 
    void userDefinedClusterBasedPartitioning(int minClusterCellNum, int eachClusterDSPNum, int eachClusterBRAMNum);
 
    void createUserDefinedClusterBasedClusterUnits();
 
    void createLongPathClusterUnits();
 
    void createClockBasedClusterUnits();
 
    void createSinglePUClusterUnits();
 
    void refineClustersWithPredefinedClusters();
 
    void clusterPlacementUnits();
 
    void placeClusters();
 
    void placeUnitBaseOnClusterPlacement(const std::vector<std::pair<int, int>> &cluster2XY);
 
    bool isClustersToLarges();
 
    inline int getPlacementUnitMaxPathLen(PlacementInfo::PlacementUnit *curPU)
    {
 
        auto &timingNodes = placementInfo->getTimingInfo()->getSimplePlacementTimingInfo();
        if (auto unpacked = dynamic_cast<PlacementInfo::PlacementUnpackedCell *>(curPU))
        {
            if (unpacked->getCell()->isVirtualCell())
                return 0;
            return timingNodes[unpacked->getCell()->getCellId()]->getLongestPathLength();
        }
        else if (auto tmpMacro = dynamic_cast<PlacementInfo::PlacementMacro *>(curPU))
        {
            int maxLen = 0;
            for (auto tmpCell : tmpMacro->getCells())
            {
                if (tmpCell->isVirtualCell())
                    continue;
                int len = timingNodes[tmpCell->getCellId()]->getLongestPathLength();
                if (len > maxLen)
                    maxLen = len;
            }
            return maxLen;
        }
        return 0;
    }
 
    inline float random_float(float min, float max)
    {
        return ((float)random() / RAND_MAX) * (max - min) + min;
    }
 
    void dumpClusters();
 
    void drawClusters();
};
 
#endif