Otlang ottimizzazioni del compilatore

Question

Non sono esperto di ottimizzazione del compilatore. Non sono nemmeno sicuro di cosa sia "ragionevole" aspettarsi per quanto riguarda i compilatori o le ottimizzazioni. Sono solo curioso e faccio domande è tutto.

In ogni caso, mi è stato codificare fino qualche Erlang in una forma di base di questo tipo:

% TOY EXAMPLE 1 
test(X) -> 
    if 
     X-1 > 0 -> 
      yes; 
     X-1 == 0 -> 
      maybe; 
     true -> no 
    end. 

Poi ho poi ottimizzato al fine di non fare lo sottrarre due volte:

% TOY EXAMPLE 2 
test(X) -> 
    Z = X-1, 
    if 
     Z > 0 -> 
      yes; 
     Z == 0 -> 
      maybe; 
     true -> no 
    end. 

Poi ho pensato "una perdita di tempo - sicuramente il compilatore ottimizza comunque il primo esempio nel secondo". Così ho deciso di verificare eseguendo compilazione: file con l'opzione "S" per entrambi. Ecco l'output:

% TOY EXAMPLE 1 
{function, test, 1, 15}. 
    {label,14}. 
    {func_info,{atom,exchange},{atom,test},1}. 
    {label,15}. 
    {gc_bif,'-',{f,16},1,[{x,0},{integer,1}],{x,1}}. 
    {test,is_lt,{f,16},[{integer,0},{x,1}]}. 
    {move,{atom,yes},{x,0}}. 
    return. 
    {label,16}. 
    {gc_bif,'-',{f,17},1,[{x,0},{integer,1}],{x,1}}. 
    {test,is_eq,{f,17},[{x,1},{integer,0}]}. 
    {move,{atom,maybe},{x,0}}. 
    return. 
    {label,17}. 
    {move,{atom,no},{x,0}}. 
    return. 

% TOY EXAMPLE 2 
{function, test, 1, 15}. 
    {label,14}. 
    {func_info,{atom,exchange},{atom,test},1}. 
    {label,15}. 
    {gc_bif,'-',{f,0},1,[{x,0},{integer,1}],{x,0}}. 
    {test,is_lt,{f,16},[{integer,0},{x,0}]}. 
    {move,{atom,yes},{x,0}}. 
    return. 
    {label,16}. 
    {test,is_eq,{f,17},[{x,0},{integer,0}]}. 
    {move,{atom,maybe},{x,0}}. 
    return. 
    {label,17}. 
    {move,{atom,no},{x,0}}. 
    return. 

Non sono la stessa cosa. Se sto leggendo questo diritto (forse non lo sono), l'ottimizzazione non viene eseguita.

posso vedere un paio di possibilità:

1. L'ottimizzazione può essere eseguita, sto solo non consentendo le ottimizzazioni perché sto utilizzando la funzione sbagliato a compilare, o non utilizzo i flag corretti, ecc.

2. L'ottimizzazione non viene eseguita.

3. Altro.

Quale è?

Nota: Si prega di non impantanarsi quando si parla di "se si utilizza una dichiarazione di un caso si può fare tale e così" o "si può evitare facendo blah-blah". Il punto è semplicemente quello di testare quali ottimizzazioni il compilatore di erlang fa o non fa, e perché o perché no.

Grazie.

Answer 1

Hai perfettamente ragione: il compilatore Beam non esegue alcuna eliminazione di sottoespressione comune. Il motivo è probabilmente che nel tipo di programmi per cui Erlang viene tipicamente utilizzato, questo non avrebbe alcun effetto evidente, quindi nessuno si è preso la briga di implementarlo. (Per i rari casi di codice Erlang computazionalmente intensivo, è facile per il programmatore occuparsi di questo, come nel secondo esempio.)

Se si compila il codice nativo, è possibile ottenere questo tipo di ottimizzazione - Il compilatore HiPE si impegna a generare un buon codice di basso livello.