OpenFPGA/libopenfpga/libarchopenfpga/src/check_circuit_library.cpp

/************************************************************************
 * Function to perform fundamental checking for the circuit library 
 * such as 
 * 1. if default circuit models are defined 
 * 2. if any circuit models shared the same name or prefix 
 * 3. if nay circuit model miss mandatory ports 
 ***********************************************************************/

/* Headers from vtrutil library */
#include "vtr_assert.h"
#include "vtr_log.h"
#include "vtr_time.h"

#include "check_circuit_library.h"

/************************************************************************
 * Circuit models have unique names, return the number of errors 
 *  If not found, we give an error
 ***********************************************************************/
static  
size_t check_circuit_library_unique_names(const CircuitLibrary& circuit_lib) {
  size_t num_err = 0;

  for (size_t i = 0; i < circuit_lib.num_models(); ++i) {
    /* Skip for the last element, because the inner loop will access it */
    if (i == circuit_lib.num_models() - 1) {
      continue;
    }
    /* Get the name of reference */
    const std::string& i_name = circuit_lib.model_name(CircuitModelId(i));
    for (size_t j = i + 1; j < circuit_lib.num_models(); ++j) {
      /* Compare the name of candidate */
      const std::string& j_name = circuit_lib.model_name(CircuitModelId(j));
      /* Compare the name and skip for different names */
      if (0 != i_name.compare(j_name)) {
        continue;
      }
      VTR_LOG_ERROR("Circuit model(index=%d) and (index=%d) share the same name, which is invalid!\n",
                    i , j, i_name.c_str());
      /* Incremental the counter for errors */
      num_err++;
    }
  }

  return num_err;
}


/************************************************************************
 * Circuit models have unique names, return the number of errors 
 *  If not found, we give an error
 ***********************************************************************/
static 
size_t check_circuit_library_unique_prefix(const CircuitLibrary& circuit_lib) {
  size_t num_err = 0;

  for (size_t i = 0; i < circuit_lib.num_models(); ++i) {
    /* Skip for the last element, because the inner loop will access it */
    if (i == circuit_lib.num_models() - 1) {
      continue;
    }
    /* Get the name of reference */
    const std::string& i_prefix = circuit_lib.model_prefix(CircuitModelId(i));
    for (size_t j = i + 1; j < circuit_lib.num_models(); ++j) {
      /* Compare the name of candidate */
      const std::string& j_prefix = circuit_lib.model_prefix(CircuitModelId(j));
      /* Compare the name and skip for different prefix */
      if (0 != i_prefix.compare(j_prefix)) {
        continue;
      }
      VTR_LOG_ERROR("Circuit model(name=%s) and (name=%s) share the same prefix, which is invalid!\n",
                    circuit_lib.model_name(CircuitModelId(i)).c_str(),
                    circuit_lib.model_name(CircuitModelId(j)).c_str(),
                    i_prefix.c_str());
      /* Incremental the counter for errors */
      num_err++;
    }
  }

  return num_err;
}

/************************************************************************
 * A generic function to check the port list of a circuit model in a given type
 *  If not found, we give an error
 ***********************************************************************/
static 
size_t check_circuit_model_required(const CircuitLibrary& circuit_lib,
                                    const enum e_circuit_model_type& circuit_model_type_to_check) {
  size_t num_err = 0;

  /* We must have an IOPAD*/
  if ( 0 == circuit_lib.models_by_type(circuit_model_type_to_check).size()) {
    VTR_LOG_ERROR("At least one %s circuit model is required!\n",
                  CIRCUIT_MODEL_TYPE_STRING[size_t(circuit_model_type_to_check)]);
    /* Incremental the counter for errors */
    num_err++;
  }

  return num_err;
}

/************************************************************************
 * A generic function to check the port list of a circuit model in a given type 
 *  If not found, we give an error
 ***********************************************************************/
size_t check_one_circuit_model_port_required(const CircuitLibrary& circuit_lib,
                                             const CircuitModelId& circuit_model, 
                                             const std::vector<enum e_circuit_model_port_type>& port_types_to_check) {
  size_t num_err = 0;

  for (const auto& port_type: port_types_to_check) {
    if (0 == circuit_lib.model_ports_by_type(circuit_model, port_type).size()) {
      VTR_LOG_ERROR("%s circuit model(name=%s) does not have %s port\n",
                    CIRCUIT_MODEL_TYPE_STRING[size_t(circuit_lib.model_type(circuit_model))], 
                    circuit_lib.model_name(circuit_model).c_str(), 
                    CIRCUIT_MODEL_PORT_TYPE_STRING[size_t(port_type)]);
      /* Incremental the counter for errors */
      num_err++;
    }
  }

  return num_err;
}

/************************************************************************
 * A generic function to check the port size of a given circuit model
 * if the port size does not match, we give an error 
 ***********************************************************************/
