netlist.h

Go to the documentation of this file.

#ifndef NETLIST_H
#define NETLIST_H

#include <string>
#include <vector>
#include <unordered_map>
#include "vtr_range.h"
#include "vtr_logic.h"
#include "vtr_vector_map.h"

#include "logic_types.h"

#include "netlist_fwd.h"
#include "netlist_utils.h"

//Forward declaration for private methods
template<typename BlockId, typename PortId, typename PinId, typename NetId>
class NetlistIdRemapper {
  public:
    BlockId new_block_id(BlockId old_blk) const;
    PortId new_port_id(PortId old_port) const;
    PinId new_pin_id(PinId old_pin) const;
    NetId new_net_id(NetId old_net) const;

  private:
    friend Netlist<BlockId, PortId, PinId, NetId>;

    vtr::vector_map<BlockId, BlockId> block_id_map_;
    vtr::vector_map<PortId, PortId> port_id_map_;
    vtr::vector_map<PinId, PinId> pin_id_map_;
    vtr::vector_map<NetId, NetId> net_id_map_;
};

template<typename BlockId, typename PortId, typename PinId, typename NetId>
class Netlist {
  public: //Public Types
    typedef typename vtr::vector_map<BlockId, BlockId>::const_iterator block_iterator;
    typedef typename std::unordered_map<std::string, std::string>::const_iterator attr_iterator;
    typedef typename std::unordered_map<std::string, std::string>::const_iterator param_iterator;
    typedef typename vtr::vector_map<NetId, NetId>::const_iterator net_iterator;
    typedef typename vtr::vector_map<PinId, PinId>::const_iterator pin_iterator;
    typedef typename vtr::vector_map<PortId, PortId>::const_iterator port_iterator;

    typedef typename vtr::Range<block_iterator> block_range;
    typedef typename vtr::Range<attr_iterator> attr_range;
    typedef typename vtr::Range<param_iterator> param_range;
    typedef typename vtr::Range<net_iterator> net_range;
    typedef typename vtr::Range<pin_iterator> pin_range;
    typedef typename vtr::Range<port_iterator> port_range;

    typedef NetlistIdRemapper<BlockId, PortId, PinId, NetId> IdRemapper;

  public:
    Netlist(std::string name = "", std::string id = "");
    virtual ~Netlist();

  public: //Public Accessors
    /*
     * Netlist
     */
    const std::string& netlist_name() const;

    const std::string& netlist_id() const;

    /*
     * Utility
     */

    bool verify() const;

    bool is_dirty() const;

    bool is_compressed() const;

    void print_stats() const;

    /*
     * Blocks
     */

    const std::string& block_name(const BlockId blk_id) const;

    bool block_is_combinational(const BlockId blk_id) const;

    attr_range block_attrs(const BlockId blk_id) const;

    param_range block_params(const BlockId blk_id) const;

    pin_range block_pins(const BlockId blk_id) const;

    pin_range block_input_pins(const BlockId blk_id) const;

    pin_range block_output_pins(const BlockId blk_id) const;

    pin_range block_clock_pins(const BlockId blk_id) const;

    port_range block_ports(const BlockId blk_id) const;

    port_range block_input_ports(const BlockId blk_id) const;

    port_range block_output_ports(const BlockId blk_id) const;

    port_range block_clock_ports(const BlockId blk_id) const;

    void remove_block(const BlockId blk_id);

    /*
     * Ports
     */

    const std::string& port_name(const PortId port_id) const;

    BlockId port_block(const PortId port_id) const;

    pin_range port_pins(const PortId port_id) const;

    PinId port_pin(const PortId port_id, const BitIndex port_bit) const;

    NetId port_net(const PortId port_id, const BitIndex port_bit) const;

    BitIndex port_width(const PortId port_id) const;

    PortType port_type(const PortId port_id) const;

    void remove_port(const PortId port_id);

    /*
     * Pins
     */

    std::string pin_name(const PinId pin_id) const;

    PinType pin_type(const PinId pin_id) const;

    NetId pin_net(const PinId pin_id) const;

    int pin_net_index(const PinId pin_id) const;

    PortId pin_port(const PinId pin_id) const;

    BitIndex pin_port_bit(const PinId pin_id) const;

    BlockId pin_block(const PinId pin_id) const;

    PortType pin_port_type(const PinId pin_id) const;

    bool pin_is_constant(const PinId pin_id) const;

    void remove_pin(const PinId pin_id);

    /*
     * Nets
     */

    const std::string& net_name(const NetId net_id) const;

    pin_range net_pins(const NetId net_id) const;

    PinId net_pin(const NetId net_id, int net_pin_index) const;

    BlockId net_pin_block(const NetId net_id, int net_pin_index) const;

    PinId net_driver(const NetId net_id) const;

    BlockId net_driver_block(const NetId net_id) const;

