Settings.pm

#-------------------------------------------------------------------------------
#  University of Applied Sciences Technikum Wien
#
#  Department of Embedded Systems
#  http://embsys.technikum-wien.at
#
#  Josef Ressel Center for Verification of Embedded Computing Systems
#  http://vecs.technikum-wien.at
#
#-------------------------------------------------------------------------------
#  File:              Settings.pm
#  Created on:        16.02.2015
#  $LastChangedBy$
#  $LastChangedDate$
#
#  Description:
#
# Contains helper functions to deal with FIJI Settings files.
#-------------------------------------------------------------------------------


## @file

## @class FIJI::Settings
#
# Contains helper functions to deal with FIJI Settings files.
package FIJI::Settings;

use strict;
use warnings;

use Scalar::Util 'blessed';
use Log::Log4perl qw(get_logger);
use Scalar::Util "looks_like_number";
use Config::Simple;
use Data::Dumper;
use POSIX qw(ceil);
use List::Util qw(max);

use FIJI qw(:all);

## @function new ($phase, $fiji_ini_file, $existing_settings)
# Create a new settings instance.
#
# \param $phase Tool flow phase the settings need to be compatible with.
# \param $fiji_ini_file (optional) Path to the configuration file to read.
# \param $existing_settings (optional) A reference to reuse and return
#        with values read from file. Any contained data will be cleared.
# \returns The new settings instance or a string describing the reason
#          why it could not be created.
sub new ($;$$) {
  my $logger = get_logger();
  my ($class, $phase, $fiji_ini_file, $existing_settings) = @_;

  my $fiji_settings_ref;
  # if there is no existing settings instance yet, create one
  if (!defined($existing_settings)) {
    $fiji_settings_ref = {};
    $fiji_settings_ref = bless($fiji_settings_ref, $class);
  } else {
    $fiji_settings_ref = $existing_settings;
  }
  if (!blessed($fiji_settings_ref) || !$fiji_settings_ref->isa("FIJI::Settings")) {
    my $msg;
    if (!defined($existing_settings)) {
      $msg = "Could not create FIJI::Settings instance.";
    } else {
      $msg = "Given settings are not of type FIJI::Settings.";
    }
    $logger->error($msg);
    return $msg;
  }

  # If there is a file given, try to read it. Else just create a default instance.
  if (defined($fiji_ini_file)) {
    $fiji_settings_ref = read_settingsfile($phase, $fiji_ini_file, $fiji_settings_ref);
    if (!ref($fiji_settings_ref)) {
      return $fiji_settings_ref; # actually an error message
    }
  } else {
    $fiji_settings_ref->{'design'} = {};
    _set_defaults(DESIGNMAP, $fiji_settings_ref->{'design'}, $phase);
    $fiji_settings_ref->{'fius'} = [];
  }

  return $fiji_settings_ref;
}


sub _export_value {
  my $logger = get_logger();
  my ($map_ref, $k, $v_ref) = @_;

  if (defined($map_ref->{$k}->{'type'})) {
    my $orig = ${$v_ref};
    if ($map_ref->{$k}->{'type'} eq 'hexadecimal') {
      ${$v_ref} = sprintf("0x%x", $orig);
    # } elsif ($map_ref->{$k}->{'type'} eq 'natural') {
    # } elsif ($map_ref->{$k}->{'type'} eq 'boolean') {
      $logger->trace("Converted value of $k (\"$orig\") to \"${$v_ref}\".") if ($orig ne ${$v_ref});
    }
  # } elsif (defined($map_ref->{$k}->{'values'})) {
  }
}