size_t check_one_circuit_model_port_size_required(const CircuitLibrary& circuit_lib,
                                                  const CircuitModelId& circuit_model, 
                                                  const CircuitPortId& circuit_port,
                                                  const size_t& port_size_to_check) {

  size_t num_err = 0;

  if (port_size_to_check != circuit_lib.port_size(circuit_port)) {
    VTR_LOG_ERROR("Expect circuit model %s to have %d %s ports but only see %d!\n",
                  circuit_lib.model_name(circuit_model).c_str(), 
                  port_size_to_check,
                  CIRCUIT_MODEL_PORT_TYPE_STRING[size_t(circuit_lib.port_type(circuit_port))],
                  circuit_lib.port_size(circuit_port));
    /* Incremental the counter for errors */
    num_err++;
  }

  return num_err;
}

/************************************************************************
 * A generic function to check the port size of a given circuit model
 * if the number of ports in the given type does not match, we give an error 
 * for each port, if the port size does not match, we give an error 
 ***********************************************************************/
size_t check_one_circuit_model_port_type_and_size_required(const CircuitLibrary& circuit_lib,
                                                           const CircuitModelId& circuit_model, 
                                                           const enum e_circuit_model_port_type& port_type_to_check,
                                                           const size_t& num_ports_to_check,
                                                           const size_t& port_size_to_check,
                                                           const bool& include_global_ports) {

  size_t num_err = 0;

  std::vector<CircuitPortId> ports = circuit_lib.model_ports_by_type(circuit_model, port_type_to_check, false == include_global_ports);
  if (num_ports_to_check != ports.size()) {
    VTR_LOG_ERROR("Expect %d %s ports for a %s circuit model, but only have %d %s ports!\n",
                  num_ports_to_check,
                  CIRCUIT_MODEL_PORT_TYPE_STRING[size_t(port_type_to_check)],
                  CIRCUIT_MODEL_TYPE_STRING[size_t(circuit_lib.model_type(circuit_model))], 
               ports.size(),
               CIRCUIT_MODEL_PORT_TYPE_STRING[size_t(port_type_to_check)]);
    num_err++;
  } 
  for (const auto& port : ports) { 
    num_err += check_one_circuit_model_port_size_required(circuit_lib,
                                                          circuit_model, 
                                                          port, port_size_to_check);
  }

  return num_err;
}

/************************************************************************
 * A generic function to check the port list of circuit models in a given type 
 *  If not found, we give an error
 ***********************************************************************/
static 
size_t check_circuit_model_port_required(const CircuitLibrary& circuit_lib,
                                         const enum e_circuit_model_type& circuit_model_type_to_check, 
                                         const std::vector<enum e_circuit_model_port_type>& port_types_to_check) {
  size_t num_err = 0;

  for (const auto& id : circuit_lib.models_by_type(circuit_model_type_to_check)) {
    num_err += check_one_circuit_model_port_required(circuit_lib, id, port_types_to_check); 
  }

  return num_err;
}

/************************************************************************
 *  A generic function to search each default circuit model by types 
 *  that have been defined by users.
 *  If a type of circuit model is defined, we expect there is a default model 
 *  to be specified
 ***********************************************************************/
static 
size_t check_default_circuit_model_by_types(const CircuitLibrary& circuit_lib) {
  size_t num_err = 0;

  for (size_t itype = 0; itype < NUM_CIRCUIT_MODEL_TYPES; ++itype) {
    std::vector<CircuitModelId> curr_models = circuit_lib.models_by_type(e_circuit_model_type(itype));
    if (0 == curr_models.size()) {
       continue;
    }
    /* Go through the models and try to find a default one */
    size_t found_default_counter = 0;
    for (const auto& curr_model : curr_models) {
      if (true == circuit_lib.model_is_default(curr_model)) {
        found_default_counter++;
      }
    }
    if (0 == found_default_counter) {
      VTR_LOG_ERROR("Miss a default circuit model for the type %s! Try to define it in your architecture file!\n",
                    CIRCUIT_MODEL_TYPE_STRING[itype]);
      num_err++;
    }
    if (1 < found_default_counter) {
      VTR_LOG_ERROR("Found >1 default circuit models for the type %s! Expect only one!\n",
                    CIRCUIT_MODEL_TYPE_STRING[itype]);
      num_err++;
    }
  }

  return num_err;
}

/************************************************************************
 *  A generic function to find the default circuit model with a given type
 *  If not found, we give an error
 ***********************************************************************/
static 
size_t check_required_default_circuit_model(const CircuitLibrary& circuit_lib,
                                            const enum e_circuit_model_type& circuit_model_type) {
  size_t num_err = 0;

  if (CircuitModelId::INVALID() == circuit_lib.default_model(circuit_model_type)) {
    VTR_LOG_ERROR("Miss a default circuit model for the type %s! Try to define it in your architecture file!\n",
                  CIRCUIT_MODEL_TYPE_STRING[size_t(circuit_model_type)]);
    num_err++;
  }

  return num_err;
}

/************************************************************************
 * A function to check the port map of FF circuit model
 ***********************************************************************/