    pin_range net_sinks(const NetId net_id) const;

    bool net_is_constant(const NetId net_id) const;

    void remove_net(const NetId net_id);

    void remove_net_pin(const NetId net_id, const PinId pin_id);

    /*
     * Aggregates
     */

    block_range blocks() const;

    port_range ports() const;

    net_range nets() const;

    pin_range pins() const;

    /*
     * ID Checks
     *
     * Validates that the specified ID is valid in the current netlist state
     */
    bool valid_block_id(BlockId block_id) const;
    bool valid_port_id(PortId port_id) const;
    bool valid_port_bit(PortId port_id, BitIndex port_bit) const;
    bool valid_pin_id(PinId pin_id) const;
    bool valid_net_id(NetId net_id) const;

    /*
     * Lookups
     */

    BlockId find_block(const std::string& name) const;

    PortId find_port(const BlockId blk_id, const std::string& name) const;

    NetId find_net(const std::string& name) const;

    PinId find_pin(const PortId port_id, BitIndex port_bit) const;

    PinId find_pin(const std::string name) const;

  public: //Public Mutators
    void set_pin_net(const PinId pin, PinType pin_type, const NetId net);

    void set_pin_is_constant(const PinId pin_id, const bool value);

    void set_block_name(const BlockId blk_id, const std::string new_name);

    void set_block_attr(const BlockId blk_id, const std::string& name, const std::string& value);

    void set_block_param(const BlockId blk_id, const std::string& name, const std::string& value);

    void merge_nets(const NetId driver_net, const NetId sink_net);

    /*
     * Note: all remove_*() will mark the associated items as invalid, but the items
     * will not be removed until compress() is called.
     */

    IdRemapper remove_and_compress();

    void remove_unused();

    IdRemapper compress();

  protected: //Protected Mutators
    BlockId create_block(const std::string name);

    PortId create_port(const BlockId blk_id, const std::string name, BitIndex width, PortType type);

    PinId create_pin(const PortId port_id, BitIndex port_bit, const NetId net_id, const PinType pin_type, bool is_const = false);

    NetId create_net(const std::string name); //An empty or existing net

    NetId add_net(const std::string name, PinId driver, std::vector<PinId> sinks);

  protected: //Protected Base Types
    struct string_id_tag;

    typedef vtr::StrongId<string_id_tag> StringId;

  protected: //Protected Base Members
    /*
     * Lookups
     */

    StringId find_string(const std::string& str) const;

    BlockId find_block(const StringId name_id) const;

    NetId find_net(const StringId name_id) const;

    /*
     * Mutators
     */

    StringId create_string(const std::string& str);

    int associate_pin_with_net(const PinId pin_id, const PinType type, const NetId net_id);

    void associate_pin_with_port(const PinId pin_id, const PortId port_id);

    void associate_pin_with_block(const PinId pin_id, const PortType type, const BlockId blk_id);

    void associate_port_with_block(const PortId port_id, const PortType type, const BlockId blk_id);

    /*
     * Netlist compression/optimization
     */

    IdRemapper build_id_maps();

    void clean_blocks(const vtr::vector_map<BlockId, BlockId>& block_id_map);

    void clean_ports(const vtr::vector_map<PortId, PortId>& port_id_map);

    void clean_pins(const vtr::vector_map<PinId, PinId>& pin_id_map);

    void clean_nets(const vtr::vector_map<NetId, NetId>& net_id_map);

    void rebuild_lookups();

    void rebuild_block_refs(const vtr::vector_map<PinId, PinId>& pin_id_map,
                            const vtr::vector_map<PortId, PortId>& port_id_map);

    void rebuild_port_refs(const vtr::vector_map<BlockId, BlockId>& block_id_map,
                           const vtr::vector_map<PinId, PinId>& pin_id_map);

    void rebuild_pin_refs(const vtr::vector_map<PortId, PortId>& port_id_map,
                          const vtr::vector_map<NetId, NetId>& net_id_map);

    void rebuild_net_refs(const vtr::vector_map<PinId, PinId>& pin_id_map);

    void shrink_to_fit();

    /*
     * Sanity Checks
     */

    //Verify the internal data structure sizes match
    bool verify_sizes() const;
    bool validate_block_sizes() const;
    bool validate_port_sizes() const;
    bool validate_pin_sizes() const;
    bool validate_net_sizes() const;
    bool validate_string_sizes() const;

    //Verify that internal data structure cross-references are consistent
    bool verify_refs() const; //All cross-references
    bool validate_block_port_refs() const;
    bool validate_block_pin_refs() const;
    bool validate_port_pin_refs() const;
    bool validate_net_pin_refs() const;
    bool validate_string_refs() const;

    bool verify_block_invariants() const;

    bool verify_lookups() const;

    bool valid_string_id(StringId string_id) const;