## @method save ($fiji_ini_file)
# @brief Store contained FIJI Settings to file.
#
# @ATTENTION Will happily overwrite existing files!
#
# \param fiji_ini_file The file name to write the FIJI Settings to.
sub save ($) {
  my $logger = get_logger();
  my ($self, $fiji_ini_file) = @_;
  return "No file name given" if !defined($fiji_ini_file);

  my $fiji_ini = new Config::Simple(syntax=>'ini');
  my $design_ref;
  my $fiu_cnt = 0;
  foreach my $key (keys %{$self}) {
    my $val = $self->{$key};
    if (ref(\$val) eq "REF") {
      if (ref($val) eq "HASH") {
        if ($key eq "design") {
          $design_ref = $val;
          next;
        }
      } elsif (ref($val) eq "ARRAY") {
        if ($key eq "fius") {
          foreach my $fiu (@{$val}) {
            my $ini_fiu;
            
            foreach my $k (keys(%{$fiu})) {
              my $ini_name = FIUMAP->{$k}->{'ini_name'};
              if (!defined($fiu->{$k})) {
                $logger->debug("Skip saving undefined value of FIU constant with key $ini_name.");
                next;
              }
              # Copy value to new hash with external naming.
              $ini_fiu->{$ini_name} = $fiu->{$k};
              # Convert value to external representation
              _export_value(FIUMAP, $k, \$ini_fiu->{$ini_name});
              $logger->trace(sprintf("Exporting FIU%d setting %s -> %s (%s -> %s).",
                                     $fiu_cnt,
                                     $k,
                                     $ini_name,
                                     defined($fiu->{$k}) ? $fiu->{$k} : "undef",
                                     defined($ini_fiu->{$ini_name}) ? $ini_fiu->{$ini_name} : "undef"),
                            );
            }
            $fiji_ini->set_block("FIU" . $fiu_cnt++, $ini_fiu);
          }
          next;
        }
      }
    }
    my $err = "Unknown element found in FIJI Settings: \"$val\"";
    $logger->error($err);
    return $err;
  }
  $design_ref->{'FIU_NUM'} = $fiu_cnt;
  my $ini_design;
  foreach my $k (keys(%{$design_ref})) {
    my $ini_name = DESIGNMAP->{$k}->{'ini_name'};
    if (!defined($design_ref->{$k})) {
      $logger->debug("Skip saving undefined value of design constant with key $ini_name.");
      next;
    }
    # Copy value to new hash with external naming.
    $ini_design->{$ini_name} = $design_ref->{$k};
    # Convert value to external representation
    _export_value(DESIGNMAP, $k, \$ini_design->{$ini_name});
    $logger->trace(sprintf("Exporting Design setting %s -> %s (%s -> %s).",
                           $k,
                           $ini_name,
                           defined($design_ref->{$k}) ? $design_ref->{$k} : "undef",
                           defined($ini_design->{$ini_name}) ? $ini_design->{$ini_name} : "undef"),
                  );
  }
  $fiji_ini->set_block("CONSTS", $ini_design);

  if (!defined($fiji_ini->write($fiji_ini_file))) {
    my $err = Config::Simple->error();
    $logger->error($err);
    return $err;
  }
  return undef;
}


