Wie effizient sind Variable Length Arrays nach C99?

mngbd

Ich wüsste gerne, ob es auf einer durchschnittlichen Architektur teurer ist, ein Array mit variabler Länge (VLA) auf den Stack zu legen, als eines mit konstanter Länge; und wenn ja, ob man abschätzen kann, wieviel teurer.

Wenn man auf den vorhandenen Platz auf dem Stack acht gibt, könnten diese VLA hin und wieder durchaus nützlich sein, denke ich. Das will ich evaluieren, und bitte dabei um eure Hilfe.

Wutz

VLA ist alloca in den Standard (C99) gehoben, u.a. mit dem Stacküberlaufsproblem, wobei man dieses mit Auswertung des alloca-Returnwertes wenigstens noch dynamisch abfangen konnte.

rüdiger

Wenn der Compiler keine Überprüfung auf Stackoverflow einbaut (was wohl die wenigsten machen, aber auch nicht viel bringt, da das einzig sinnvolle in dem Fall ein Absturz wäre. Aber immerhin nur DOS und keine Sicherheitslücke), dann sollte das ganze ja nur auf laden der Länge und eine Subtraktion vom Stackpointer hinauslaufen.

Ich hab das mal ausprobiert:

#include <stdio.h>
#include <time.h>

__inline__ void test_fixed() {
  int foo[256];
}

__inline__ void test_vla() {
  int n = 256;
  int foo[n];
}

int main(void) {
  clock_t b, m, e;
  int i;

  b = clock();
  for(i = 0; i < 100000000; ++i) { test_fixed(); }
  m = clock();
  for(i = 0; i < 100000000; ++i) { test_vla(); }
  e = clock();

  printf("%lf - %lf\n",
         (double)(m - b) / CLOCKS_PER_SEC,
         (double)(e - m) / CLOCKS_PER_SEC);

  return 0;
}

$ gcc test.c && ./a.out
0.300000 - 0.520000
$ gcc -O1 test.c && ./a.out 
0.040000 - 0.260000
$ gcc -O2 test.c && ./a.out 
0.000000 - 0.220000
$ gcc -O3 test.c && ./a.out 
0.000000 - 0.220000

mit gcc 4.5.1.

Jetzt wird ab -O1 der Funktionskörper von test_fixed wegoptimiert, so dass nur das erste ein sinnvoller Vergleich ist (ich habe bisher nicht rausgekriegt, wie ich diese spezielle Optimierung unterbinde), aber es scheint so zu sein, als habe zumindest der gcc größere Probleme, im Optimierer mit VLAs umzugehen als mit normalen Arrays.