Более низкая оценка размера локальной переменной

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

Описание

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

Размер возвращаемого значения функции
Размеры функциональных параметров
Размеры локальных переменных
Предположим, что функция имеет определения переменных во вложенных областях следующим образом:
```
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

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