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

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

Описание

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

  • Размер функционального возвращаемого значения

  • Размеры параметров функции

  • Размеры локальных переменных

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

    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
Параметр param48
Локальные переменные var_1 и var_24+4=816
Локальные переменные заданы в условии 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
Параметр param12
Дополнительное дополнение, введенное перед var_1, хранится

2

Память должна быть выровнена с помощью дополнения, потому что следующая переменная var_1 требует четырех байтов. Устройство хранения данных должно начать с адреса памяти в кратном четыре.

4
var_148
Дополнительное дополнение, введенное перед var_2, хранится

0

Никакое выравнивание памяти не требуется, потому что следующая переменная var_2 имеет меньший размер.

8
var_219
Дополнительное дополнение, введенное перед var_3, хранится

3

Память должна быть выровнена с помощью дополнения, потому что следующая переменная var_3 требует восьми байтов. Устройство хранения данных должно начать с адреса памяти в кратном выравниванию, четыре байта.

12
var_3820

Правила для объема дополнения:

  • Если следующая сохраненная переменная имеет тот же или меньший размер, никакое дополнение не требуется.

  • Если следующая переменная имеет больший размер:

    • Если переменный размер эквивалентен или меньше, чем выравнивание на платформе, объем дополнения должен быть достаточным так, чтобы адрес ЗУ был кратным своему размеру.

    • Если переменный размер больше, чем выравнивание на платформе, объем дополнения должен быть достаточным так, чтобы адрес ЗУ был кратным выравниванию.

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).

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
Метрика HIS: нет

Введенный в R2017b