  protected: //Protected virtual functions implemented in derived classes
    //The functions follow the Non-Virtual Interface (NVI) idiom, and
    //are called from this class in their respective non-impl() functions.
    virtual void shrink_to_fit_impl() = 0;

    virtual bool validate_block_sizes_impl(size_t num_blocks) const = 0;
    virtual bool validate_port_sizes_impl(size_t num_ports) const = 0;
    virtual bool validate_pin_sizes_impl(size_t num_pins) const = 0;
    virtual bool validate_net_sizes_impl(size_t num_nets) const = 0;

    virtual void clean_blocks_impl(const vtr::vector_map<BlockId, BlockId>& block_id_map) = 0;
    virtual void clean_ports_impl(const vtr::vector_map<PortId, PortId>& port_id_map) = 0;
    virtual void clean_pins_impl(const vtr::vector_map<PinId, PinId>& pin_id_map) = 0;
    virtual void clean_nets_impl(const vtr::vector_map<NetId, NetId>& net_id_map) = 0;

    virtual void remove_block_impl(const BlockId blk_id) = 0;
    virtual void remove_port_impl(const PortId port_id) = 0;
    virtual void remove_pin_impl(const PinId pin_id) = 0;
    virtual void remove_net_impl(const NetId net_id) = 0;

    virtual void rebuild_block_refs_impl(const vtr::vector_map<PinId, PinId>& pin_id_map, const vtr::vector_map<PortId, PortId>& port_id_map) = 0;
    virtual void rebuild_port_refs_impl(const vtr::vector_map<BlockId, BlockId>& block_id_map, const vtr::vector_map<PinId, PinId>& pin_id_map) = 0;
    virtual void rebuild_pin_refs_impl(const vtr::vector_map<PortId, PortId>& port_id_map, const vtr::vector_map<NetId, NetId>& net_id_map) = 0;
    virtual void rebuild_net_refs_impl(const vtr::vector_map<PinId, PinId>& pin_id_map) = 0;

  protected:
    constexpr static int INVALID_INDEX = -1;
    constexpr static int NET_DRIVER_INDEX = 0;

  private:                     //Data
    std::string netlist_name_; 
    std::string netlist_id_;   
    bool dirty_ = false;       
    //Block data
    vtr::vector_map<BlockId, BlockId> block_ids_;    
    vtr::vector_map<BlockId, StringId> block_names_; 
    vtr::vector_map<BlockId, std::vector<PortId>> block_ports_; 
    vtr::vector_map<BlockId, unsigned> block_num_input_ports_;  
    vtr::vector_map<BlockId, unsigned> block_num_output_ports_; 
    vtr::vector_map<BlockId, unsigned> block_num_clock_ports_;  
    vtr::vector_map<BlockId, std::vector<PinId>> block_pins_;  
    vtr::vector_map<BlockId, unsigned> block_num_input_pins_;  
    vtr::vector_map<BlockId, unsigned> block_num_output_pins_; 
    vtr::vector_map<BlockId, unsigned> block_num_clock_pins_;  
    vtr::vector_map<BlockId, std::unordered_map<std::string, std::string>> block_params_; 
    vtr::vector_map<BlockId, std::unordered_map<std::string, std::string>> block_attrs_;  
    //Port data
    vtr::vector_map<PortId, PortId> port_ids_;              
    vtr::vector_map<PortId, StringId> port_names_;          
    vtr::vector_map<PortId, BlockId> port_blocks_;          
    vtr::vector_map<PortId, std::vector<PinId>> port_pins_; 
    vtr::vector_map<PortId, BitIndex> port_widths_;         
    vtr::vector_map<PortId, PortType> port_types_;          
    //Pin data
    vtr::vector_map<PinId, PinId> pin_ids_;          
    vtr::vector_map<PinId, PortId> pin_ports_;       
    vtr::vector_map<PinId, BitIndex> pin_port_bits_; 
    vtr::vector_map<PinId, NetId> pin_nets_;         
    vtr::vector_map<PinId, int> pin_net_indices_;    
    vtr::vector_map<PinId, bool> pin_is_constant_;   
    //Net data
    vtr::vector_map<NetId, NetId> net_ids_;               
    vtr::vector_map<NetId, StringId> net_names_;          
    vtr::vector_map<NetId, std::vector<PinId>> net_pins_; 
    //String data
    // We store each unique string once, and reference it by an StringId
    // This avoids duplicating the strings in the fast look-ups (i.e. the look-ups
    // only store the Ids)
    vtr::vector_map<StringId, StringId> string_ids_; 
    vtr::vector_map<StringId, std::string> strings_; 
  private: //Fast lookups
    vtr::vector_map<StringId, BlockId> block_name_to_block_id_;
    vtr::vector_map<StringId, NetId> net_name_to_net_id_;
    std::unordered_map<std::string, StringId> string_to_string_id_;
};

#include "netlist.tpp"
#endif