size_t check_ff_circuit_model_ports(const CircuitLibrary& circuit_lib,
                                    const CircuitModelId& circuit_model) {
  size_t num_err = 0;

  /* Check the type of circuit model */
  VTR_ASSERT(CIRCUIT_MODEL_FF == circuit_lib.model_type(circuit_model));
  /* Check if we have D, Set and Reset */
  num_err += check_one_circuit_model_port_type_and_size_required(circuit_lib, circuit_model, 
                                                                 CIRCUIT_MODEL_PORT_INPUT,
                                                                 3, 1, false);
  /* Check if we have a clock */
  num_err += check_one_circuit_model_port_type_and_size_required(circuit_lib, circuit_model, 
                                                                 CIRCUIT_MODEL_PORT_CLOCK,
                                                                 1, 1, false);


  /* Check if we have output */
  num_err += check_one_circuit_model_port_type_and_size_required(circuit_lib, circuit_model, 
                                                                 CIRCUIT_MODEL_PORT_OUTPUT,
                                                                 1, 1, false);

  return num_err;
}

/************************************************************************
 * A function to check the port map of CCFF circuit model
 ***********************************************************************/
size_t check_ccff_circuit_model_ports(const CircuitLibrary& circuit_lib,
                                      const CircuitModelId& circuit_model) {
  size_t num_err = 0;

  /* Check the type of circuit model */
  VTR_ASSERT(CIRCUIT_MODEL_CCFF == circuit_lib.model_type(circuit_model));

  /* Check if we have D, Set and Reset */
  /* We can have either 1 input which is D or 2 inputs which are D and scan input */
  size_t num_input_ports = circuit_lib.model_ports_by_type(circuit_model, CIRCUIT_MODEL_PORT_INPUT, true).size();
  if ((1 != num_input_ports) && (2 != num_input_ports)) {
    VTR_LOG_ERROR("Configuration flip-flop '%s' must have either 1 or 2 %s ports!\n\tAmong which:\n\t\tthe first input is a regular input (e.g., D)\n\t\tand the other could be scan-chain input (e.g., SI)\n",
                  circuit_lib.model_name(circuit_model).c_str(),
                  CIRCUIT_MODEL_PORT_TYPE_STRING[size_t(CIRCUIT_MODEL_PORT_INPUT)]);
    num_err++;
  }

  num_err += check_one_circuit_model_port_type_and_size_required(circuit_lib, circuit_model, 
                                                                 CIRCUIT_MODEL_PORT_INPUT,
                                                                 num_input_ports, 1, false);
  /* Check if we have a clock */
  num_err += check_one_circuit_model_port_type_and_size_required(circuit_lib, circuit_model, 
                                                                 CIRCUIT_MODEL_PORT_CLOCK,
                                                                 1, 1, true);


  /* Check if we have 1 or 2 or 3 outputs */
  size_t num_output_ports = circuit_lib.model_ports_by_type(circuit_model, CIRCUIT_MODEL_PORT_OUTPUT, true).size();
  if ((1 != num_output_ports) 
   && (2 != num_output_ports)
   && (3 != num_output_ports)) {
    VTR_LOG_ERROR("Configuration flip-flop '%s' must have either 1 or 2 or 3 %s ports!\n\tAmong which:\n\t\tthe first port is the manadatory regular data output (e.g., Q) and \n\t\tthe second port could be the inverted data output which can optionally be enabled by configure-enable signal (e.g., QN or cgf_en_QN) and \n\t\tthe third port could be the data output which can optionally be enabled by configure-enable signal (e.g., cgf_en_Q)\n",
                  circuit_lib.model_name(circuit_model).c_str(),
                  CIRCUIT_MODEL_PORT_TYPE_STRING[size_t(CIRCUIT_MODEL_PORT_OUTPUT)]);
    num_err++;
  }

  num_err += check_one_circuit_model_port_type_and_size_required(circuit_lib, circuit_model, 
                                                                 CIRCUIT_MODEL_PORT_OUTPUT,
                                                                 num_output_ports, 1, false);

  return num_err;
}

/************************************************************************
 * A function to check the port map of CCFF circuit model used to control BLs
 * - Require 1 clock port
 * - Require 1 input port as data input (to be driven by other CCFF in a chain) 
 * - Require 1 output port as data output (to drive other CCFF in a chain) 
 * - Require 1 BL port as data output / inout (to drive/driven by BLs)
 ***********************************************************************/