## @function read_settingsfile ($phase, $fiji_ini_file)
# @brief Load the FIJI Settings file containing design and FIU constants.
#
# \param phase  Tool flow phase the settings stored in the given file
#               need to be compatible with.
# \param fiji_ini_file The name of an .ini file with FIJI Settings:
#         - a 'consts' block containing the constants specified by
#           \ref _sanitize_design.
#         - at least one FIU block named "FIU<number>" where "<number>"
#           is a strictly increasing integer starting with 0 containing
#           the constants for the respective FIU, see \ref _sanitize_fiu
#
# \returns a reference to the hash containing the read constants.
sub read_settingsfile ($$$) {
  my $logger = get_logger();
  my ($phase, $fiji_ini_file, $existing_settings) = @_;
  my $fiji_ini;
  eval { $fiji_ini = new Config::Simple($fiji_ini_file) }; # pesky library tries to die on syntax errors
  if (!defined($fiji_ini)) {
    my $submsg = defined($@) ? $@ : Config::Simple->error();
    if (length($submsg) == 0) {
      $submsg = "Empty file?";
    }
    my $msg = "Could not read config file \"$fiji_ini_file\": $submsg";
    $logger->error($msg);
    return $msg;
  }

  my $design_ref = $fiji_ini->get_block("CONSTS");
  if (!(%$design_ref)) {
    my $msg = "Could not fetch CONSTS block from config file \"$fiji_ini_file\"";
    $logger->error($msg);
    return $msg;
  }
  _set_defaults(DESIGNMAP, $design_ref, $phase);

  $design_ref = _rename_import(DESIGNMAP, $design_ref);
  if (!defined($design_ref)) {
    my $msg = "Design constants do not match the FIJI Settings naming scheme.";
    $logger->error($msg);
    return $msg;
  }

  # Create a new instance or reuse the shallow hull of the existing one
  my $fiji_settings_ref;
  if (!defined($existing_settings)) {
    $fiji_settings_ref = {};
    bless($fiji_settings_ref, "FIJI::Settings");
  } else {
    $fiji_settings_ref = $existing_settings;
    # Clear the hash
    for (keys %$fiji_settings_ref) {
        delete $fiji_settings_ref->{$_};
    }
   }
  if (!blessed($fiji_settings_ref) || !$fiji_settings_ref->isa("FIJI::Settings")) {
    my $msg;
    if (!defined($existing_settings)) {
      $msg = "Could not create FIJI::Settings instance.";
    } else {
      $msg = "Given settings are not of type FIJI::Settings.";
    }
    $logger->error($msg);
    return $msg;
  }
  $fiji_settings_ref->{'design'} = $design_ref;
  $fiji_settings_ref->{'fius'} = [];

  # sanitize and validate read design constants
  $design_ref = _sanitize_design($design_ref, $phase);
  if (!ref($design_ref)) {
    $logger->error($design_ref);
    return $design_ref;
  }

  my $fiu_num = 0;
  # loop over all read fius
  while (1) {
    my $fiu_name = "FIU" . $fiu_num;
    my $fiu_ref = $fiji_ini->get_block($fiu_name);
    if (!(%$fiu_ref)) {
      last;
    }
    $fiu_ref = _rename_import(FIUMAP, $fiu_ref);
    if (!defined($design_ref)) {
      my $msg = "FIU constants of $fiu_name do not match the FIJI Settings naming scheme.";
      $logger->error($msg);
      return $msg;
    }

    my $tmp_fiu = {};
    _set_defaults(FIUMAP, $tmp_fiu, $phase);
    # overwrite default entries
    foreach my $k (keys(%{$fiu_ref})) {
      $tmp_fiu->{$k} = $fiu_ref->{$k};
    }
    $fiu_ref = $tmp_fiu;

    $fiu_ref = _sanitize_fiu($fiu_ref, $phase);
    if (!ref($fiu_ref)) {
      my $msg = "(Some) constants for $fiu_name in FIJI Settings are invalid.";
      $logger->error($msg);
      return $msg;
    }
    $fiji_settings_ref->{'fius'}->[$fiu_num] = $fiu_ref;
    $fiu_num++;
    $logger->trace("Read in $fiu_name from FIJI Settings file successfully.");
  }

  if ($fiu_num == 0) {
    $logger->debug("Could not fetch any FIU blocks from config file \"$fiji_ini_file\"");
  }

  # FIU_NUM is optional in the Settings file... if it was set check that
  # it corresponds to the number of FIU<number> blocks.
  if (defined($design_ref->{'FIU_NUM'}) && $design_ref->{'FIU_NUM'} != $fiu_num) {
      my $msg = FIU_NUM->{'ini_name'} . " does not match the numbers of FIU blocks found.";
      $logger->error($msg);
      return $msg;
  } else {
    $design_ref->{'FIU_NUM'} = $fiu_num; # assume the best if FIU_NUM constant is not given
  }

  splice(@{$fiji_settings_ref->{'fius'}}, $fiu_num);
  $logger->info("Successfully read in design constants and $fiu_num FIU definitions from FIJI Settings file \"$fiji_ini_file\".");
  return $fiji_settings_ref;
}

## @method set_fiu_defaults (%$fiu_ref)
# @brief Overwrite existing fields (if defined) with defaults defined in FIJI.pm.
#
sub set_fiu_defaults ($) {
  my ($self, $consts_ref) = @_;
  return _set_defaults(FIUMAP, $consts_ref);
}

