OpenFPGA/libopenfpga/libarchopenfpga/src/technology_library.h

#ifndef TECHNOLOGY_LIBRARY_H
#define TECHNOLOGY_LIBRARY_H

/********************************************************************
 * This file include the declaration of technology library
 *******************************************************************/
#include <string>
#include <map>
#include <array>

/* Headers from vtrutil library */
#include "vtr_vector.h"
#include "vtr_geometry.h"

#include "technology_library_fwd.h"

/********************************************************************
 * Types for technology library attributes
 * Industrial library: the .lib file which define technology  
 *                     This is ubiquitous in commercial vendors
 *                     For industry library, we allow users to define
 *                     process corners.
 * Academia library: the .pm file which define technology 
 *                   This is mainly used in PTM-like technology library 
 * PTM is the Predictive Technology Model provided by the Arizona
 * State University (ASU). Available at ptm.asu.edu
 *******************************************************************/
enum e_tech_lib_type {
  TECH_LIB_INDUSTRY,
  TECH_LIB_ACADEMIA,
  NUM_TECH_LIB_TYPES
};
/* Strings correspond to each technology library type */
constexpr std::array<const char*, NUM_TECH_LIB_TYPES> TECH_LIB_TYPE_STRING = {{"industry", "academia"}};

/********************************************************************
 * Types of model which may be defined in a technology library
 * 1. transistor 
 * 2. RRAM
 *******************************************************************/
enum e_tech_lib_model_type {
  TECH_LIB_MODEL_TRANSISTOR, 
  TECH_LIB_MODEL_RRAM, 
  NUM_TECH_LIB_MODEL_TYPES
};
/* Strings correspond to transistor type */
constexpr std::array<const char*, NUM_TECH_LIB_MODEL_TYPES> TECH_LIB_MODEL_TYPE_STRING = {{"transistor", "rram"}};

/********************************************************************
 * Types of transistors which may be defined in a technology library
 * 1. NMOS transistor 
 * 2. PMOS transistor 
 *******************************************************************/
enum e_tech_lib_transistor_type {
  TECH_LIB_TRANSISTOR_PMOS, 
  TECH_LIB_TRANSISTOR_NMOS, 
  NUM_TECH_LIB_TRANSISTOR_TYPES
};
/* Strings correspond to transistor type */
constexpr std::array<const char*, NUM_TECH_LIB_TRANSISTOR_TYPES> TECH_LIB_TRANSISTOR_TYPE_STRING = {{"pmos", "nmos"}};

/********************************************************************
 * A data structure to describe technology library
 *
 * Typical usage:
 * --------------
 *   // Create an empty technology library
 *   TechnologyLibrary tech_lib;
 *   // call your builder for technology library
 *   // Build the internal links for the technology library
 *   tech_lib.link_model_to_variation();
 *
 *******************************************************************/