size_t check_bl_ccff_circuit_model_ports(const CircuitLibrary& circuit_lib,
                                         const CircuitModelId& circuit_model) {
  size_t num_err = 0;

  /* Check the type of circuit model */
  VTR_ASSERT(CIRCUIT_MODEL_CCFF == circuit_lib.model_type(circuit_model));

  /* Check if we have D, Set and Reset */
  /* We can have either 1 input which is D or 2 inputs which are D and scan input */
  size_t num_input_ports = circuit_lib.model_ports_by_type(circuit_model, CIRCUIT_MODEL_PORT_INPUT, true).size();
  if (1 != num_input_ports) {
    VTR_LOG_ERROR("Configuration flip-flop for BL shift register '%s' must have 1 %s port!\n",
                  circuit_lib.model_name(circuit_model).c_str(),
                  CIRCUIT_MODEL_PORT_TYPE_STRING[size_t(CIRCUIT_MODEL_PORT_INPUT)]);
    num_err++;
  }

  num_err += check_one_circuit_model_port_type_and_size_required(circuit_lib, circuit_model, 
                                                                 CIRCUIT_MODEL_PORT_INPUT,
                                                                 num_input_ports, 1, false);
  /* Check if we have a clock */
  num_err += check_one_circuit_model_port_type_and_size_required(circuit_lib, circuit_model, 
                                                                 CIRCUIT_MODEL_PORT_CLOCK,
                                                                 1, 1, true);


  /* Check if we have 1 output*/
  num_err += check_one_circuit_model_port_type_and_size_required(circuit_lib, circuit_model, 
                                                                 CIRCUIT_MODEL_PORT_OUTPUT,
                                                                 1, 1, false);

  /* Check if we have 1 bl port */
  num_err += check_one_circuit_model_port_type_and_size_required(circuit_lib, circuit_model, 
                                                                 CIRCUIT_MODEL_PORT_BL,
                                                                 1, 1, false);

  return num_err;
}

/************************************************************************
 * A function to check the port map of CCFF circuit model used to control WLs
 * - Require 1 clock port
 * - Require 1 input port as data input (to be driven by other CCFF in a chain) 
 * - Require 1 output port as data output (to drive other CCFF in a chain) 
 * - Require 1 WL port as data output (to drive WLs)
 * - Optionally require 1 WLR port as data output (to drive WLRs)
 ***********************************************************************/
size_t check_wl_ccff_circuit_model_ports(const CircuitLibrary& circuit_lib,
                                         const CircuitModelId& circuit_model) {
  size_t num_err = 0;

  /* Check the type of circuit model */
  VTR_ASSERT(CIRCUIT_MODEL_CCFF == circuit_lib.model_type(circuit_model));

  /* Check if we have D, Set and Reset */
  /* We can have either 1 input which is D or 2 inputs which are D and scan input */
  size_t num_input_ports = circuit_lib.model_ports_by_type(circuit_model, CIRCUIT_MODEL_PORT_INPUT, true).size();
  if (1 != num_input_ports) {
    VTR_LOG_ERROR("Configuration flip-flop for WL shift register '%s' must have 1 %s port!\n",
                  circuit_lib.model_name(circuit_model).c_str(),
                  CIRCUIT_MODEL_PORT_TYPE_STRING[size_t(CIRCUIT_MODEL_PORT_INPUT)]);
    num_err++;
  }

  num_err += check_one_circuit_model_port_type_and_size_required(circuit_lib, circuit_model, 
                                                                 CIRCUIT_MODEL_PORT_INPUT,
                                                                 num_input_ports, 1, false);
  /* Check if we have two clock: 1 for write-enable, 1 for shift register */
  num_err += check_one_circuit_model_port_type_and_size_required(circuit_lib, circuit_model, 
                                                                 CIRCUIT_MODEL_PORT_CLOCK,
                                                                 2, 1, true);


  /* Check if we have 1 output*/
  num_err += check_one_circuit_model_port_type_and_size_required(circuit_lib, circuit_model, 
                                                                 CIRCUIT_MODEL_PORT_OUTPUT,
                                                                 1, 1, false);

  /* Check if we have 1 wl port */
  if (0 < circuit_lib.model_ports_by_type(circuit_model, CIRCUIT_MODEL_PORT_WLR, true).size()) {
    num_err += check_one_circuit_model_port_type_and_size_required(circuit_lib, circuit_model, 
                                                                   CIRCUIT_MODEL_PORT_WLR,
                                                                   1, 1, false);
  }

  return num_err;
}


/************************************************************************
 * A function to check the port map of SRAM circuit model
 ***********************************************************************/
size_t check_sram_circuit_model_ports(const CircuitLibrary& circuit_lib,
                                      const CircuitModelId& circuit_model,
                                      const bool& check_blwl) {
  size_t num_err = 0;

  /* Check the type of circuit model */
  VTR_ASSERT(CIRCUIT_MODEL_SRAM == circuit_lib.model_type(circuit_model));

  /* Check if we has 1 output with size 2 */
  num_err += check_one_circuit_model_port_type_and_size_required(circuit_lib, circuit_model, 
                                                                 CIRCUIT_MODEL_PORT_OUTPUT,
                                                                 2, 1, false);
  /* basic check finished here */
  if (false == check_blwl) {
    return num_err;
  }

  /* If bl and wl are required, check their existence */
  num_err += check_one_circuit_model_port_type_and_size_required(circuit_lib, circuit_model, 
                                                                 CIRCUIT_MODEL_PORT_BL,
                                                                 1, 1, false);

  num_err += check_one_circuit_model_port_type_and_size_required(circuit_lib, circuit_model, 
                                                                 CIRCUIT_MODEL_PORT_WL,
                                                                 1, 1, false);

  return num_err;
}