## @function _set_defaults (%$map_ref, %$consts_ref)
# @brief Set defaults according to FIJI.pm.
sub _set_defaults {
  my $logger = get_logger();
  my ($map_ref, $consts_ref, $phase) = @_;
  foreach my $k (keys(%{$map_ref})) {
    if (exists($map_ref->{$k}->{'default'})) {
      # Set default only if it is not mandatory in the given phase.
      if (defined($phase) && scalar(grep {$_ eq $phase} @{$map_ref->{$k}->{'phases_opt'}}) == 0) {
        next;
      }

      # Also, do not overwrite existing values
      if (defined($consts_ref->{$k})) {
        next;
      }
      $consts_ref->{$k} = $map_ref->{$k}->{default};
      $logger->trace(sprintf("Adding default constant: %s (%s) = %s.", $k, $map_ref->{$k}->{'ini_name'}, $map_ref->{$k}->{default}));
    }
  }
}


sub validate_design_value {
  my ($k, $v_ref) = @_;
  return validate_value(DESIGNMAP, $k, $v_ref);
}

sub validate_fiu_value {
  my ($k, $v_ref) = @_;
  return validate_value(FIUMAP, $k, $v_ref);
}

## @function validate_value (%$map_ref, $k, $$v_ref, $old, $log_func)
#   Do validation (and conversation from external->internal representation)
#
#   \param map_ref  reference to FIJI Settings mappings
#   \param k        key identifying the respective setting
#   \param v_ref    scalar reference to the proposed value (that may be modified)
#   \param old      (optional) previously valid value
#   \param log_func (optional) the (log4perl) log function to use
#                   (defaul is \&Log::Log4perl::Logger::trace)
sub validate_value ($$$;$$) {
  my $logger = get_logger();
  my ($map_ref, $k, $v_ref, $old, $log_func) = @_;
  $log_func = \&Log::Log4perl::Logger::trace if !defined($log_func);
  if (defined($map_ref->{$k}->{'type'})) {
    my $orig = ${$v_ref};
    # FIXME: check if the constant is depending on another constant, that needs to be enabled.
    # my $dependency = @{$map_ref->{$k}->{'depends_on'}};
    # if (defined($dependency) && defined(@{$map_ref->{$dependency}->{'value'}}
    # }

    if ($map_ref->{$k}->{'type'} eq 'net') {
      # TODO: check syntax? there is nothing more to do in here unless we supply allowed nets...
      # which is actually possible because the input netlist is stored in the settings as well
    } elsif ($map_ref->{$k}->{'type'} eq 'hexadecimal') {
      if ($orig !~ /^(0|(0[xX][[:xdigit:]]+))$/) {
        $log_func->($logger, "$k: $orig does not look like a natural hexadecimal number.");
        return 0;
      }
      ${$v_ref} = hex($orig);
      # Check for natural value range. Should never trigger due to the regex above.
      if (${$v_ref} < 0) {
        $log_func->($logger, "$k: $orig is negative.");
        return 0;
      }
    } elsif ($map_ref->{$k}->{'type'} eq 'natural') {
      # Match hexadecimal, binary, octal and decimal numbers (the latter also in scientific notation)
      if ($orig !~ /^(0|(0(x[0-9a-fA-F]+|[0-7]+))|(0b[01]+)|([1-9][0-9]*(e(-[0-9])?[0-9]+)?))$/) {
        $log_func->($logger, "$k: $orig does not look like a number.");
        return 0;
      }
      
      # convert non-decimal (hexadecimal, binary, octal) values to decimal
      ${$v_ref} = oct($orig) if $orig =~ /^0/;
      if (!looks_like_number(${$v_ref})) {
        $log_func->($logger, "$k: $orig does not look like a number.");
        return 0;
      }
      # Check for natural value range. Should never trigger due to the regex above.
      if (${$v_ref} < 0) {
        $log_func->($logger, "$k: $orig is negative.");
        return 0;
      }
    } elsif ($map_ref->{$k}->{'type'} eq 'boolean') {
      # convert strings to binary if need be
      if (!defined($orig)) {
        $log_func->($logger, "$k: \"undef\" is not a boolean value.");
        return 0;
      } elsif (lc($orig) eq 'true') {
        $orig = 1;
      } elsif (lc($orig) eq 'false') {
        $orig = 0;
      }
      if (($orig ne '0') && ($orig ne '1')) {
        $log_func->($logger, "$k: \"$orig\" does not look like a boolean value.");
        return 0;
      }
      # ensure proper boolean value, i.e. 0 or 1
      ${$v_ref} = (!!$orig) ? 1 : 0;
    }
    $logger->trace("Converted value of $k (\"$orig\") to \"${$v_ref}\".") if (defined($orig) && $orig ne ${$v_ref});
  }

  if (defined($map_ref->{$k}->{'values'})) {
    my $values_ref = $map_ref->{$k}->{'values'};
    if (ref($values_ref) eq 'ARRAY') {
      # Look for given value in allowed values
      if (scalar(grep {$_ eq ${$v_ref}} @{$values_ref}) == 0) {
        $log_func->($logger, "$k: ${$v_ref} is not allowed. Allowed values are: " . join(", ", @{$map_ref->{$k}->{'values'}}));
        return 0;
      }
    } elsif (ref($values_ref) eq 'CODE') {
      if (!$values_ref->(${$v_ref}, $old)) {
        $log_func->($logger, "$k: ${$v_ref} is not allowed.");
        return 0;
      }
    }
  }
  return 1;
}


