Lower Estimate of Local Variable Size

Общий размер локальных переменных в функции с учетом вложенных возможностей

Описание

Эта метрика предоставляет оптимистическую оценку общего размера локальных переменных в функции. Метрика является суммой следующих размеров в байтах:

Размер возвращаемого значения функции
Размеры параметров функции
Размеры локальных переменных
Предположим, что функция имеет определения переменных во вложенных возможностях следующим образом:
```
type func (type param_1, ...) {

  {
    /* Scope 1 */
    type var_1, ...;
  }
  {
    /* Scope 2 */
    type var_2, ...;
  }
}
```
Программа вычисляет общий размер переменной в каждых возможностях видимости и использует тот, который больше всего. Например, если условный оператор имеет определения переменных, программа вычисляет общий размер переменной в каждой ветви и затем использует то, какая сумма является наибольшей. Если вложенные возможности сама имеют дополнительные вложенные возможности, тот же процесс повторяется для внутренних возможностей.
Переменная, заданная во вложенных возможностях не вне возможностей. Поэтому некоторые компиляторы повторно используют пространство стека для переменных, определенных в отдельных возможностях. Эта метрика обеспечивает более точную оценку использования стека для таких компиляторов. В противном случае используйте метрику Higher Estimate of Local Variable Size. Эта метрика добавляет размер всех локальных переменных, независимо от того, заданы ли они во вложенных возможностях.
Дополнительное заполнение, введенное для выравнивания памяти

Фактическое использование стека из-за локальных переменных может отличаться от метрического значения.

Некоторые переменные хранятся в регистрах вместо в стеке.
Ваш компилятор выполняет переменный анализ жизни, чтобы включить определенную оптимизацию памяти. При вычислении этой метрики Polyspace^® не рассматривает эти оптимизации.
Ваш компилятор использует дополнительную память во время вызова функции. Например, компиляторы хранят адрес, на который возвращается выполнение после вызова функции. При вычислении этой метрики Polyspace не рассматривает это скрытое использование памяти.

Однако метрика предоставляет разумную оценку использования стека из-за локальных переменных.

Чтобы определить размеры основных типов, программное обеспечение использует ваши спецификации для Target processor type (-target). Метрика также учитывает #pragma pack директивы в вашем коде.

Примеры

расширить все

Все переменные одного типа

int flag();

int func(int param) {
  int var_1;
  int var_2;
  if (flag()) {
      int var_3;
      int var_4;
    } else {
      int var_5;
    }
}

В этом примере, принимая четыре байта для intнижняя оценка размера локальной переменной составляет 24. Распад метрики показан в этой таблице.

Переменная	Размер (в байтах)	Общее выполнение
Возвращаемое значение	4	4
Параметрический `param`	4	8
Локальные переменные `var_1` и `var_2`	`4+4=8`	16
Локальные переменные, определенные в `if` состояние	`max(4+4,4)= 8` Размер переменных в первой ветви составляет восемь байт. Размер во второй ветви - четыре байта. Максимум двух ветвей - восемь байт.	24

Заполнение для выравнивания памяти не введено, потому что все задействованные переменные имеют одинаковый тип.

Переменные разных типов

char func(char param) {
  int var_1;
  char var_2;
  double var_3;
}

В этом примере, принимая один байт для char, четыре байта для int, восемь байтов для double и четыре байта для выравнивания, более низкая оценка размера локальной переменной составляет 20. Выравниванием обычно является размер слова на вашей платформе. В проекте Polyspace вы задаете выравнивание через целевой процессор. Для получения дополнительной информации см. столбец « Выравнивание» в Target processor type (-target).

Разбивка по размеру показана в этой таблице.

Переменная	Размер (в байтах)	Общее выполнение
Возвращаемое значение	1	1
Дополнительная набивка, введенная перед `param` хранится	0 Выравнивание памяти не требуется, поскольку следующая переменная `param` имеет тот же размер.	1
Параметрический `param`	1	2
Дополнительная набивка, введенная перед `var_1` хранится	`2` Память должна быть выровнена с помощью заполнения, поскольку следующая переменная `var_1` требуется четыре байта. Устройство хранения данных должно начинаться с адреса памяти, кратного четырем.	4
`var_1`	4	8
Дополнительная набивка, введенная перед `var_2` хранится	0 Выравнивание памяти не требуется, поскольку следующая переменная `var_2` имеет меньший размер.	8
`var_2`	1	9
Дополнительная набивка, введенная перед `var_3` хранится	3 Память должна быть выровнена с помощью заполнения, поскольку следующая переменная `var_3` требуется восемь байтов. Устройство хранения данных должно начинаться с адреса памяти, кратного выравниванию, четыре байта.	12
`var_3`	8	20

Правилами для количества заполнения являются:

Если следующая сохраненная переменная имеет тот же или меньший размер, заполнение не требуется.
Если следующая переменная имеет больший размер:
- Если размер переменной совпадает или меньше, чем выравнивание на платформе, количество заполнения должно быть достаточным, чтобы адрес памяти был кратен его размеру.
- Если размер переменной больше, чем выравнивание на платформе, количество заполнения должно быть достаточным, чтобы адрес памяти был кратен выравниванию.

Методы и объекты C++

class MySimpleClass {
  public:

    MySimpleClass() {};

    MySimpleClass(int) {};

    ~MySimpleClass() {};  
};


int main() {
  MySimpleClass c;
  return 0;
}

В этом примере предполагаемые локальные размеры переменных:

Функции конструктора MySimpleClass::MySimpleClass(): Четыре байта.
Размер исходит из this указатель, который является неявным аргументом для конструктора. Размер указателя задается с помощью опции Target processor type (-target).
Функции конструктора MySimpleClass::MySimpleClass(int): Восемь байт.
Размер исходит из this указатель и int аргумент.
Деструктор MySimpleClass::~MySimpleClass(): Четыре байта.
Размер исходит из this указатель.
main(): Пять байт.
Размер исходит из int возвращаемое значение и размер объекта c. Минимальный размер объекта - это выравнивание, заданная с помощью опции Target processor type (-target).

Функции C++ с аргументами объекта

class MyClass {
  public:
    MyClass() {};
    MyClass(int) {};
    ~MyClass() {};
  private:
    int i[10];   
};
void func1(const MyClass& c) {
}


void func2() {
  func1(4);  
}

В этом примере предполагаемый размер локальной переменной для func2() составляет 40 байт. Когда func2() вызывает func1(), временный объект класса MyClass создается. Объект имеет десять int переменные с размером четырех байтов.

Метрическая информация

Группа: Функция

Акроним: LOCAL_VARS_MIN

ЕГО Метрика: Нет

См. также

Calculate code metrics (-code-metrics) | Higher Estimate of Local Variable Size

Введенный в R2016b

Документация