/************************************************************************
 * Check all the ports make sure, they satisfy the restriction 
 ***********************************************************************/
static 
size_t check_circuit_library_ports(const CircuitLibrary& circuit_lib) {
  size_t num_err = 0;
  
  /* Check global ports: make sure all the global ports are input ports */
  for (const auto& port : circuit_lib.ports()) {
    if ( (circuit_lib.port_is_global(port)) 
      && (!circuit_lib.is_input_port(port)) 
      && (!circuit_lib.is_output_port(port)) ) {
      VTR_LOG_ERROR("Circuit port (type=%s) of model (name=%s) is defined as global but not an input/output port!\n",
                    CIRCUIT_MODEL_PORT_TYPE_STRING[size_t(circuit_lib.port_type(port))],
                    circuit_lib.model_name(port).c_str());
      num_err++;
    }
  }

  /* Check global output ports: make sure they are all I/Os */
  for (const auto& port : circuit_lib.ports()) {
    if ( (circuit_lib.port_is_global(port)) 
      && (CIRCUIT_MODEL_PORT_OUTPUT == circuit_lib.port_type(port))
      && (false == circuit_lib.port_is_io(port)) ) {
      VTR_LOG_ERROR("Circuit port (type=%s) of model (name=%s) is defined as global output port but not an I/O!\n",
                    CIRCUIT_MODEL_PORT_TYPE_STRING[size_t(circuit_lib.port_type(port))],
                    circuit_lib.model_name(port).c_str());
      num_err++;
    }
  }

  /* Check set/reset/config_enable ports: make sure they are all global ports */
  for (const auto& port : circuit_lib.ports()) {
    if ( ( (circuit_lib.port_is_set(port)) 
        || (circuit_lib.port_is_reset(port)) 
        || (circuit_lib.port_is_config_enable(port)) )
      && (!circuit_lib.port_is_global(port)) ) {
      VTR_LOG_ERROR("Circuit port (type=%s) of model (name=%s) is defined as a set/reset/config_enable port but it is not global!\n",
                    CIRCUIT_MODEL_PORT_TYPE_STRING[size_t(circuit_lib.port_type(port))],
                    circuit_lib.model_name(port).c_str());
      num_err++;
    }
  }

  /* Check the tri-state map of ports, the length should match the port size! */
  for (const auto& port : circuit_lib.ports()) {
    if (circuit_lib.port_tri_state_map(port).empty()) {
      continue; /* No tri-state map is found, go to the next */
    }
    if (circuit_lib.port_tri_state_map(port).length() == circuit_lib.port_size(port)) {
      continue; /* Sizes match, go to the next */
    }
    /* We have a problem here, sizes do not match, leave a message and raise the error flag */
    VTR_LOG_ERROR("Tri-state map (=%s) of circuit port (type=%s) of model (name=%s) does not match the port size (=%lu)!\n",
               circuit_lib.port_tri_state_map(port).c_str(),
               CIRCUIT_MODEL_PORT_TYPE_STRING[size_t(circuit_lib.port_type(port))],
               circuit_lib.model_name(port).c_str(),
               circuit_lib.port_size(port));
    num_err++;
  }

  /* Check all the global ports which sare the same name also share the same attributes:
   * default_value, is_config, is_reset, is_set etc. 
   */
  std::vector<CircuitPortId> global_ports;

  /* Collect all the global ports */
  for (auto port : circuit_lib.ports()) {
    /* By pass non-global ports*/
    if (false == circuit_lib.port_is_global(port)) {
      continue;
    }
    global_ports.push_back(port);
  }

  for (size_t iport = 0; iport < global_ports.size() - 1; ++iport) {
    for (size_t jport = iport + 1; jport < global_ports.size(); ++jport) {
      /* Bypass those do not share the same name */
      if (0 != circuit_lib.port_prefix(global_ports[iport]).compare(circuit_lib.port_prefix(global_ports[jport]))) {
        continue;
      }

      /* Check if a same port share the same attributes */
      CircuitModelId iport_parent_model = circuit_lib.port_parent_model(global_ports[iport]);
      CircuitModelId jport_parent_model = circuit_lib.port_parent_model(global_ports[jport]);

      if (circuit_lib.port_default_value(global_ports[iport]) != circuit_lib.port_default_value(global_ports[jport])) { 
        VTR_LOG_ERROR("Global ports %s from circuit model %s and %s share the same name but have different dfefault values(%lu and %lu)!\n",
                      circuit_lib.port_prefix(global_ports[iport]).c_str(),
                      circuit_lib.model_name(iport_parent_model).c_str(),
                      circuit_lib.model_name(jport_parent_model).c_str(),
                      circuit_lib.port_default_value(global_ports[iport]),
                      circuit_lib.port_default_value(global_ports[jport])
                      ); 
        num_err++;
      }

      if (circuit_lib.port_is_reset(global_ports[iport]) != circuit_lib.port_is_reset(global_ports[jport])) { 
        VTR_LOG_ERROR("Global ports %s from circuit model %s and %s share the same name but have different is_reset attributes!\n",
                      circuit_lib.port_prefix(global_ports[iport]).c_str(),
                      circuit_lib.model_name(iport_parent_model).c_str(),
                      circuit_lib.model_name(jport_parent_model).c_str() 
                      ); 
        num_err++;
      }
      if (circuit_lib.port_is_set(global_ports[iport]) != circuit_lib.port_is_set(global_ports[jport])) { 
        VTR_LOG_ERROR("Global ports %s from circuit model %s and %s share the same name but have different is_set attributes!\n",
                      circuit_lib.port_prefix(global_ports[iport]).c_str(),
                      circuit_lib.model_name(iport_parent_model).c_str(),
                      circuit_lib.model_name(jport_parent_model).c_str() 
                      ); 
        num_err++;
      }
      if (circuit_lib.port_is_config_enable(global_ports[iport]) != circuit_lib.port_is_config_enable(global_ports[jport])) { 
        VTR_LOG_ERROR("Global ports %s from circuit model %s and %s share the same name but have different is_config_enable attributes!\n",
                      circuit_lib.port_prefix(global_ports[iport]).c_str(),
                      circuit_lib.model_name(iport_parent_model).c_str(),
                      circuit_lib.model_name(jport_parent_model).c_str() 
                      ); 
        num_err++;
      }
      if (circuit_lib.port_is_prog(global_ports[iport]) != circuit_lib.port_is_prog(global_ports[jport])) { 
        VTR_LOG_ERROR("Global ports %s from circuit model %s and %s share the same name but have different is_prog attributes!\n",
                      circuit_lib.port_prefix(global_ports[iport]).c_str(),
                      circuit_lib.model_name(iport_parent_model).c_str(),
                      circuit_lib.model_name(jport_parent_model).c_str() 
                      ); 
        num_err++;
      }
    }
  }

  return num_err;
}