# @function _rename_import (%$map_ref, %$consts_ref)
# Rename and convert entries in consts_ref according to map_ref.
#
# This function takes a hash of FIJI Settings and converts its contents
# to the respective internal representation. This allows to use different
# names and value representations in the external file than within the
# implementation.
#
# \returns $consts_ref, or undef on errors
sub _rename_import {
  my $logger = get_logger();
  my ($map_ref, $consts_ref) = @_;
  if (ref($consts_ref) ne 'HASH') {
    $logger->error("Parameter is not a reference to a hash (containing design constants).");
    return undef;
  }

  # Iterating over respective hash from FIJI.pm and rename the entries
  # to match our internal naming scheme.
  foreach my $k (keys(%{$map_ref})) {
    my $ini_name = $map_ref->{$k}->{'ini_name'};
    if (exists($consts_ref->{$ini_name}) && $ini_name ne $k) {
      $consts_ref->{$k} = $consts_ref->{$ini_name};
      $logger->trace(sprintf("Renaming Design setting %s -> %s (=%s).",
                             $ini_name,
                             $k,
                             defined($consts_ref->{$ini_name}) ? $consts_ref->{$ini_name} : "undef"),
                    );
      delete $consts_ref->{$ini_name};
    }
  }
  foreach my $entry_key (keys(%{$consts_ref})) {
    if (!exists($map_ref->{$entry_key})) {
      $logger->debug("Deleting unknown setting %s = %s.", $entry_key, $consts_ref->{$entry_key});
      delete $consts_ref->{$entry_key};
    }
  }

  return $consts_ref;
}


## @function _sanitize_fiu (%$fiu_ref, $phase)
# @brief Convert and sanity check FIJI Settings.
#
# \param fiu_ref a reference to a hash containing FIJI Settings for a
#                single FIU.
#
# \returns A new hash with all constants required in the FIU settings
#          in sanitized form, or undef on errors.
sub _sanitize_fiu ($;$) {
  my $logger = get_logger();
  my ($fiu_ref, $phase) = @_;
  if (ref($fiu_ref) ne 'HASH') {
    my $msg = "Parameter is not a reference to a hash (containing FIU constants).";
    $logger->error($msg);
    return $msg;
  }

  $fiu_ref = _validate_hashmap(FIUMAP, $fiu_ref, $phase);
  if (!ref($fiu_ref)) {
      $logger->error("Could not validate Design Constants.");
      return $fiu_ref;
  }

  return $fiu_ref;
}