class TechnologyLibrary {
  public: /* Types */
    typedef vtr::vector<TechnologyModelId, TechnologyModelId>::const_iterator technology_model_iterator;
    typedef vtr::vector<TechnologyVariationId, TechnologyVariationId>::const_iterator technology_variation_iterator;
    /* Create range */
    typedef vtr::Range<technology_model_iterator> technology_model_range;
    typedef vtr::Range<technology_variation_iterator> technology_variation_range;
  public:  /* Constructors */
    TechnologyLibrary();
  public: /* Accessors: aggregates */
    technology_model_range models() const;
    technology_variation_range variations() const;
    std::vector<TechnologyModelId> models_by_type(const enum e_tech_lib_model_type& type) const;
  public: /* Public Accessors: Basic data query on models */
    std::string model_name(const TechnologyModelId& model_id) const;
    TechnologyModelId model(const std::string& name) const;
    enum e_tech_lib_model_type model_type(const TechnologyModelId& model_id) const;
    enum e_tech_lib_type model_lib_type(const TechnologyModelId& model_id) const;
    std::string model_corner(const TechnologyModelId& model_id) const;
    std::string model_ref(const TechnologyModelId& model_id) const;
    std::string model_lib_path(const TechnologyModelId& model_id) const;
    float model_vdd(const TechnologyModelId& model_id) const;
    float model_pn_ratio(const TechnologyModelId& model_id) const;
  public: /* Public Accessors: Basic data query on transistors */
    std::string transistor_model_name(const TechnologyModelId& model_id,
                                      const e_tech_lib_transistor_type& transistor_type) const;
    float transistor_model_chan_length(const TechnologyModelId& model_id,
                                       const e_tech_lib_transistor_type& transistor_type) const;
    float transistor_model_min_width(const TechnologyModelId& model_id,
                                     const e_tech_lib_transistor_type& transistor_type) const;
    TechnologyVariationId transistor_model_variation(const TechnologyModelId& model_id,
                                                     const e_tech_lib_transistor_type& transistor_type) const;
  public: /* Public Accessors: Basic data query on RRAM models */
    float rram_rlrs(const TechnologyModelId& model_id) const;
    float rram_rhrs(const TechnologyModelId& model_id) const;
    TechnologyVariationId rram_variation(const TechnologyModelId& model_id) const;
  public: /* Public Accessors: Basic data query on variations */
    std::string variation_name(const TechnologyVariationId& variation_id) const;
    TechnologyVariationId variation(const std::string& name) const;
    float variation_abs_value(const TechnologyVariationId& variation_id) const;
    size_t variation_num_sigma(const TechnologyVariationId& variation_id) const;
  public: /* Public Mutators: model-related */
    TechnologyModelId add_model(const std::string& name);
    void set_model_type(const TechnologyModelId& model_id, 
                         const e_tech_lib_model_type& type);
    void set_model_lib_type(const TechnologyModelId& model_id, 
                            const e_tech_lib_type& lib_type);
    void set_model_corner(const TechnologyModelId& model_id, 
                           const std::string& corner);
    void set_model_ref(const TechnologyModelId& model_id, 
                              const std::string& model_ref);
    void set_model_lib_path(const TechnologyModelId& model_id, 
                             const std::string& lib_path);
    void set_model_vdd(const TechnologyModelId& model_id, 
                        const float& vdd);
    void set_model_pn_ratio(const TechnologyModelId& model_id, 
                             const float& pn_ratio);
  public: /* Public Mutators: transistor-related */
    void set_transistor_model_name(const TechnologyModelId& model_id, 
                                   const e_tech_lib_transistor_type& transistor_type,
                                   const std::string& model_name);
    void set_transistor_model_chan_length(const TechnologyModelId& model_id, 
                                          const e_tech_lib_transistor_type& transistor_type,
                                          const float& chan_length);
    void set_transistor_model_min_width(const TechnologyModelId& model_id, 
                                        const e_tech_lib_transistor_type& transistor_type,
                                        const float& min_width);
    void set_transistor_model_variation_name(const TechnologyModelId& model_id, 
                                             const e_tech_lib_transistor_type& transistor_type,
                                             const std::string& variation_name);
  public: /* Public Mutators: RRAM-related */
    void set_rram_rlrs(const TechnologyModelId& model_id, 
                       const float& rlrs);
    void set_rram_rhrs(const TechnologyModelId& model_id, 
                       const float& rhrs);
    void set_rram_variation_name(const TechnologyModelId& model_id, 
                                 const std::string& variation_name);
  public: /* Public Mutators: variation-related */
    TechnologyVariationId add_variation(const std::string& name);
    void set_variation_abs_value(const TechnologyVariationId& variation_id, const float& abs_value);
    void set_variation_num_sigma(const TechnologyVariationId& variation_id, const size_t& num_sigma);
  public: /* Public Mutators: linkers */
    void link_models_to_variations();
  public: /* Public invalidators/validators */
    bool valid_model_id(const TechnologyModelId& model_id) const;
    bool valid_variation_id(const TechnologyVariationId& variation_id) const;
  private: /* Internal data */
    /* Transistor-related fundamental information */
    /* Unique identifier for each model
     * A model could be either transistors (1 pair of PMOS and NMOS) or RRAMs  
     */
    vtr::vector<TechnologyModelId, TechnologyModelId> model_ids_;

    /* Unique name for each model. This is defined by XML file */
    vtr::vector<TechnologyModelId, std::string> model_names_;

    /* Type of each model, either transistors or RRAMs */
    vtr::vector<TechnologyModelId, e_tech_lib_model_type> model_types_;