/************************************************************************
 * Check the port requirements for a power-gated circuit model 
 * - It must have at least 2 global ports and which are config enable signals
 * - It must have an Enable port which control power gating 
 * - It must have an EnableB port which control power gating 
 ***********************************************************************/
static 
int check_power_gated_circuit_model(const CircuitLibrary& circuit_lib,
                                    const CircuitModelId& circuit_model) {
  int num_err = 0;

  std::vector<CircuitPortId> global_ports = circuit_lib.model_global_ports_by_type(circuit_model, CIRCUIT_MODEL_PORT_INPUT, true, true);

  /* If the circuit model is power-gated, we need to find at least one global config_enable signals */
  VTR_ASSERT(true == circuit_lib.is_power_gated(circuit_model));
  /* Check all the ports we have are good for a power-gated circuit model */
  /* We need at least one global port */
  if (2 > global_ports.size())  {
    VTR_LOGF_ERROR(__FILE__, __LINE__,
                   "Expect at least two global ports (a pair of EN/Enb) for circuit model '%s' which is power-gated!\n",
                   circuit_lib.model_name(circuit_model).c_str()); 
    num_err++;
  }
  /* All the global ports should be config_enable */
  int num_config_enable_ports = 0;
  for (const auto& port : global_ports) {
    if (true == circuit_lib.port_is_config_enable(port)) {
      num_config_enable_ports++;
    }
  }

  if (2 != num_config_enable_ports) {
    VTR_LOGF_ERROR(__FILE__, __LINE__,
                   "Circuit model '%s' is power-gated. Two config-enable global ports are required!\n",
                   circuit_lib.model_name(circuit_model).c_str()); 
    num_err++;
  }
  /* Report errors if there are any */
  if (0 < num_err) {
    return num_err;
  }

  /* Try to find a pair of Enable and ENb ports from the global ports */
  CircuitPortId en_port = CircuitPortId::INVALID();
  CircuitPortId enb_port = CircuitPortId::INVALID();
  for (const auto& port : global_ports) {
    /* Focus on config_enable ports which are power-gate control signals */
    if (false == circuit_lib.port_is_config_enable(port)) {
      continue;
    }
    if (0 == circuit_lib.port_default_value(port)) {
      en_port = port;
    } else {
      VTR_ASSERT(1 == circuit_lib.port_default_value(port));
      enb_port = port;
    }
  }
  /* We must have valid EN/ENb ports */
  if (false == circuit_lib.valid_circuit_port_id(en_port)) {
    VTR_LOGF_ERROR(__FILE__, __LINE__,
                   "Fail to find an enable port for the circuit model '%s' is power-gated!\n",
                   circuit_lib.model_name(circuit_model).c_str()); 
  }
  if (false == circuit_lib.valid_circuit_port_id(enb_port)) {
    VTR_LOGF_ERROR(__FILE__, __LINE__,
                   "Fail to find an inverted enable port for the circuit model '%s' is power-gated!\n",
                   circuit_lib.model_name(circuit_model).c_str()); 
  }

  return num_err;
}