sub _disabled_via_dependency ($$$) {
  my ($map_ref, $consts_ref, $k) = @_;
  my $dependency = $map_ref->{$k}->{'depends_on'};
  return defined($dependency) && !$consts_ref->{$dependency};
}


sub _validate_hashmap ($$;$) {
  my $logger = get_logger();
  my ($map_ref, $consts_ref, $phase) = @_;
  my @map_keys = keys(%{$map_ref});
  foreach my $entry_key (keys(%{$consts_ref})) {
    my $ini_name = $map_ref->{$entry_key}->{'ini_name'};
    
    if (!exists($map_ref->{$entry_key})) {
      $logger->debug("Deleting unknown setting %s = %s.", $entry_key, $consts_ref->{$entry_key});
      next;
    }

    @map_keys = grep {$_ ne $entry_key} @map_keys; # mark constant key as done
    if (_disabled_via_dependency($map_ref, $consts_ref, $entry_key)) {
      $logger->debug(sprintf("Key %s is disabled via %s. Skipping validation.", $entry_key, $map_ref->{$entry_key}->{'depends_on'}));
    } elsif (!validate_value($map_ref, $entry_key, \$consts_ref->{$entry_key})) {
      my $msg = sprintf("%s = %s is invalid.", $entry_key, !defined($consts_ref->{$entry_key}) ? "<undef>" : $consts_ref->{$entry_key});
      $logger->error($msg);
      return $msg;
    }
  }

  if (!defined($phase)) {
    # If there is no phase we are creating an "empty" hash that has
    # all possible defaults set earlier already and the there is
    # nothing we can or should do here.
    return $consts_ref;
  }

  # Iterate over the constants defined in FIJI.pm that apparently are
  # not contained in $consts_ref.
  foreach my $k (@map_keys) {
    my $dependency = $map_ref->{$k}->{'depends_on'};
    if (
        scalar(grep {$_ eq $phase} @{$map_ref->{$k}->{'phases_opt'}}) == 0 && # mandatory in current phase
        !_disabled_via_dependency($map_ref, $consts_ref, $k) # no dependency or dependency is enabled
       ) {
      my $msg = "$k is mandatory in phase $phase.";
      $logger->error($msg);
      return $msg;
    }
  }
  return $consts_ref
}


## @function _sanitize_design (%$consts_ref, $phase)
# @brief Sanity check FIJI Design Settings.
#
# The function deals with sanity checks for the values
# themselves. It checks for the following conditions:
#
#   - FIU_NUM: > 0
#   - FIU_CFG_BITS: > 0
#   - TIMER_WIDTH: > 0, <= 16
#   - ID: > 0, < 2^15-1
#   - BAUDRATE: > 0
#
# \param consts_ref a reference to a hash containing some design settings
# \param phase the tool flow phase that defines the rules to check against
#
# \returns The given hash with all constants required in the design
#          settings in sanitized form, or an error message.
sub _sanitize_design {
  my $logger = get_logger();
  my ($consts_ref, $phase) = @_;
  if (ref($consts_ref) ne 'HASH') {
    my $msg = "Parameter is not a reference to a hash (containing design constants).";
    $logger->error($msg);
    return $msg;
  }
  
  # check for sane values
  $consts_ref = _validate_hashmap(DESIGNMAP, $consts_ref, $phase);
  if (!ref($consts_ref)) {
      my $msg = "Could not validate Design Constants.";
      $logger->error($msg);
      return "$msg $consts_ref";
  }

  if (($consts_ref->{'FIU_CFG_BITS'} <= 0)) {
      my $msg = "FIU_CFG_BITS is <= 0.";
      $logger->error($msg);
      return $msg;
  }
  if (($consts_ref->{'TIMER_WIDTH'} <= 0) || ($consts_ref->{'TIMER_WIDTH'} > 16)) {
      my $msg = "TIMER_WIDTH is invalid ($consts_ref->{'TIMER_WIDTH'}).";
      $logger->error($msg);
      return $msg;
  }
  if (defined($consts_ref->{'ID'}) && ($consts_ref->{ID} < 0 || $consts_ref->{ID} > (2**16 - 1))) {
      my $msg = "ID is invalid ($consts_ref->{ID}).";
      $logger->error($msg);
      return $msg;
  }
  if (($consts_ref->{'BAUDRATE'} <= 0)) {
      my $msg = "BAUDRATE missing is <= 0.";
      $logger->error($msg);
      return $msg;
  }

  return $consts_ref;
}

