133 lines
6.0 KiB
C++
133 lines
6.0 KiB
C++
#ifndef RR_GRAPH_CLOCK_H
|
|
#define RR_GRAPH_CLOCK_H
|
|
|
|
#include <string>
|
|
#include <vector>
|
|
#include <memory>
|
|
#include <unordered_map>
|
|
#include <set>
|
|
#include <utility>
|
|
|
|
#include "clock_fwd.h"
|
|
|
|
#include "clock_network_builders.h"
|
|
#include "clock_connection_builders.h"
|
|
|
|
#include "rr_graph_fwd.h"
|
|
|
|
class ClockNetwork;
|
|
class ClockConnection;
|
|
|
|
class SwitchPoint {
|
|
/* A switch point object: keeps information on the location and and rr_node indices
|
|
* for a certain clock switch. clock connections are grouped with their own unique
|
|
* name; this object holds information for only one such grouping.
|
|
* Examples of SwitchPoint(s) are rib-to-spine, driver-to-spine. */
|
|
public:
|
|
// [grid_width][grid_height][0..nodes_at_this_location-1]
|
|
std::vector<std::vector<std::vector<RRNodeId>>> rr_node_indices;
|
|
// Set of all the locations for this switch point. Used to quickly find
|
|
// if the switch point exists at a certian location.
|
|
std::set<std::pair<int, int>> locations; // x,y
|
|
public:
|
|
/** Getters **/
|
|
std::vector<RRNodeId> get_rr_node_indices_at_location(int x, int y) const;
|
|
|
|
std::set<std::pair<int, int>> get_switch_locations() const;
|
|
|
|
/** Setters **/
|
|
void insert_node_idx(int x, int y, const RRNodeId& node_idx);
|
|
};
|
|
|
|
class SwitchPoints {
|
|
/* This Class holds a map from a uniquely named switch to all of its locations on
|
|
* the device and its rr_node_indices. The location and rr_node_indices are stored
|
|
* in the SwitchPoint object*/
|
|
public:
|
|
std::unordered_map<std::string, SwitchPoint> switch_point_name_to_switch_location;
|
|
|
|
public:
|
|
/** Getters **/
|
|
|
|
/* Example: x,y = middle of the chip, switch_point_name == name of main drive
|
|
* of global clock spine, returns the rr_nodes of all the clock spines that
|
|
* start the newtork there*/
|
|
std::vector<RRNodeId> get_rr_node_indices_at_location(std::string switch_point_name,
|
|
int x,
|
|
int y) const;
|
|
|
|
std::set<std::pair<int, int>> get_switch_locations(std::string switch_point_name) const;
|
|
|
|
/** Setters **/
|
|
void insert_switch_node_idx(std::string switch_point_name, int x, int y, const RRNodeId& node_idx);
|
|
};
|
|
|
|
class ClockRRGraphBuilder {
|
|
public:
|
|
/* Returns the current ptc num where the wire should be drawn and updates the
|
|
* channel width. Note: The ptc_num is determined by the channel width. The channel
|
|
* width global state gets incremented everytime there is a request for a new ptc_num*/
|
|
int get_and_increment_chanx_ptc_num();
|
|
int get_and_increment_chany_ptc_num();
|
|
|
|
public:
|
|
/* Reverse lookup for to find the clock source and tap locations for each clock_network
|
|
* The map key is the the clock network name and value are all the switch points*/
|
|
std::unordered_map<std::string, SwitchPoints> clock_name_to_switch_points;
|
|
|
|
/* Saves a map from switch rr_node idx -> {x, y} location */
|
|
void add_switch_location(std::string clock_name,
|
|
std::string switch_point_name,
|
|
int x,
|
|
int y,
|
|
const RRNodeId& node_index);
|
|
|
|
/* Returns the rr_node idx of the switch at location {x, y} */
|
|
std::vector<RRNodeId> get_rr_node_indices_at_switch_location(std::string clock_name,
|
|
std::string switch_point_name,
|
|
int x,
|
|
int y) const;
|
|
|
|
/* Returns all the switch locations for the a certain clock network switch */
|
|
std::set<std::pair<int, int>> get_switch_locations(std::string clock_name,
|
|
std::string switch_point_name) const;
|
|
|
|
public:
|
|
/* Creates the routing resourse (rr) graph of the clock network and appends it to the
|
|
* existing rr graph created in build_rr_graph for inter-block and intra-block routing. */
|
|
static void create_and_append_clock_rr_graph(std::vector<t_segment_inf>& segment_inf,
|
|
const float R_minW_nmos,
|
|
const float R_minW_pmos,
|
|
int wire_to_rr_ipin_switch,
|
|
const enum e_base_cost_type base_cost_type);
|
|
|
|
private:
|
|
/* loop over all of the clock networks and create their wires */
|
|
void create_clock_networks_wires(std::vector<std::unique_ptr<ClockNetwork>>& clock_networks,
|
|
int num_segments);
|
|
|
|
/* loop over all clock routing connections and create the switches and connections */
|
|
void create_clock_networks_switches(std::vector<std::unique_ptr<ClockConnection>>& clock_connections);
|
|
|
|
/* Adds the architecture switches that the clock rr_nodes use to the rr switches and
|
|
* maps the newly added rr_switches to the nodes.
|
|
* The input nodes_start_idx ~ corresponds to the rr_node index of the first node
|
|
* used to create the clock network. Every node from node_start_idx..rr_nodes.size-1
|
|
* is a node in the clock network.*/
|
|
// TODO: Change to account for swtich fanin. Note: this function is simular to
|
|
// remap_rr_node_switch_indices but does not take into account node fanin.
|
|
void add_rr_switches_and_map_to_nodes(size_t nodes_start_idx,
|
|
const float R_minW_nmos,
|
|
const float R_minW_pmos);
|
|
|
|
/* Returns the index of the newly added rr_switch. The rr_switch information is coppied
|
|
* in from the arch_switch information */
|
|
// TODO: Does not account for fanin information when copping Tdel. Note: this function
|
|
// is simular to load_rr_switch_inf but does not take into account node fanin.
|
|
int add_rr_switch_from_arch_switch_inf(int arch_switch_idx,
|
|
const float R_minW_nmos,
|
|
const float R_minW_pmos);
|
|
};
|
|
|
|
#endif
|