Накладные расходы переменной длины в С++?

Глядя на этот вопрос: Почему компилятору C/С++ нужно знать размер массива во время компиляции?, мне пришло в голову, что разработчики компилятора должны были несколько раз, чтобы получить свои ноги теперь (это часть стандарта C99, что 10 лет назад) и обеспечивают эффективные реализации.

Однако по-прежнему кажется (из ответов) считаться дорогостоящим.

Это меня как-то удивляет.

Конечно, я понимаю, что статическое смещение намного лучше, чем динамическое с точки зрения производительности, и, в отличие от одного предложения, я бы не имел на самом деле компилятор, выполняющий распределение кучи массива, поскольку это, вероятно, стоило бы еще больше [ это не было измерено;)]

Но я все еще удивляюсь предполагаемой стоимости:

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

Возникает вопрос о нескольких VLA, конечно, и мне было интересно, будет ли работать выделенный VLA-стек. Это означает, что VLA будет отображаться счетчиком и указателем (из известных размеров), а фактическая память, взятая во вторичном стеке, используется только для этой цели (и, следовательно, действительно является стеком).

[перефразировать]

Как VLAs реализованы в gcc/VС++?

Действительно ли это действительно впечатляет?

[end rephrasing]

Мне кажется, что это может быть лучше, чем использование, скажем, vector, даже с существующими реализациями, поскольку вы не несете затраты на динамическое размещение (за счет того, что не изменяете размер).

EDIT:

Существует частичный ответ здесь, однако сравнение VLA с традиционными массивами кажется несправедливым. Если бы мы знали размер заранее, то нам не понадобилось бы VLA. В том же вопросе AndreyT дал некоторые указания относительно реализации, но это не так точно, как хотелось бы.

Ответ 1

Как VLAs реализованы в gcc/VС++?

AFAIK VС++ не реализует VLA. Это компилятор С++ и поддерживает только C89 (без VLA, без ограничений). Я не знаю, как gcc реализует VLA, но самым быстрым способом является сохранение указателя на VLA и его размер в статической части стекового кадра. Таким образом, вы можете получить доступ к одному из VLA с производительностью массива с постоянным размером (это последний VLA, если стек растет вниз, как в x86 (разыменование [указатель стека + индекс * размер элемента + размер последних временных нажатий]), и первый VLA, если он растет вверх (разыменование [указатель стека/смещение от размера стека/рамки + индекс *))). Все остальные VLA нуждаются в еще одном обращении, чтобы получить свой базовый адрес из статической части стека.

[Редактировать: также при использовании VLA компилятор не может опустить указатель на стек-фрейм, который в противном случае лишний, поскольку все смещения от указателя стека могут быть вычислены во время компиляции. Итак, у вас есть один бесплатный бесплатный реестр. — end edit]

Действительно ли это действительно впечатляет?

Не совсем. Более того, если вы не используете его, вы не платите за него.

[Edit: Возможно, более правильным ответом будет: По сравнению с чем? По сравнению с выделенным кучей вектором время доступа будет таким же, но распределение и освобождение будут быстрее. — end edit]

Ответ 2

Если бы это было реализовано в VС++, я бы предположил, что команда компилятора использует некоторый вариант _alloca(size). И я думаю, что стоимость эквивалентна использованию переменных с более чем 8-байтовым выравниванием в стеке (например, __m128); компилятор должен где-то хранить исходный указатель стека, а для выравнивания стека требуется дополнительный регистр для хранения неуравновешенного стека.

Таким образом, накладные расходы в основном являются дополнительным направлением (вы должны где-то хранить адрес VLA) и регистрировать давление из-за хранения исходного диапазона стека где-то также.