Will compilatore ottimizzare malloc/liberi o nuova/delete coppia in alloca

Question

C'è qualche maturare C/C++, in grado di ottimizzare malloc/free (o new/delete) coppie di informazioni alloca? In altre parole, convertire da memoria basata su heap a stack (SOLO per alcuni casi limitati).

Questa ottimizzazione può essere consentita solo per coppia di malloc/free quando entrambe le funzioni sono nella stessa funzione (o anche nello stesso blocco di {}) e viene chiamata ogni volta che viene chiamato malloc. Inoltre, consideriamo che il puntatore alla memoria malloced non viene salvato in alcune variabili globali.

Quindi, sarà GCC/LLVM + clang/Intel Compiler convertire tale blocco di codice:

{ 
    char *carray; 
    carray = malloc(100);   // or malloc(N) 
    // some string-like work with carray 
    free(carray); 
} 

in

{ 
    char*carray; 
    carray = alloca(100); // or if(N<const1) carray=alloca(N);else carray=malloc(N) 
    // the same work 
    // nothing      // or if(N>=const1) free(carray) 
} 

Questa conversione potrebbe non essere molto utile per ogni programma, ma penso , potrebbe esserci qualche opzione speciale per il compilatore.

PS (Update1) Siamo in grado di limitare la nostra discussione solo per i casi in cui compilatore sa che malloc e libero è da libc (stdlib)

Answer 1

Tecnicamente, i compilatori possono ottimizzare qualsiasi cosa purché essi seguono il come-se regola.
Quindi, è possibile ottimizzare le allocazioni dell'heap per allocare le allocazioni, ma è necessario che il compilatore sia abbastanza intelligente da sondare l'utilizzo e determinare che la modifica dell'assegnazione allo stack non influirà sul comportamento osservabile del programma.

Non sono a conoscenza di alcun compilatore che esegue questa operazione.

Answer 2

In generale, nessun compilatore esegue questa ottimizzazione. Va bene, perché questa cosa può essere potenzialmente molto dannosa: tieni presente che lo stack di solito è molto limitato nelle sue dimensioni. Se un compilatore ottimizzato malloc + free in un alloca, il comportamento osservabile del codice cambierebbe: per alcuni input, non sarebbe in crash con malloc + free, ma sarebbe con alloca (perché lo spazio di stack ottenuto esaurito). Pertanto, questa ottimizzazione non è sicura (e illegale secondo lo standard, poiché modifica il comportamento osservabile) e i compilatori non tentano nemmeno di eseguirlo.

Detto questo, in alcune circostanze molto specifiche, un compilatore potrebbe eseguirlo, ma nessun compilatore ne sono a conoscenza.

L'ottimizzazione eseguita da LLVM e menzionato in the comments è una cosa diversa, ottimizza solo malloc s che vengono confrontati solo a null e quindi free d.

Answer 3

È in corso l'off-shoot di LLVM denominato poolalloc che esegue questa ottimizzazione. Viene gestito come parte di SAFECode e non si trova nella distribuzione LLVM della linea principale.

E 'descritto nel documento Chris Lattner PhD thesis e nella carta PLDI this. Il codice è here.