sub _log2 {
    my $val = shift;
    return ($val > 0) ? (log($val)/log(2)) : 0;
}

sub estimate_resources {
    my $logger = get_logger();
    my ($settings_ref) = @_;

    # FIXME where do we put these values? they are likely to change if the VHDL
    # source is changed...

    my $CTRL_COMB_FACTOR_MIN   = 0.85; # c5 ft1
    my $CTRL_COMB_FACTOR_MAX   = 1.2;  # c3de0
    my $FIU_COMB_FACTOR_RT_MIN = 0.36; # v5max
    my $FIU_COMB_FACTOR_RT_MAX = 1.22; # c3 de0
    my $FIU_COMB_FACTOR_SI_MIN = 0.42; # v5mid
    my $FIU_COMB_FACTOR_SI_MAX = 0.75; # c3 de0
    my $BUFFER_COMB_FACTOR_MIN = 0.85; # v5max
    my $BUFFER_COMB_FACTOR_MAX = 1.1;  # c5 ft1
    my $UART_COMB_FACTOR_MIN   = 0.9;  # v5mid
    my $UART_COMB_FACTOR_MAX   = 1.83; # c3 de0

    my $consts_ref = $settings_ref->{'design'};
    my $fiu_ref = $settings_ref->{'fius'};
    my $fiubytes = ceil((@$fiu_ref*$consts_ref->{'CFGS_PER_MSG'}*$consts_ref->{'FIU_CFG_BITS'})/8.0);
    my $cfgbytes = ($consts_ref->{'TIMER_WIDTH'} * $consts_ref->{'CFGS_PER_MSG'} + 4);
    my $comb_min = 0;
    my $comb_max = 0;
    my $reg  = 0;
    my $uart_regs   = 0;
    my $ctrl_regs   = 0;
    my $fiu_regs    = 0;
    my $buffer_regs = 0;
    my $rv;


    # resources for FIC

    my $ctrl_reg_hash = {
            TRIGGER_SYNC => 3,
            FSM_STATE    => 9,
            CRC          => 8,
            ERROR_BITS   => 3,
            INJ_START    => 1,
            ID           => 16,
            CONFIG       => 8,
            RST_CNTR     => ($consts_ref->{'RESET_DUT_IN_EN'}) ? ceil(_log2($consts_ref->{'RESET_DUT_IN_DURATION'})) : 0,
            BYTE_CNTR    => ceil(_log2(max($fiubytes,$cfgbytes))),
            PAT_CNTR     => ceil(_log2($consts_ref->{'CFGS_PER_MSG'})) * 2, # we need to store an older value, too
            TIMER_STOR   => $consts_ref->{'TIMER_WIDTH'} * 8 * $consts_ref->{'CFGS_PER_MSG'}, # value storage
            TIMER_VAL    => $consts_ref->{'TIMER_WIDTH'} * 8,
            TIMER_IDLE   => 1
        };

    my $uart_reg_hash = {
            RX_SYNC         => 4,
            RX_BIT_COUNT    => 3,
            RX_BAUD_GEN     => ceil(_log2($consts_ref->{'FREQUENCY'}/$consts_ref->{'BAUDRATE'})),
            RX_STATE        => 4,
            TX_BIT_COUNT    => 3,
            TX_BAUD_GEN     => ceil(_log2($consts_ref->{'FREQUENCY'}/$consts_ref->{'BAUDRATE'})),
            TX_DATA_REG     => 8,
            TX_OUT_REG      => 1,
            TX_STATE        => 4,
            OUT_REGS_TO_CTRL=> 4
        };

    my $buffer_reg_hash = {
            BUFFER_STORAGE  => 10, # Buffer width * (Depth+1)
            BUFFER_INDEX_RD => 3, # (ceil(log2(depth)) + 1)
            BUFFER_INDEX_WR => 3, # (ceil(log2(depth)) + 1)
            READER_STATE    => 2
        };

    $logger->debug("Num FIUs: ".@$fiu_ref);

    my $stuck_open_flag = 0;

    # resources for FIUs
    foreach my $fiu (@$fiu_ref) {
        my $this_fiu_reg;
        $this_fiu_reg += 12; # we don't assume regs get optimized away when using a single model
        $this_fiu_reg += 1  if ($fiu->{'FIU_MODEL'} eq "RUNTIME" or $fiu->{'FIU_MODEL'} eq "DELAY");
        if (($fiu->{'FIU_MODEL'} eq "RUNTIME" or $fiu->{'FIU_MODEL'} eq "STUCK_OPEN")) {
            # actually, STUCK_OPEN will only be implemented if additionally $fiu->{'FIU_LFSR_MASK'} != 0 
            # but to give the user a conservative estimate immediately, we omit this condition

            $this_fiu_reg += 1;
            $stuck_open_flag = 1;
        }
        if ($fiu->{'FIU_MODEL'} eq "RUNTIME") {
            $comb_min += $this_fiu_reg * $FIU_COMB_FACTOR_RT_MIN;
            $comb_max += $this_fiu_reg * $FIU_COMB_FACTOR_RT_MAX;
        } else {
            $comb_min += $this_fiu_reg * $FIU_COMB_FACTOR_SI_MIN;
            $comb_max += $this_fiu_reg * $FIU_COMB_FACTOR_RT_MAX;
        }
        $fiu_regs += $this_fiu_reg
    }

    # LFSR will get optimized away if it is not used
    $ctrl_reg_hash->{'LFSR'} = $consts_ref->{'LFSR_WIDTH'} if $stuck_open_flag != 0;

    # calculate total registers

    for my $k (keys(%$ctrl_reg_hash)) {
        $ctrl_regs += $ctrl_reg_hash->{$k};
    }

    $logger->debug("ESTIMATE: CTRL will need ~$ctrl_regs registers");

    for my $k (keys(%$uart_reg_hash)) {
        $uart_regs += $uart_reg_hash->{$k};
    }

    $logger->debug("ESTIMATE: UART will need ~$uart_regs registers");

    for my $k (keys(%$buffer_reg_hash)) {
        $buffer_regs += $buffer_reg_hash->{$k};
    }

    $logger->debug("ESTIMATE: BUFFER will need ~$buffer_regs registers");
    $logger->debug("ESTIMATE: FIUS will need ~$fiu_regs registers");

    $reg  = $ctrl_regs + $buffer_regs + $uart_regs + $fiu_regs;

    $comb_min += $ctrl_regs   * $CTRL_COMB_FACTOR_MIN;
    $comb_max += $ctrl_regs   * $CTRL_COMB_FACTOR_MAX;
    $comb_min += $buffer_regs * $BUFFER_COMB_FACTOR_MIN;
    $comb_max += $buffer_regs * $BUFFER_COMB_FACTOR_MAX;
    $comb_min += $uart_regs   * $UART_COMB_FACTOR_MIN;
    $comb_max += $uart_regs   * $UART_COMB_FACTOR_MAX;

    $rv->{'regs'} = ceil($reg/10)*10;
    $rv->{'comb_min'} = ceil($comb_min/10)*10;
    $rv->{'comb_max'} = ceil($comb_max/10)*10;
    $logger->debug("ESTIMATE: current config will need ~$reg registers and ~$comb_min to $comb_max LUTs (tech-dependent)");
    $logger->debug("ESTIMATE: current config will need ~$rv->{'regs'} registers and ~$rv->{'comb_min'} to $rv->{'comb_max'} LUTs (tech-dependent)");
    return $rv;
}

1;