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 переменные, каждый с размером четырех байтов.