    /* Type of models of each model, either industry or academia
     * This will lead to different ways when include these models
     * For industry models, we use .lib to include library
     * For academia models, we use .include to include library
     */
    vtr::vector<TechnologyModelId, e_tech_lib_type> model_lib_types_;

    /* Name of process corner to be used for each model
     * Users can define any string for the process corner they are going to use
     * But the corner name should be consistent with their library files
     * When this is enabled, the corner name will be added when 
     * include the models 
     * For example, for a industry model, .lib <lib_path> <corner_name>
     */
    vtr::vector<TechnologyModelId, std::string> model_corners_;

    /* The string used to instanciate the model models
     * This will really depend on the type of models
     * For most industry models, we can use 'M' to instanciate a transisitor
     * For some academia models, we have to use 'X' to do so
     */
    vtr::vector<TechnologyModelId, std::string> model_refs_;

    /* The path to the transistor models
     * This is going to be the <lib_path> when include the library files
     * See the example in the comments about process corner
     */
    vtr::vector<TechnologyModelId, std::string> model_lib_paths_;

    /* Operating voltage for the models. Unit: [V] */
    vtr::vector<TechnologyModelId, float> model_vdds_;

    /* The width ratio between PMOS and NMOS for a model group
     * This really depend the transistor technology
     * We recommend users to characterize driving strengths of
     * PMOS and NMOS using SPICE simulators 
     */
    vtr::vector<TechnologyModelId, float> model_pn_ratios_;

    /* The model name is the name that is defined in your library file.
     * For example, your NMOS transistor may be defined as 
     * .model nch
     * in some BSIM models. In this case, nch will be the model name
     * 
     * In the rest of these transistor-level parameters, we follow the same organization:
     * PMOS data will be stored in the first element of the array
     * NMOS data will be stored in the second element of the array
     */
    vtr::vector<TechnologyModelId, std::array<std::string, 2>> transistor_model_names_;

    /* The channel length of a transistor.
     * This should be defined by your technology vendor
     * For example, a 22nm technology, the channel length is around 22nm
     */
    vtr::vector<TechnologyModelId, std::array<float, 2>> transistor_model_chan_lengths_;

    /* The minimum width of a transistor.
     * This should be defined by your technology vendor
     */
    vtr::vector<TechnologyModelId, std::array<float, 2>> transistor_model_min_widths_;

    /* The variation name and id binded to PMOS and NMOS transistor
     * We expect users to provide the exact name of variation defined in this technology library
     * the name and id will be automatically matched by using function link_model_to_variation()
     */
    vtr::vector<TechnologyModelId, std::array<std::string, 2>> transistor_model_variation_names_;
    vtr::vector<TechnologyModelId, std::array<TechnologyVariationId, 2>> transistor_model_variation_ids_;

    /* ReRAM-related fundamental information: 
     * Low Resistance State (LRS) resistance will be stored in the x() part of vtr::Point
     * High Resistance State (HRS) resistance will be stored in the y() part of vtr::Point 
     * Unit: [Ohm]
     */
    vtr::vector<TechnologyModelId, vtr::Point<float>> rram_resistances_;

    /* The variation name and id binded to this RRAM
     * We expect users to provide the exact name of variation defined in this technology library
     * the name and id will be automatically matched by using function link_model_to_variation()
     */
    vtr::vector<TechnologyModelId, std::string> rram_variation_names_;
    vtr::vector<TechnologyModelId, TechnologyVariationId> rram_variation_ids_;
    
	/* Unique identifier for each process variation */
    vtr::vector<TechnologyVariationId, TechnologyVariationId> variation_ids_;
    vtr::vector<TechnologyVariationId, std::string> variation_names_;
    
    /* Absoluate and standard deviation of a process variation 
     * These are used to apply manual process variations 
     * in case your technology vender does not provide any
     */
    vtr::vector<TechnologyVariationId, float> variation_abs_values_;
    vtr::vector<TechnologyVariationId, size_t> variation_num_sigmas_;

    /* Fast name-to-id lookup */
    std::map<std::string, TechnologyModelId> model_name2ids_;
    std::map<std::string, TechnologyVariationId> variation_name2ids_;
};

#endif