/************************************************************************
 * Check the port requirements for each power-gated circuit model 
 ***********************************************************************/
static 
int check_power_gated_circuit_models(const CircuitLibrary& circuit_lib) {
  int num_err = 0;

  for (const CircuitModelId& circuit_model : circuit_lib.models()) {
    if (true == circuit_lib.is_power_gated(circuit_model)) {
      num_err += check_power_gated_circuit_model(circuit_lib, circuit_model);
    }
  }

  return num_err;
}

/************************************************************************
 * Check io has been defined and has input and output ports 
 * - We must have global I/O port, either its type is inout, input or output
 * - For each IOPAD, we must have at least an input an output 
 ***********************************************************************/
static 
size_t check_io_circuit_model(const CircuitLibrary& circuit_lib) {
  size_t num_err = 0;

  /* Each I/O cell must have 
   *  - One of the following ports
   *    - At least 1 ASIC-to-FPGA (A2F) port that is defined as global data I/O 
   *    - At least 1 FPGA-to-ASIC (F2A) port that is defined as global data I/O!
   *  - At least 1 regular port that is non-global which is connected to global routing architecture
   */
  for (const auto& io_model : circuit_lib.models_by_type(CIRCUIT_MODEL_IOPAD)) {
    bool has_data_io = false;
    bool has_data_input_only_io = false;
    bool has_data_output_only_io = false;
    bool has_internal_connection = false;

    for (const auto& port : circuit_lib.model_ports(io_model)) {
      if ( (true == circuit_lib.port_is_io(port))
        && (true == circuit_lib.port_is_data_io(port))
        && (CIRCUIT_MODEL_PORT_INOUT == circuit_lib.port_type(port))
        && (true == circuit_lib.port_is_global(port))) {
        has_data_io = true;
        continue; /* Go to next */
      }
      if ( (true == circuit_lib.port_is_io(port))
        && (true == circuit_lib.port_is_data_io(port))
        && (CIRCUIT_MODEL_PORT_INPUT == circuit_lib.port_type(port))
        && (true == circuit_lib.port_is_global(port))) {
        has_data_input_only_io = true;
        continue; /* Go to next */
      }
      if ( (true == circuit_lib.port_is_io(port))
        && (true == circuit_lib.port_is_data_io(port))
        && (CIRCUIT_MODEL_PORT_OUTPUT == circuit_lib.port_type(port))
        && (true == circuit_lib.port_is_global(port))) {
        has_data_output_only_io = true;
        continue; /* Go to next */
      }

      if ( (false == circuit_lib.port_is_io(port)
        && (false == circuit_lib.port_is_global(port)))
        && (CIRCUIT_MODEL_PORT_SRAM != circuit_lib.port_type(port))) {
        has_internal_connection = true;
        continue; /* Go to next */
      }
    }
  
    /* Error out when
     *   - there is no data io, data input-only io and data output-only io
     */
    if ( (false == has_data_io) 
      && (false == has_data_input_only_io) 
      && (false == has_data_output_only_io)) {
      VTR_LOGF_ERROR(__FILE__, __LINE__,
                     "I/O circuit model '%s' does not have any data I/O port defined!\n",
                     circuit_lib.model_name(io_model).c_str()); 
      num_err++;
    }

    if (false == has_internal_connection) {
      VTR_LOGF_ERROR(__FILE__, __LINE__,
                     "I/O circuit model '%s' does not have any port connected to FPGA core!\n",
                     circuit_lib.model_name(io_model).c_str()); 
      num_err++;
    }
  }

  return num_err;
}

/************************************************************************
 * Check points to make sure we have a valid circuit library
 * Detailed checkpoints: 
 * 1. Circuit models have unique names 
 * 2. Circuit models have unique prefix
 * 3. Check IOPADs have input and output ports
 * 4. Check MUXes has been defined and has input and output ports
 * 5. We must have at least one SRAM or CCFF 
 * 6. SRAM must have at least an input and an output ports
 * 7. CCFF must have at least a clock, an input and an output ports
 * 8. FF must have at least a clock, an input and an output ports
 * 9. LUT must have at least an input, an output and a SRAM ports
 * 10. We must have default circuit models for these types: MUX, channel wires and wires
 *
 * Note:
 *   - NO modification on the circuit library is allowed!
 *     The circuit library should be read-only!!!
 ***********************************************************************/
