vpr/src/route/cb_metrics.h

#ifndef CB_METRICS_H
#define CB_METRICS_H

#include <vector>
#include <set>

#define MAX_OUTER_ITERATIONS 100000
#define MAX_INNER_ITERATIONS 10
#define INITIAL_TEMP 1
#define LOWEST_TEMP 0.00001
#define TEMP_DECREASE_FAC 0.999

/**** Enums ****/
/* Defines the different kinds of metrics that we can adjust */
enum e_metric {
    WIRE_HOMOGENEITY = 0,
    HAMMING_PROXIMITY,
    LEMIEUX_COST_FUNC, /* described by lemieux in his 2001 book; used there for creating routable sparse crossbars */
    NUM_WIRE_METRICS,
    PIN_DIVERSITY,
    NUM_METRICS
};

/**** Typedefs ****/
/* 2D vector of integers */
typedef std::vector<std::vector<int> > t_2d_int_vec;
/* 3D vector of integers */
typedef std::vector<std::vector<std::vector<int> > > t_3d_int_vec;
/* a vector of vectors of integer sets. used for pin-to-track and track-to-pin lookups */
typedef std::vector<std::vector<std::set<int> > > t_vec_vec_set;

/**** Classes ****/
/* Contains various useful structures to calculate connection block metrics, and is used to
 * hold the CB metrics themselves */
class Conn_Block_Metrics {
  public:
    /* the actual metrics */
    float pin_diversity;
    float wire_homogeneity;
    float hamming_proximity;
    float lemieux_cost_func;

    int num_wire_types;         /* the number of different wire types, used for computing pin diversity */
    t_2d_int_vec pin_locations; /* [0..3][0..num_on_this_side-1]. Keeps track of which pins come out on which side of the block */

    /* these vectors simplify the calculation of the various metrics */
    t_vec_vec_set track_to_pins;        /* [0..3][0..W-1][0..pins_connected-1]. A convenient lookup for which pins connect to a given track */
    t_vec_vec_set pin_to_tracks;        /* [0..3][0..num_pins_on_side-1][0..tracks_connected-1]. A lookup for which tracks connect to a given pin */
    t_3d_int_vec wire_types_used_count; /* [0..3][0..num_pins_on_side-1][0..num_wire_types-1]. Keeps track of how many times each pin connects to each of the wire types */

    void clear() {
        pin_diversity = wire_homogeneity = hamming_proximity = lemieux_cost_func = 0;
        num_wire_types = 0;
        pin_locations.clear();
        track_to_pins.clear();
        pin_to_tracks.clear();
        wire_types_used_count.clear();
    }
};

/**** Function Declarations ****/

/* wires may be grouped in a channel according to their start points. i.e. at a given channel segment with L=4, there are up to
 * four 'types' of L=4 wires: those that start in this channel segment, those than end in this channel segment, and two types
 * that are in between. here we return the number of wire types.
 * the current connection block metrics code can only deal with channel segments that carry wires of only one length (i.e. L=4).
 * this may be enhanced in the future. */
int get_num_wire_types(const int num_segments, const t_segment_inf* segment_inf);

/* calculates all the connection block metrics and returns them through the cb_metrics variable */
void get_conn_block_metrics(const t_type_ptr block_type, int***** tracks_connected_to_pin, const int num_segments, const t_segment_inf* segment_inf, const e_pin_type pin_type, const int* Fc_array, const t_chan_width* chan_width_inf, Conn_Block_Metrics* cb_metrics);
/* adjusts the connection block until the appropriate wire metric has hit it's target value. the pin metric is kept constant
 * within some tolerance */
void adjust_cb_metric(const e_metric metric, const float target, const float target_tolerance, const t_type_ptr block_type, int***** pin_to_track_connections, const e_pin_type pin_type, const int* Fc_array, const t_chan_width* chan_width_inf, const int num_segments, const t_segment_inf* segment_inf);

/**** EXPERIMENTAL ****/
#include <map>

class Wire_Counting {
  public:
    Wire_Counting() = default;

    /* number of wires in this wire group (here, wires are grouped by the number of switches they carry) */
    int num_wires = 0;
    /* map key is number of wires used. element represents how many times, over all possible configurations of the switches
     * in the channel, 'map key' wires from this wire group is used */
    std::map<int, long double> configs_used;

    /* the probabilistic expectation of how many wires will actually be used */
    float expectation_available = 0.;
};

typedef std::vector<std::vector<float> > t_xbar_matrix;

/* perform a probabilistic analysis on the compound crossbar formed by the input and output connection blocks */
void analyze_conn_blocks(const int***** opin_cb, const int***** ipin_cb, const t_type_ptr block_type, const int* Fc_array_out, const int* Fc_array_in, const t_chan_width* chan_width_inf);

/* make a poor cb pattern. */
void make_poor_cb_pattern(const e_pin_type pin_type, const t_type_ptr block_type, const int* Fc_array, const t_chan_width* chan_width_inf, int***** cb);

/**** END EXPERIMENTAL ****/

#endif /*CB_METRICS_H*/