bool check_circuit_library(const CircuitLibrary& circuit_lib) {
  size_t num_err = 0;

  vtr::ScopedStartFinishTimer timer("Check circuit library");

  /* 1. Circuit models have unique names  
   * For each circuit model, we always make sure it does not share any name with any circuit model locating after it
   */
  num_err += check_circuit_library_unique_names(circuit_lib);

  /* 2. Circuit models have unique prefix
   * For each circuit model, we always make sure it does not share any prefix with any circuit model locating after it
   */
  num_err += check_circuit_library_unique_prefix(circuit_lib);

  /* Check global ports */
  num_err += check_circuit_library_ports(circuit_lib);

  /* 3. Check io has been defined and has input and output ports 
   * [a] We must have global I/O port, either its type is inout, input or output
   * [b] For each IOPAD, we must have at least an input an output 
   */
  num_err += check_circuit_model_required(circuit_lib, CIRCUIT_MODEL_IOPAD);
  num_err += check_io_circuit_model(circuit_lib);

  /* 4. Check mux has been defined and has input and output ports
   * [a] We must have a MUX! 
   * [b] For each MUX, we must have at least an input, an output, and an SRAM port
   */
  num_err += check_circuit_model_required(circuit_lib, CIRCUIT_MODEL_MUX);

  std::vector<enum e_circuit_model_port_type> mux_port_types_required;
  mux_port_types_required.push_back(CIRCUIT_MODEL_PORT_INPUT);
  mux_port_types_required.push_back(CIRCUIT_MODEL_PORT_OUTPUT);
  mux_port_types_required.push_back(CIRCUIT_MODEL_PORT_SRAM);

  num_err += check_circuit_model_port_required(circuit_lib, CIRCUIT_MODEL_MUX, mux_port_types_required);

  /* 5. We must have at least one SRAM or CCFF */
  if ( ( 0 == circuit_lib.models_by_type(CIRCUIT_MODEL_SRAM).size())
    && ( 0 == circuit_lib.models_by_type(CIRCUIT_MODEL_CCFF).size()) ) {
    VTR_LOG_ERROR("At least one %s or %s circuit model is required!\n",
                  CIRCUIT_MODEL_TYPE_STRING[size_t(CIRCUIT_MODEL_SRAM)], 
                  CIRCUIT_MODEL_TYPE_STRING[size_t(CIRCUIT_MODEL_CCFF)]);
    /* Incremental the counter for errors */
    num_err++;
  }

  /* 6. SRAM must have at least an input and an output ports*/
  std::vector<enum e_circuit_model_port_type> sram_port_types_required;
  sram_port_types_required.push_back(CIRCUIT_MODEL_PORT_OUTPUT);

  num_err += check_circuit_model_port_required(circuit_lib, CIRCUIT_MODEL_SRAM, sram_port_types_required);

  /* 7. CCFF must have at least a clock, an input and an output ports*/
  std::vector<enum e_circuit_model_port_type> ccff_port_types_required;
  ccff_port_types_required.push_back(CIRCUIT_MODEL_PORT_CLOCK);
  ccff_port_types_required.push_back(CIRCUIT_MODEL_PORT_INPUT);
  ccff_port_types_required.push_back(CIRCUIT_MODEL_PORT_OUTPUT);

  num_err += check_circuit_model_port_required(circuit_lib, CIRCUIT_MODEL_CCFF, ccff_port_types_required);

  /* 8. FF must have at least a clock, an input and an output ports*/
  std::vector<enum e_circuit_model_port_type> ff_port_types_required;
  ff_port_types_required.push_back(CIRCUIT_MODEL_PORT_CLOCK);
  ff_port_types_required.push_back(CIRCUIT_MODEL_PORT_INPUT);
  ff_port_types_required.push_back(CIRCUIT_MODEL_PORT_OUTPUT);

  num_err += check_circuit_model_port_required(circuit_lib, CIRCUIT_MODEL_FF, ff_port_types_required);

  /* 9. LUT must have at least an input, an output and a SRAM ports*/
  std::vector<enum e_circuit_model_port_type> lut_port_types_required;
  lut_port_types_required.push_back(CIRCUIT_MODEL_PORT_SRAM);
  lut_port_types_required.push_back(CIRCUIT_MODEL_PORT_INPUT);
  lut_port_types_required.push_back(CIRCUIT_MODEL_PORT_OUTPUT);

  num_err += check_circuit_model_port_required(circuit_lib, CIRCUIT_MODEL_LUT, lut_port_types_required);

  /* 10. For each type of circuit models that are define, we must have 1 default model
   *     We must have default circuit models for these types: MUX, channel wires and wires 
   */
  num_err += check_default_circuit_model_by_types(circuit_lib);
  num_err += check_required_default_circuit_model(circuit_lib, CIRCUIT_MODEL_MUX);
  num_err += check_required_default_circuit_model(circuit_lib, CIRCUIT_MODEL_CHAN_WIRE);
  num_err += check_required_default_circuit_model(circuit_lib, CIRCUIT_MODEL_WIRE);

  /* 11. Check power-gated inverter/buffer models */
  num_err += check_power_gated_circuit_models(circuit_lib);

  /* If we have any errors, exit */

  if (0 < num_err) {
    VTR_LOG("Finished checking circuit library with %d errors!\n",
            num_err);
    return false;
  }

  VTR_LOG("Checking circuit library passed.\n");

  return true;
}