# Vi va di discutere le mie CFLAGS?

## n3m0

Sapete che e' da poco che bazzico su Gentoo.

Informati e re-informati, la stringa di CFLAGS e' variata.

Visto che sono in test, vorrei ricompilare il tutto, ma prima vorrei discutere con voi dei miei FLAGS, visto che sono un po' spinti  :Smile: 

Alcune le commentero'...

```

-O3 -force-addr -fmerge-all-constants 

```

```

-ffast-math

```

Velocita' a discapito di precisione

```

 -funroll-loops

```

Loop unrolling. Crea codice più grande, ma più veloce. I loop srotolati sono solo quelli con numero di iterazioni certe. 

```

 -fprefetch-loop-arrays -fstrict-aliasing

```

strict-aliasing non mi piace tanto, vorrei toglierla, che dite? 

```

-falign-functions=64

```

Consigliato da AMD per Athlon, causa 64byte cache line alignment nella cache L1

```

-falign-loops=16 -falign-jumps=16 

```

align-jumps a 16 sempre grazie al manuale AMD.

align-loops mi e' stato consigliato a 16, ma non ho trovato ancora riscontro nel manuale AMD

```

-fmove-all-movables 

```

tutto cio' che non varia in un ciclo, viene portato fuori. Ovvie conseguenze.

```

-march=athlon-xp -msse -mmmx -m3dnow -mfpmath=sse -mpreferred-stack-boundary=4 -mno-push-args -maccumulate-outgoing-args -minline-all-stringops -pipe"

```

Ciao a tutti! E non picchiatemi per le troppe flags!  :Smile: 

----------

## quantumwire

Qual'e' la versione del compilatore (quasi certamente gcc) che usi?  :Very Happy: 

In materia non ti posso aiutare molto pero' ti indico questo link:

http://gcc.gnu.org/onlinedocs/gcc-3.3.2/gcc/Option-Index.html#Option%20Index

relativo alla versione 3.3.2 del gcc.

Inoltre, se non erro, l'opzione 

```
-O3
```

e' di per se equivalente alla seguente barca di ottimizzazioni:

```

-fdefer-pop

-fmerge-constants

-fthread-jumps

-floop-optimize

-fcrossjumping

-fif-conversion

-fif-conversion2

-fdelayed-branch

-fguess-branch-probability

-fcprop-registers

-fomit-frame-pointer

-fforce-mem

-foptimize-sibling-calls

-fstrength-reduce

-fcse-follow-jumps

-fcse-skip-blocks

-frerun-cse-after-loop

-frerun-loop-opt

-fgcse

-fgcse-lm

-fgcse-sm

-fdelete-null-pointer-checks

-fexpensive-optimizations

-fregmove

-fschedule-insns

-fschedule-insns2

-fsched-interblock

-fsched-spec

-fcaller-saves

-fpeephole2

-freorder-blocks

-freorder-functions

-fstrict-aliasing

-falign-functions

-falign-jumps

-falign-loops

-falign-labels

-finline-functions

-frename-registers

```

Sul mio laptop (P4 - 2.8GHz) uso la seguente definizione per la variabile CFLAGS:

```

CFLAGS="-O3 -march=i686 -pipe"

```

Qualche suggerimento?

----------

## bld

evil mode ON

 :Evil or Very Mad:  no a me non mi va piu di discutere di CFLAGS!

evil mode OFF

Ci sono talmente tanti forum che discuttono del'argomento, credo che trovi piu di quello che ti occore anche in italiano.

cmq io uso quelle "super classiche"

 *Quote:*   

> 
> 
> [5:23:10 ~ ]> cat /etc/make.conf|grep -i cflags
> 
> # For optimal performance, enable a CFLAGS setting appropriate for your CPU
> ...

 

----------

## n3m0

 *quantumwire wrote:*   

> Qual'e' la versione del compilatore (quasi certamente gcc) che usi? 
> 
> 

 

La 3.3.2

Le ridondanze sono dovute al fatto che alcune devono assumere dei valori diversi da quelli di default.

 *Quote:*   

> 
> 
> Sul mio laptop (P4 - 2.8GHz) uso la seguente definizione per la variabile CFLAGS:
> 
> ```
> ...

 

-march=pentium4 -funroll-loops -fprefetch-loop-arrays -msse -msse2 -mmmx -mfpmath=sse -mpreferred-stack-boundary=4 -mno-push-args -maccumulate-outgoing-args -minline-all-stringops

----------

## n3m0

 *bld wrote:*   

> 
> 
> Ci sono talmente tanti forum che discuttono del'argomento, credo che trovi piu di quello che ti occore anche in italiano.
> 
> 

 

Lo so, ma mi piaceva l'idea di discuterne attivamete.

Se proprio si tratta di superFAQ, si puo' pure lasciar stare.

----------

## cerri

Ricordati che non sempre CFLAGS più spinte ti danno performance più elevate. Dipende da notevoli fattori tra i quali, non ultimo, kernel, glibc e programmi che si compilano decentemente.

Non esagerare con le CFLAGS: otterrai solo problemi (con il vantaggio di avere quell'agognato magari 1% in più di velocità su una o due applicazioni).

Per darti un'idea, le altre distro sono in genere compilate usando '-march=i686 -O2' (e spesso anche peggio).

----------

## shev

 *n3m0 wrote:*   

> Lo so, ma mi piaceva l'idea di discuterne attivamete.
> 
> Se proprio si tratta di superFAQ, si puo' pure lasciar stare.

 

Per ora direi che potete continuare, perlomeno si sta discutendo un po' più "a fondo" del solito. Quindi se approfondite qualche aspetto, commentate in modo tecnicamente valido le flags allora continuate pure (ci sarebbero cmq altri topic di questo genere, ma per ora sorvoliamo). Se però il discorso cade nel solito "che flags usate", "cosa consigliate", "è meglio X o Y" allora blocco tutto.

p.s.: non dico nulla in prima persona sulle cflags perchè a forza di leggere e scrivere commenti comincio ad averne la nausea  :Twisted Evil: 

----------

## bld

 *n3m0 wrote:*   

>  *bld wrote:*   
> 
> Ci sono talmente tanti forum che discuttono del'argomento, credo che trovi piu di quello che ti occore anche in italiano.
> 
>  
> ...

 

cmq, scusa mi   :Embarassed:   forse con te sono stato molto cattivo. Se provi al forum "CFLAGS CENTRAL" sono arrivati a pagina 27, e devo dire che le flags che propongono sono abbastanza complicate, e le ho provate qualche volta con tanti errori di compilazione. E poi tante sono "redundand", e' un argomento delicato.

----------

## n3m0

Grazie Shev  :Smile: 

Approfitto allora per comunicare e commentare alcune mie modifiche decise oggi, modifiche ancora in "beta" 

Fare riferimento al mio post di apertura thread.

Per dettagli sui flag che si elencheranno: man gcc  :Smile: 

Iniziamo con: 

```

-falign-functions

-falign-jumps

```

Tutte sono implicate (così come le ho appena scritte) da -O3.

Da manuale AMD, come già detto, setto falign-functions=64 e falign-jumps=16

Pero' continua a girarmi in testa la frase che il man di gcc riporta riguardo le opzioni falign*: 

"If n is not specified or is zero, use a machine-dependent default."

E mi chiedevo: visto che il default e' "machine-dependent", gcc (con O3 che implica -falign* con n non specificato) userà falign-functions=64 trovando march=athlon-xp?

Sto cercando, ma non trovo risposta.

La logica vorrebbe un si come risposta alla mia domanda, ma sono dubbioso.

Sentenza: per ora sono lasciate a machine-dependent default implicato da -O3

Ma continuiamo con: 

```

-mpreferred-stack-boundary=4

```

E' il default (se non si usa -Os, e non è questo il caso)

Sentenza: eliminata

```

-mno-push-args 

-maccumulate-outgoing-args

```

A parte il fatto che la seconda implicava la prima, ho riflettuto sulla frase del man al riguardo: 

"The drawback is a notable increase in code size"

Non credo che il vantaggio apportato in termini di tempi di esecuzione sia tanto da giustificare lo svantaggio apportato in termini di tempi di loading, causa il percettibile incremento della dimensione del codice.

Sentenza: eliminate

```

-fstrict-aliasing

```

Implicata da -O3, forzerei l'esatto opposto.

Sentenza: per ora cambiata con -fno-strict-aliasing

```

-minline-all-stringops

```

Aumenta dimensione del codice senza certezza di migliori performance.

Sentenza: eliminata

```

-fmerge-all-constants

```

Incremento di performance impercettibile e non sicuro.

Stabilità non sicura.

Infrange l'ANSI standard per C e C++

Più che sufficiente la -fmerge-costants (implicata a qualsiasi livello di O)

Sentenza: eliminata

```

-funroll-loops

```

Oltre ai vantaggi descritti nel man, volevo fare un commento per i possessori della mia stessa CPU.

Tale flag e' suggerita da AMD (e trova riscontro nel manuale): 

"Make use of the large AMD Athlon processor 64-K byte

instruction cache and unroll loops to get more parallelism and

reduce loop overhead, even with branch prediction. Complete

unr o lling re duces re gister pressure by re moving the loop

counter. To completely unroll a loop, remove the loop control

and replicate the loop body N times. In addition, completely

unrolling a loop increases scheduling opportunities."

Sentenza: flag mantenuta

Ne segue la nuova stringa di flags: 

CFLAGS="-march=athlon-xp -O3 -pipe -mmmx -msse -m3dnow -mfpmath=sse -fforce-addr -fomit-frame-pointer -ffast-math -fmove-all-movables -funroll-loops -fprefetch-loop-arrays"

CXXFLAGS=$CFLAGS

Tra l'altro, -mmmx -3dnow -msse dovrebbero essere implicati da -march=athlon-xp, ma non ne sono certo.

Qualcuno puo' confermarmelo?

Colgo l'occasione per aggiungere dei commenti sulle delle flags che ho gia' scartato tempo fa: 

```

-funroll-all-loops

```

Simile a -funroll-loops, questa flag srotola anche loop con un numero di iterazioni non certo. Questo con molta probabilità puo' creare codice che verra' eseguito più lentamente. In piu' si incrementa ulteriormente la dimensione del codice.

Sentenza: sconsigliata, IMHO

```

-malign-double

```

Solo per Pentium e Pentiun Pro.

Per esperienza, su AMD produce codice che fa cose strane e diverse da quelle che dovrebbe fare.

Sentenza: da non usare su AMD e Pentium superiori

Alla prox ragazzi!

Ciao!

----------

## n3m0

 *bld wrote:*   

> 
> 
> cmq, scusa mi    forse con te sono stato molto cattivo. 
> 
> 

 

Di niente, figurati.

Capisco che il proliferare di troppi post simili e' sconsigliato.

Il mio intento non è cmq quello di confrontare le CFLAGS come se fossero figurine dei calciatori, ma quello di capire meglio alcune flags.

 *bld wrote:*   

> 
> 
> Se provi al forum "CFLAGS CENTRAL" sono arrivati a pagina 27, e devo dire che le flags che propongono sono abbastanza complicate,
> 
> 

 

Ho iniziato a leggere sin da subito quel topic, grazie al vostro "Post utilissimi" che lo segnalava.

Mi sono permesso di aprire un thread simile qui, per parlare e leggere in italiano.

Pur non avendo problemi con l'inglese, ogni tanto e' bello parlare la propria lingua.  :Wink: 

 *bld wrote:*   

> 
> 
>  e le ho provate qualche volta con tanti errori di compilazione. E poi tante sono "redundand", e' un argomento delicato.

 

Finora ho avuto delle flags abbastanza spinte e il sistema ha compilato senza problemi, anche se mi sono reso conto che forse certa roba faceva più male che bene e pian piano sto sfoltendo.

L'unico problema che ho e' che la sun-j2sdk 1.4.2 non mi fa andare Eclipse 3M*, ma funziona un amore cn molte altre java-apps.

Ma per questo sto su altro thread.

Ciao!

----------

## Sparker

Secondo molti O2 generalmente dà un risultato migliore rispetto ad O3 (che tende ad ingrossare il codice senza aumenti significativi)

P.S. Cosa intendi con il manuale AMD?

----------

## n3m0

 *Sparker wrote:*   

> Secondo molti O2 generalmente dà un risultato migliore rispetto ad O3 (che tende ad ingrossare il codice senza aumenti significativi)
> 
> 

 

Consideriamo le sole due flags che O3 aggiunge a quelle di O2: 

```

-finline-functions 

-frename-registers

```

La prima effettivamente crea codice più grosso.

Bisognerebbe capire questo quanto discapito porta al tempo di loading.

Non credo cmq che crei codice talmente grosso da influire sensibilmente anche sul page-in/page-out.

Ma va giustamente ponderata: l'avevo data troppo per scontata, grazie  :Smile: 

Per la seconda invece, credo che l'unico svantaggio sia quello che rende impossibile il debug.

Mentre scrivevo, riflettevo sulla prima...effettivamente forse crea eseguibili un po' troppo onerosi rispetto al vantaggio che realmente apporta...

Beh me la studio meglio.

Ma credo che se scelgo di eliminarla, lo faccio mantendo -O3 e forzando -fno-inline (oppure mettendo -O2 e aggiungendo -frename-registers, forse e' meglio  :Smile: )

A meno che non decida di mettere un O2 puro.

Devo ponderare  :Smile: 

 *Sparker wrote:*   

> 
> 
> P.S. Cosa intendi con il manuale AMD?

 

La guida per l'ottimizzazione del codice x86 di AMD.

La trovi sul sito ufficiale.

Hola a todos!

----------

## randomaze

Hai provato anche a dilettarti con alcovea?

----------

## Detronizator

Salve.

Prima di tutto listo semplicemente.

```

CFLAGS="-mcpu=pentium4 -march=pentium4 -O3 -pipe -mfpmath=sse -msse2 -mpush-args -maccumulate-outgoing-args -funroll-loops -fomit-frame-pointer -fprefetch-loop-arrays -ffast-math -fforce-addr -fforce-mem -falign-functions -falign-labels -falign-loops -falign-jumps -foptimize-sibling-calls -fmerge-constants -fmove-all-movables"

```

Salto volentieri i flag ovvi legati alla mia archietettura (P4).

```

-maccumulate-outgoing-args

```

La trovo una funzione molto utile che, a patto di avere codice che non va in crash con particolari strutture, fa sentire i suoi effetti.

```

-falign-functions -falign-labels -falign-loops -falign-jumps

```

Le più "grasse", secondo me: ho compilato l'intera distro e si é presa 7gb! Togliendo i 2 gb di sorgenti, il resto é TUTTO CODICE. Ovvio io dico che queste funzioni di allineamento in memoria mantengono le promesse: incremento visibile delle dimensioni dei binari.

=> Penso di rimuoverle

```

-ffast-math

```

Io non devo fare nessuna applicazione con calcoli di precisione estrema => Mi tengo stretta questa FLAGS che "semplifica i calcoli matematici"

Delle altre mi fido ma in base solo al GCC. In verità non ne sono sicurissimo. Per ora però ho avuto un solo problema con la J2SDK che era tanto ottimizzata da non riuscire ad eseguire Eclipse 3M* (stesso problema di N3m0)(ps ce l'hai fatta a farmi postare  :Wink:  ).

Io proporrei una cosa: un Thread "da bloccare" con la raccolta delle USE-FLAGS più testate e sicure per ogni architettura. Esempio: alcune di queste FLAGS hanno dato problemi a N3m0, ma a me nulla (ripeto, a parte J2).

Che ne dite?

----------

## randomaze

 *Detronizator wrote:*   

> Io proporrei una cosa: un Thread "da bloccare" con la raccolta delle USE-FLAGS più testate e sicure per ogni architettura. Esempio: alcune di queste FLAGS hanno dato problemi a N3m0, ma a me nulla (ripeto, a parte J2).

 

Le Safe Flags sono quì, IMHO il resto é tutta sperimentazione.

----------

## n3m0

 *Detronizator wrote:*   

> 
> 
> ```
> 
> -falign-functions -falign-labels -falign-loops -falign-jumps
> ...

 

Considerando che:

- quelle flags sono implicate gia' dal livello O2, usato molto comunemente

- molte distro sono compilate con O2 per march=i686

- O2 e' abbandontamente tra le Safe Flags

- le flag che entrano in un livello di "O" sono ben testate dagli sviluppatori di gcc

ne segue che vanno tranquillamente tenute, IMHO.

----------

## n3m0

 *randomaze wrote:*   

> 
> 
> Le Safe Flags sono quì, IMHO il resto é tutta sperimentazione.

 

Questo e' vero.

Ma e' bello sperimentare  :Smile: 

----------

## Detronizator

 *n3m0 wrote:*   

> 
> 
> Considerando che:
> 
> - quelle flags sono implicate gia' dal livello O2, usato molto comunemente
> ...

 

Ne sei certo?

----------

## n3m0

 *randomaze wrote:*   

> Hai provato anche a dilettarti con alcovea?

 

Sto leggendo i vari test, il funzionamento, l'algoritmo...

Interessante...

Ma se metto -march=athlon-xp nei Makefile dei sorgenti, e poi eseguo il test P4, secondo te e' affidabile?

Nello script del test (guardato di fretta) non vedo nulla di particolare...

Torno al mio dovere  :Smile: 

Ciao

----------

## n3m0

 *Detronizator wrote:*   

>  *n3m0 wrote:*   
> 
> Considerando che:
> 
> - quelle flags sono implicate gia' dal livello O2, usato molto comunemente
> ...

 

man gcc

----------

## Detronizator

 *n3m0 wrote:*   

>  *Detronizator wrote:*    *n3m0 wrote:*   
> 
> Considerando che:
> 
> - quelle flags sono implicate gia' dal livello O2, usato molto comunemente
> ...

 

Ok, mi fido!  :Wink: 

ps Stai ancora impazzendo con il Progetto di Linguaggi 2 o per Statistica?

----------

## blackfede

Mi intrometto in questa dicussione in modo semi-OT.

Ho letto a proposito dei compilatori Intel (ottimizzazione, compatibilità -decente- con gcc, ecc), e mi chiedevo se avesse senso (sia a livello di "ottimizzazione" che proprio il fatto di per se, cioè scaricare il gcc a favore del compilatore Intel) usarlo per compilare tutta la Gentoo. Mi pare che per adesso ci sia una buona compatibiltà, ma non vorei che però gli ebuild contenessero flags che nell'Intel non sono ancora supportate...

In sostanza se qualcuno ha provato, vorrei sapere la sua opinione, altimenti mi offro pioniere di questa sperimentazione!  :Cool: 

----------

## cerri

Guarda qui https://forums.gentoo.org/viewtopic.php?t=115644 e ancora meglio qui https://bugs.gentoo.org/show_bug.cgi?id=41750.

Se cerchi icc nel forum ti viene fuori un sacco di roba interessante  :Very Happy: 

----------

## blackfede

Io ho cercato, ma ho usato Intel Compiler come chiave di ricerca, l'unico post che era "pertinente" (titolo: intel C++ Compiler) era in russo!!!  :Confused: 

Cmq grazie per la dritta, ora leggo e ricerco con ICC!

EDIT: Nel secnodo link c'è finito in mezzo anche il punto di chiusura frase che invalida quindi tutto l'indirizzo!  :Very Happy: 

----------

## xdarma

ma nessuno usa -s o -Os?

*apparentemente* nel mio pc crea binari piccoli ma non stabilissimi

xdarma

----------

## Sparker

ho compilato qualcosa con -Os senza problemi, ma non un intero sisteama. In una vecchia newsletter c'era un link ad una discussione su -O3 Vs. -O2 dove parlavano anche di -Os

----------

## t0mcat

verso fine pagina 27 del thread CFLAGS Central è spiegato piuttosto chiaramente che -falign-functions è + o - ininfluente.

inoltre è vivamente consigliato l'uso della fpu 387 e non sse per gli athlon. ( -mfpmath=387 ).

ho installato gentoo con le safe flag, e ora che mi sto documentando mi appresto a fare un emerge -e world con le seguenti flag (athlon-xp 2500@3200):

CFLAGS="-march=athlon-xp -O3 -pipe -fomit-frame-pointer -ffast-math -fmove-all-movables -funroll-loops -fprefetch-loop-arrays -fforce-addr -mmmx -msse -m3dnow -mfpmath=387 -frename-registers -maccumulate-outgoing-args"

alcune mi pare siano ridondanti, ma non si sa mai...  :Razz: 

----------

## n3m0

 *t0mcat wrote:*   

> verso fine pagina 27 del thread CFLAGS Central è spiegato piuttosto chiaramente che -falign-functions è + o - ininfluente.
> 
> 

 

Ho letto semplicemente che e' inutile discutere, poiche' a quanto pare, secondo alcuni, e' inutile specificare un n > 32, in quanto e' il default per tutte le CPU (infatti -falign-functions e' incluso in -O2 senza specificare n, che comporta l'utilizzo dei valori di default).

Quello che mi rende ancora dubbioso per gli Athlon-XP e' che questo processore ha una cache line di 64-byte quindi l'allineamento a 64 byte delle funzioni e' giustificato (nonche' consigliato, da cio' che si puo' capire dall' "AMD Athlon Processor x86 Code Optimization Guide").

Inoltre il suddetto manuale sembra suggerire chiaramente con questo passaggio: 

"In program hot spots (as determined by either profiling or loop

nesting analysis), place branch targets at or near the beginning

of 16-by te aligned code windows. Th is guideline improve s

performance insi de hotspots by maximizing the nu mber of

instruction fills into the instruction-byte queue and preserves I-

cache space in branch-intensive code outside such hotspots."

che sarebbe l'ideale specificare -falign-jumps=16

Non so pero' se questo corrisponde al machine-dependent default.

 *t0mcat wrote:*   

> 
> 
> inoltre è vivamente consigliato l'uso della fpu 387 e non sse per gli athlon. ( -mfpmath=387 ).
> 
> 

 

Questo devo capirlo ancora bene.

Dovrebbe essere per il fatto che la sse si occupa solo di operazioni in singola precisione, giusto?

Attendo feedback.

 *t0mcat wrote:*   

> 
> 
> CFLAGS="-march=athlon-xp -O3 -pipe -fomit-frame-pointer -ffast-math -fmove-all-movables -funroll-loops -fprefetch-loop-arrays -fforce-addr -mmmx -msse -m3dnow -mfpmath=387 -frename-registers -maccumulate-outgoing-args"
> 
> alcune mi pare siano ridondanti, ma non si sa mai... 

 

Giusto se ti interessa, ecco quelle che dovrebbero essere le ridondanze: 

-mmmx -msse -m3dnow: sono implicate dall'architettura usata.

Puoi accertartene con: 

```

gcc QUALSIASI_FILE.C -Q -v -march=athlon-xp 2>&1 | sed -n -e "/optionsenabled/,/include/{s/ -/\n-/g;p}" | sed -n -e "/^-/{p}" | sort >flags.opt

```

Nel file flags.opt dovresti trovare anche le flag in questione.

-maccumulate-outgoing-args: implicata di default.

Puoi accertartene col test di prima eseguendolo addirittura senza -march: ti troverai, nel file flags.opt, un -march=i486 e il flag in questione attivo.

Ovviamente e' ancora attivo se come architettura specifichi la tua.

-frename-registers: implicato da -O3 (man gcc per conferma).

Hola.

----------

## t0mcat

ho ricompilato tutto con le suddette cflags ed è andato tutto liscio. alcuni pacchetti richiedono flags meno strette (come openoffice) ma il portage le setta automaticamente di conseguenza.

non ho notato particolari miglioramenti visibili di prestazioni, ma il sistema sembra averne tutto sommato guadagnato in stabilità.

consiglio le flags di cui sopra a chiunque abbia un athlon-xp barton.

per la storia di -mfpmath=387: non è questione di precisione (per quella c'è la flag -ffast-math che riduce i bit di precisione da 10 a 8 se non sbaglio, con un teorico incremento notevole di velocità), quanto di ottimizzazione: la fpu sse è adatta negli intel, non negli amd.

questo almeno è quanto ho capito leggendo.

----------

## xoen

 *cerri wrote:*   

> Per darti un'idea, le altre distro sono in genere compilate usando '-march=i686 -O2' (e spesso anche peggio).

 

Si ma le distro normali sono fatte per gente paccioccosa che se ne frega delle ottimizzazioni, e cmq non si ricompila il tutto.

----------

## n3m0

Ho ripescato questo mio vecchio post, per non aprire l'n-simo thread che parla di flag.

Non voglio continuare la discussione delle FLAG, solo chiedere un parere: 

su un PC con disco lento (in read) (come e' normalmente [a parte casi eccezionali e costosi] quello di un notebook, rispetto ai moderni dischi per home-PC), conviene, secondo voi, ottimizzare con -Os, per far si che il loading delle applicazioni sia piu' veloce? O si perde troppo in performance durante il running rispetto ad un -O2/3?

Confido nelle vostre esperienze per un buon consiglio...

----------

## shev

 *n3m0 wrote:*   

> conviene, secondo voi, ottimizzare con -Os, per far si che il loading delle applicazioni sia piu' veloce? O si perde troppo in performance durante il running rispetto ad un -O2/3?

 

Io uso -Os anche sui miei desktop oltre che sul pbook, sia su desktop con tanta ram che con poca, con dischi lenti o veloci. Avendo provato in passato anche -O3 e -O2 ti posso dire di usare tranquillamente -Os, in prestazioni pure imho non perdi nulla (o cmq nulla di percettibile).

----------

## solka

Acovea https://forums.gentoo.org/viewtopic.php?t=157108&postdays=0&postorder=asc&highlight=url&start=0

Ebuild https://bugs.gentoo.org/show_bug.cgi?id=39089

Un programma che, da quanto ho capito, testa le ottimizzazioni possibili e indica un punteggio per ogni stringa permettendo di trovare le CFLAGS migliori. I test durano un bel po'...in quei due link trovate tutto.

----------

## n3m0

 *Shev wrote:*   

> 
> 
> Io uso -Os anche sui miei desktop oltre che sul pbook, sia su desktop con tanta ram che con poca, con dischi lenti o veloci. Avendo provato in passato anche -O3 e -O2 ti posso dire di usare tranquillamente -Os, in prestazioni pure imho non perdi nulla (o cmq nulla di percettibile).

 

Grazie mille...

Solo un'altra domanda...

Riesci a dirmi, sempre che tu abbia potuto fare questi confronti, se percettibile, invece, e' la diminuzione del tempo di loading quando passo da un O3 ad un Os?

Grazie ancora per la pazienza  :Wink: 

----------

## shev

 *n3m0 wrote:*   

> Riesci a dirmi, sempre che tu abbia potuto fare questi confronti, se percettibile, invece, e' la diminuzione del tempo di loading quando passo da un O3 ad un Os?

 

Sinceramente non mi sento di dirti nulla per il semplice fatto che non ho dati concreti sotto mano, quindi dovrei limitarmi alle mie impressioni, soggettive quindi pocco attendibili.

Se proprio ti accontenti, io uso -Os perchè mi sembra di avere un sistema più reattivo e snello rispetto all'O3 precedente, però è un'impressione non verificata dai fatti, quindi prendila come tale.

Se ti serve che faccia qualche test dimmi pure che fare  :Smile: 

----------

## n3m0

Grazie mille, le tue impressioni sono gia' qualcosa...

Per il resto, provvedero' io a fare dei test approssimati con "time".

Se sono sulla stessa onda delle tue impressioni, credo che faro' provero' questo cambiamento...

----------

## cloc3

Credo che il titolo di questo topic possa applicarsi benissimo alle MIE cflags ... Quindi mi permetto di utlizzarlo, anche per riesumare il topic.

Possiedo un nuovo laptop con queste caratteristiche:

```

cloc3@gentoo-amd ~ $ cat /proc/cpuinfo

processor       : 0

vendor_id       : AuthenticAMD

cpu family      : 15

model           : 4

model name      : AMD Athlon(tm) 64 Processor 3400+

stepping        : 10

cpu MHz         : 2201.856

cache size      : 1024 KB

fdiv_bug        : no

hlt_bug         : no

f00f_bug        : no

coma_bug        : no

fpu             : yes

fpu_exception   : yes

cpuid level     : 1

wp              : yes

flags           : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush mmx fxsr sse sse2 syscall nx mmxext lm 3dnowext 3dnow

bogomips        : 4358.14

```

Attualmente la macchina lavora egregiamente con un sistema operativo copiato di sana pianta da un altro laptop e compilato in questo modo:

```

cloc3@gentoo-amd ~ $ cat /etc/make.conf

CFLAGS="-O3 -march=pentium4 -pipe -fomit-frame-pointer -fPIC"

CHOST="i686-pc-linux-gnu"

CXXFLAGS="${CFLAGS}"

...

```

Adesso vorrei installare un sistema operativo originale in una partizione separata. Per il momento, desidero compilare un sistema a 32 bit, non a 64, ma ottimizzato per la mia cpu. Leggendo il link sulle safe cflags, non sono riuscito a trovare indicazioni per un amd k8. Non so neppure se quelle impostazioni siano ancora valide per i gcc-3.4.x.

Mi piacerebbe anche interessarmi al problema dell'ottimizzazione delle cflags. Ho provato a consultare timidamente il manuale di gcc, ma mi è parso piuttosto complesso per le mie conoscenze. Mi sapreste dare delle indicazioni per un modo efficiente di studiare il problema? Sarei disposto a farci un po' di fatica sopra, a patto di riuscire a impostare un percorso di studio credibile.

----------

## randomaze

 *cloc3 wrote:*   

> model name      : AMD Athlon(tm) 64 Processor 3400+
> 
> ...
> 
> CFLAGS="-O3 -march=pentium4 -pipe -fomit-frame-pointer -fPIC"
> ...

 

L'archittettura P4 con le varie estensioni di intel (sse1&2 e simili) non da problemi con l'AMD64?

----------

## cloc3

 *randomaze wrote:*   

>  *cloc3 wrote:*   model name      : AMD Athlon(tm) 64 Processor 3400+
> 
> ...
> 
> CFLAGS="-O3 -march=pentium4 -pipe -fomit-frame-pointer -fPIC"
> ...

 

A rigore di logica, dovrebbe darli, ma sperimentalmente, il mio computer funziona.

Il mio problema è proprio questo: se voglio fare una installazione corretta a 32 bit, come dovrei impostare le cflags?

e da dove conviene incominciare per studiare la scelta delle ottimizzazioni?

----------

## randomaze

 *cloc3 wrote:*   

> Il mio problema è proprio questo: se voglio fare una installazione corretta a 32 bit, come dovrei impostare le cflags?
> 
> 

 

Nel forum dedicato all'AMD64 non c'é niente?

----------

## lavish

Io ho settato le cflags sul mio athlon64 3200+ (hammer.. tu hai un newcastle se nn erro)

Solo che il mio sistema e' a 64 bit.. come mai tu lo stai facendo a 32? paura della nuova arch?  :Razz: 

Cmq se possono esserti d'aiuto ti posto le mie flags fra un paio d'ore, appena arrivo a casa. (non solo le cflags)

----------

## cloc3

 *lavish wrote:*   

>  come mai tu lo stai facendo a 32? paura della nuova arch? 
> 
> 

 

Forse anche paura, ma soprattutto voglia di provare tutte le possibilità. Inoltre sono nubbio, e capisco le cose di informatica solo fin dove mi porta l'intuizione. Quindi ho bisogno di sperimentare.

@randomaze: grazie per l'indirizzo nel settore AMD64. Da grande sciocco, avevo trascurato quel ramo di ricerca per insistere sulla chiave CFLAGS.

----------

## lavish

 *cloc3 wrote:*   

> Forse anche paura, ma soprattutto voglia di provare tutte le possibilità. Inoltre sono nubbio, e capisco le cose di informatica solo fin dove mi porta l'intuizione. Quindi ho bisogno di sperimentare.
> 
> 

 

Allora... per sperimentare sarebbe bello (e produttivo IMHO) andare a 64bit visto che hai preso una amd64 (altrimenti che l'hai presa a fare?  :Razz: )

Cmq questo e' parte del make.conf :

CFLAGS="-march=athlon64 -O2 -fweb -frename-registers -ftracer -pipe"

CHOST="x86_64-pc-linux-gnu"

CXXFLAGS="${CFLAGS}"

LDFLAGS="-Wl,-O1"

MAKEOPTS="-j3"

ACCEPT_KEYWORDS="~amd64"

- Il march=athlon64 e' introdotto nel gcc dalla serie 3.4.* e si puo' usare anche a 32bit

- LDFLAGS ho notato che nn creano problemi di compilazione e/o stabilita' e rendono l'esecuzione dei programmi piu' veloce per dirla in modo semplice

- MAKEOPTS="-j3" .. questo puo' sembrare strano perche' in teoria dovrebbe essere posta  a 2 ( -j2) che corrisponde al num delle cpu +1; invece ho notato che la compilazione e' un po' piu' veloce con j3 in OGNI caso. Non ci sono comunque problemi di nessun tipo a settarla a j3, magari fai delle prove con genloop -t per vedere i tempi di compilazione.

Riguardo alle altre cflgs, posso dirti che queste sono ideali per il mio sistema, non so quanto bene possano andare su un sistema compilato a 32bit...

Il mio consiglio cmq (se non hai scheda ATI) e' quello di andare a 64bit  :Very Happy:   :Very Happy: 

Ciao!

<EDIT> Dimenticavo... -Os non si puo' mettere su amd64. Oltre che essere controproduttivo IMHO metterlo su questa cpu, "rompe" il sistema (from technotes)

Altra cosa... tutti queli che hanno provato 03 (che comprende varei ottimizzazioni fra le quali alcune delle mie) sono tornati a 02 avendo notato problemi di compilazione e 0 aumento prestazionle... si parla sempre di sistemi a 64 pero'.... dai dai rinnovo l'invito di passare a 64 ghgh   :Cool: 

----------

## lavish

 *randomaze wrote:*   

> L'archittettura P4 con le varie estensioni di intel (sse1&2 e simili) non da problemi con l'AMD64?

 

Bhe' non dovrebbe infatti dare problemi visto che le estensioni sono + o - quelle.. 

```
flags           : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush mmx fxsr sse sse2 syscall nx mmxext lm 3dnowext 3dnow
```

Come vedi per esempio sse e sse2 sono contemplate nell'athlon64 ed e' proprio per la flag sse2 che certi settano il march con p4 invece invece che con athlon-xp.

Effettivamente ho notato che cmq per compilarsi un ambiente a 32bit da utilizzare via chroot e bind per certe applicazioni in molti usano semplicemente i686

Ciao!

----------

## Taglia

 *quantumwire wrote:*   

> 
> 
> http://gcc.gnu.org/onlinedocs/gcc-3.3.2/gcc/Option-Index.html#Option%20Index
> 
> relativo alla versione 3.3.2 del gcc.

 

Giusto per inciso, se modificate la parte gcc-x.x.x del link, avrete il manuale della versione che usate   :Laughing: 

----------

## cloc3

 *lavish wrote:*   

> 
> 
> Allora... per sperimentare sarebbe bello (e produttivo IMHO) andare a 64bit visto che hai preso una amd64 (altrimenti che l'hai presa a fare? )
> 
> ...
> ...

 

Chi ha detto di non voler andare a 64. Voglio sperimentare: chello e chello.

Tra l'altro, prima di andare a 64, devo convincere il CD a caricare anche la tastiera... In chroot, il mio sistema a 32 non mi lascia entrare.

Scopiazzando sul forums amd, ho deciso di provare questa ricetta:

```

CFLAGS="-march=athlon-xp -O2 -pipe -fomit-frame-pointer -msse2 -ftracer -maccumulate-outgoing-args"

CHOST="i686-pc-linux-gnu"

CXXFLAGS="${CFLAGS}"

ACCEPT_KEYWORDS="~x86"

MAKEOPTS="-j2 -s"

```

Contiene errori letali?

Tra l'altro, cos'è quell'opzione LDFLAGS="-Wl,-O1" . Non l'avevo mai vista prima.

----------

## Sasdo

 *cloc3 wrote:*   

> 
> 
> Tra l'altro, cos'è quell'opzione LDFLAGS="-Wl,-O1" . Non l'avevo mai vista prima.

 

infatti credo sia stata inserita in una recente versione del portage...

----------

## lavish

Allora... le LDFLAGS funzionano + o - come funziona il prelink.. cioè sono delle ottimizzazioni per l' LD (Dynamic Loader) e tendono quindi ad incrementare la velocità d'esecuzione delle applicazioni.

Maggiori approfondimenti li puoi trovare... qui:

https://forums.gentoo.org/viewtopic.php?t=67777

https://forums.gentoo.org/viewtopic.php?t=226909

Come vedi io ho usato ottimizzazioni sulle LDFLAGS non troppo spinte, ma molto stabili sulla mia box  :Wink: 

CYA

----------

## Cazzantonio

Ho iniziato anche io ad usare le ldflags come suggeritomi da lavish al g-day, sia sul fisso che sul portatile... e mi sembra che le applicazioni che ho compilato con LDFLAGS=" -Wl, -O1" siano un po' più veloci... qualcosa fanno queste ldflags... anche con ottimizzazioni così blande   :Wink: 

Ottimo tip lavish!   :Very Happy: 

perchè non creare un topic a parte dove introdurre a tutti la novità delle LDFLAGS? qualcuno rischia di perdersele in un topic dal titolo così generico...

----------

## gutter

@Cazzantonio: apri questo topic   :Wink:   e magari posti anche qualche bench di applicazioni compilate in entrambi i modi  :Smile: 

----------

## n3m0

[OT]

Wow. Uno dei miei primi post, nonchè uno dei pochi topic che ho aperto qui!  :Very Happy: 

[/OT]

----------

## Cazzantonio

 *gutter wrote:*   

> @Cazzantonio: apri questo topic    e magari posti anche qualche bench di applicazioni compilate in entrambi i modi 

 

magari è meglio che lo faccia lavish, visto che se ne intende di più... io al massimo posso postare gli stessi link che ha messo lui nei post precedenti...   :Smile: 

Il mio consiglio era solo di splittare la discussione visto che questo è un post sulle cflags mentre lavish aveva introdotto una discussione su qualcosa di nuovo come le ldflags...   :Wink: 

----------

## gutter

@Cazzantonio: che lo scriva lavish per me va benissimo   :Wink:   Ero solo curioso di vedere che aumenti di performance riuscivate ad ottenere e per saperne un poco di più.   :Very Happy: 

Buon lavoro   :Wink: 

@n3m0: Sei un sentimentalista, non lo immaginavo   :Wink: 

----------

## lopio

 *lavish wrote:*   

> 
> 
> CFLAGS="-march=athlon64 -O2 -fweb -frename-registers -ftracer -pipe"
> 
> CHOST="x86_64-pc-linux-gnu"
> ...

 

ciao lavish ho provato a seguire i tuoi preziosi consigli.

Sembra che il parametro -fweb dia fastidio.

Ecco un esempio di errore di  pacchetto getext 

```

emerge getext

checking for C compiler default output file name... configure: error: C compiler cannot create executables

See `config.log' for more details.

configure: error: /bin/sh './configure' failed for autoconf-lib-link

!!! ERROR: sys-devel/gettext-0.14.1 failed.

!!! Function econf, Line 449, Exitcode 1

!!! econf failed

!!! If you need support, post the topmost build error, NOT this status message.

```

un altro pacchetto ed-0.2-r4

```

cc1: error: unrecognized option `-fweb'

make: *** [glbl.o] Error 1

make: *** Waiting for unfinished jobs....

config.h is unchanged

touch stamp-h

make: *** Waiting for unfinished jobs....

!!! ERROR: sys-apps/ed-0.2-r4 failed.

!!! Function src_compile, Line 33, Exitcode 2

!!! (no error message)

!!! If you need support, post the topmost build error, NOT this status message.

```

Sai dirmi come mai?

grazie infinite

----------

## Cazzantonio

 *gutter wrote:*   

> @Cazzantonio: che lo scriva lavish per me va benissimo    Ero solo curioso di vedere che aumenti di performance riuscivate ad ottenere e per saperne un poco di più.   

 

Di preciso non lo so... ma mi sembrano sensibili su applicazioni pese (ovviamente su applicazioni leggere non noto la differenza

Non ho mai fatto questi tipi di benchmark e non saprei da dove iniziare   :Rolling Eyes:  di solito vado "a sensazione" sia per valutare la stabilità che la velocità relativa di un'applicazione...   :Very Happy:   se non mi accorgo di nessun cambaimento significa che l'ottimizzazione era di poco conto    :Smile: 

----------

## lavish

Scusate avevo perso di vista questo topic   :Embarassed: 

Ora sono fuori casa e di fretta...appena ho due minuti vedo quel che riesco a fare  :Wink: 

Saludos!

----------

## gutter

 *Cazzantonio wrote:*   

> 
> 
> [CUT]
> 
> Non ho mai fatto questi tipi di benchmark e non saprei da dove iniziare   di solito vado "a sensazione" sia per valutare la stabilità che la velocità relativa di un'applicazione...    se non mi accorgo di nessun cambaimento significa che l'ottimizzazione era di poco conto   

 

Confido nei tuoi riflessi   :Wink:   ma in genere per queste cose preferisco un bench    :Wink:   Aspetteremo lavish   :Very Happy: 

----------

## lavish

Quotiamo con umanita -fedeliallalinea

 *lopio wrote:*   

> ciao lavish ho provato a seguire i tuoi preziosi consigli.
> 
> Sembra che il parametro -fweb dia fastidio.
> 
> Ecco un esempio di errore di  pacchetto getext 
> ...

 

Togliendo la flag -fweb compila? Non sembra un problema legato a quella cosi' al primo impatto...

----------

## lavish

@ lopio:

-fweb deriva dalle ottimizzazioni di 03.. quarda qui:

 *Quote:*   

> 
> 
> -O2
> 
>     Optimize even more. GCC performs nearly all supported optimizations that do not involve a space-speed tradeoff. The compiler does not perform loop unrolling or function inlining when you specify -O2. As compared to -O, this option increases both compilation time and the performance of the generated code.
> ...

 

E fa questo:

```

-fweb

    Constructs webs as commonly used for register allocation purposes and assign each web individual pseudo register. This allows the register allocation pass to operate on pseudos directly, but also strengthens several other optimization passes, such as CSE, loop optimizer and trivial dead code remover. It can, however, make debugging impossible, since variables will no longer stay in a home register.

    Enabled at levels -O2, -O3, -Os, on targets where the default format for debugging information supports variable tracking. 
```

Praticamente non dovrebbe creare errori in compilazione, quanto darne durante il debug.. visto che non e' nelle mie attuali possibilita' dedicarmi a quest'ultimo ho ritenuto appropriato abilitarla  :Wink: 

Spero che la lettura di questo post possa essere abbastanza interessante  :Smile:  A volte non si sa nemmeno cosa 02 e 03 realmente comportano a livello di ottimizzazione

Riguardo ai bench... ma li volete per amd64 vero?

----------

## Cazzantonio

 *gutter wrote:*   

> Confido nei tuoi riflessi    ma in genere per queste cose preferisco un bench     Aspetteremo lavish  

 

Sono curioso anche io   :Wink: 

----------

## lavish

Ops   :Embarassed:   ho riletto tutto il topic di nuovo e avevo capito completamente un'altra cosa   :Shocked:   Stavo per postare benchamrk fatti con diverse CFLAGS su amd64 e invece volevate quelli per le LDFLAGS... accidenti... sono bruciato  :Rolling Eyes: 

Non ho nulla sottomano al momento vi prego di scusarmi... cmq se vi interessano ho 2 topics molto interessanti sull'argomento:

https://forums.gentoo.org/viewtopic.php?t=67777

https://forums.gentoo.org/viewtopic.php?t=226909

CiaO!

----------

## kandalf

come posso impostare le flags per un amd64?

grazie

----------

## earcar

Ecco le mie:

```
CFLAGS="-march=athlon64 -Os -pipe"

LDFLAGS="-Wl,--as-needed"
```

```
USE="multilib nptl hal -arts -directfb encode -oss X aac aalib acpi alsa avi bash-completion caps cdr crypt cups dga divx4linux dvd emul-linux-x86 foomaticdb gnome gtk2 icq jabber jack joystick mad mmx mp3 mpeg msn ogg oggvorbis opengl png posix python quicktime readline scanner sse svg tiff usb truetype wxwindows xine xvid yahoo"

```

Poi ovviamente le setti in base all'utilizzo che vuoi fare con la tua macchina  :Wink: 

Ciauz

earcar  :Wink: 

----------

## lavish

che domanda è?  ..........................

non sappiamo che sistema è, che servizi ci gireranno, l'uso che ne farai, che ottimizzazioni vuoi.... se ne è parlato mille volte inoltre sui settings per amd64, quindi mi sembra abbastanza allucinante come post (to be honest)

<EDIT> apprezzo la tranquillità di earcar  :Surprised: 

----------

## kandalf

grazie earcar!

----------

## .:chrome:.

 *earcar wrote:*   

> Ecco le mie:
> 
> ```
> CFLAGS="-march=athlon64 -Os -pipe"
> 
> ...

 

ci sono state un paio di discussioni a riguardo, e non in pochi (me compreso) avevano espresso parecchi dubbi circa l'utilità di impostare tutte quelle use flags. la cosa migliore sarebbe impostare CFLAGS e poche (e sottolineo poche) USE flag globali, per poi mettere quelle specifiche di ogni pacchetto in /etc/portage/package.use

----------

## jp10hp

cosa sono le LDFLAGS  :Question:   :Question:   :Question: 

----------

## .:chrome:.

 *jp10hp wrote:*   

> cosa sono le LDFLAGS   

 

citando la guida di configurazione del kernel... "se non sai cosa è, non ti serve"  :Very Happy: 

scherzo  :Smile:  sono le opzioni che passi al linker (ld, appunto)

----------

## jp10hp

eheh ma la parola d'ordine con gentoo è ottimizzare qualsiasi cosa anche se nn sai cos'è!  :Laughing: 

...seriamente impattano sulle prestazioni del sistema o solo sulla compilazione?

----------

## .:chrome:.

 *jp10hp wrote:*   

> eheh ma la parola d'ordine con gentoo è ottimizzare qualsiasi cosa anche se nn sai cos'è! 
> 
> ...seriamente impattano sulle prestazioni del sistema o solo sulla compilazione?

 

io l'ho provata. a conti fatti non mi sembra che porti questi gran vantaggi perché guadagni da una parte e perdi dall'altra.

guarda questo thread: https://forums.gentoo.org/viewtopic-t-318552.html e soprattutto questo: https://forums.gentoo.org/viewtopic-t-321020.html che documenta un bug abbastanza grave di quell'opzione

----------

## old_al

Ciao a tutti,

sulla base delle vostre esperienze con quali CFLAGS è meglio compilare per un AMD 64 X2?

Grazie Alberto

----------

## X-Drum

https://forums.gentoo.org/viewtopic-t-323422-highlight-flags+amd64.html

https://forums.gentoo.org/viewtopic-t-221361.html

https://forums.gentoo.org/viewtopic-t-319749-highlight-cflags.html

usa i "defaults" .

```
CFLAGS="-march=k8 -O2 -pipe"
```

----------

## Cazzantonio

Fatto il merge dei thread... guardiamo di cercare prima di postare   :Wink: 

----------

## unarana

io uso quelle consigliate da amd per la compilazione con gcc, anche se sinceramente sono un po spinte e non le userei mai in produzione

```
CFLAGS="-O3 -march=athlon64 -ffast-math -funroll-all-loops -funit-at-a-time -fpeel-loops -ftracer -funswitch-loops -fomit-frame-pointer -pipe"

CHOST="x86_64-pc-linux-gnu"

CXXFLAGS="${CFLAGS}"

LDFLAGS="-Wl,-O1"

MAKEOPTS="-j3"
```

Ciao  :Mr. Green: 

----------

## unarana

dimenticavo il link, sorry

https://forums.gentoo.org/viewtopic-t-257417-highlight-amd64+cflags.html

Ciao  :Mr. Green: 

----------

## nihil39

Io ho un P4 3 Ghz su un portatile, potete consigliarmi le flag da usare in make.conf? Almeno quelle più comunemente usate.

 Per le USE flag vorrei impostarne poche  globali e poi inserire quelle specifiche per i singoli programmi  in /etc/portage/package.use 

Grazie in anticipo.

----------

## lavish

[MOD]

Fatto il merge del thread aperto da kandalf in questo poichè era diventato l'ennesima dscussione sulle CFLAGS

[/MOD]

nihil39, hai postato due domande che sono state già fatte mille volte, cerca sul forum per favore prima di postare

----------

## -YoShi-

Ciao a TÜc  :Smile: 

Mi accodo per un consiglio.

Dovendo compilare dei pacchetti "Generic x86" in modo da crearmi una GRP universale e aggiornata che CFLAGS posso usare?

Nn qualcosa di eccezionalmente spinto, ma comunque qualcosa di performante.

E' sufficiente un un "-mark=i686 -O3" o ci si può fare un po' di tuning? Che consigliate?

per ricompilare tutti i pacchetti presenti nel mio "world & system" per renderli GRP ready è suff un:

```

# emerge -DeBv system && emerge -DeBv && mkdir /temp && cp /etc/make.conf /temp && cp /usr/portage /temp && tar -cjpf  /temp

```

? o ci devo mettere qualche stringa in più?

----------

## Luca89

Ti basta impostare tra le features "buildpkg" e dare un "emerge -e world", poi se vuoi i pacchetti in una specifica directory imposti PKGDIR, per le CFLAGS se i pacchetti devono essere utilizzati solo su sistemi i686 credo che un "-Os -march=i686 -fomit-frame-point -pipe" sia la soluzione migliore.

----------

## -YoShi-

Si ma se faccio così ricompilo anche tutto il mio sistema  :Smile:  io volevo solo dare in pasto i pacchetti alla mia cpu senza ritoccare il mio pinguinetto  :Smile: 

----------

## AnT-87

ciao a tutti, ho un pentium cleron 434 mHz, cosa devo scrivere nelle CFLAGS e nel CHOST del make.conf? ho dato un occhiata nel make.conf.example, ma ho trovato solo riferimenti a pentium 4 o athlon-xp 64...

grazie anticipatamente per l'aiuto

----------

## MeMyselfAndI

Per queste domande "normali" basterebbe fare una ricerca sul forum.....

http://gentoo-wiki.com/Safe_Cflags

----------

## Cazzantonio

fatto il merge del topic...

cavolo c'era un topic uguale nella stessa pagina... non dico cercare... basta guardare a volte...

----------

## light108

volevo sapere quali sono le migliori flag da inserire in /etc/make.conf per un processore AMD64

----------

## X-Drum

questa discussione è stata affrontata parecchie volte sul forum

go search()   :Wink: 

----------

## =DvD=

http://www.gentoo.org/doc/en/gentoo-amd64-faq.xml#cflags

è una faq del sito principale, pure  :Smile: 

( http://gentoo-wiki.com/Safe_Cflags )

----------

## gutter

Fatto il merge del topic di light108

Per favore cerchiamo prima di postare.

----------

## Occasus

ho un celeron 2000 con 256mb di ram e dopo una prima installazione con le flags completamente sbagliate:

-O3 -pipe -fomit-frame-pointer

e una mediocre -O2,

attualmente uso la -Os.

le prestazioni sono più che discrete, però il problema grande è che il sistema si inceppa quando eseguo compilazioni e contemporaneamente uso firefox e gaim.

leggendo una dozzina di threads, mi sono segnato queste flags:

CFLAGS="-march=pentium4 -Os -pipe -fomit-frame-pointer -fstack-protector-all -fno-ident -fforce-addr -ftracer -fweb -falign-functions=4 -ffast-math -falign-jump=4"

CXXFLAGS="${CFLAGS} -fvisibility-inlines-hidden"

LDFLAGS="-Wl, -O1 -Wl, --sort-common -s" (e poco probabilmente --as-needed, disattivato in caso di pacchetti problematici)

cosa ne pensate di questo minestrone? tento uno stage1 con queste flags, oppure verrà una schifezza?

a me interessa soprattutto che il sistema non vada a scatti quando sono aperti diversi programmi insieme

----------

## Ic3M4n

mi sembra una cavolata... poi logicamente le cose sono personali ed ognuno con il proprio pc ci fa quello che vuole.

in ogni caso come ribadito più volte non sempre l'ottimizzazione migliora le performance, anzi in molti casi le può addirittura peggiorare.

un solo consiglio che potrebbe essere anche la verità, cerca il problema della tua velocità durante la compilazione in qualcos'altro, tipo:

dma, kernel, /etc/hosts correttamente configurati.

----------

## Occasus

/dev/hda:

 IO_support   =  3 (32-bit w/sync)

 unmaskirq    =  1 (on)

 using_dma    =  1 (on)

 Timing cached reads:   1092 MB in  2.00 seconds = 544.88 MB/sec

 Timing buffered disk reads:  134 MB in  3.03 seconds =  44.19 MB/sec

occasus@aestas ~ $ cat /etc/hosts

127.0.0.1       localhost       aestas

non credo ci siano problemi...o sbaglio?

----------

## .:chrome:.

 *Occasus wrote:*   

> -fforce-addr -ftracer -fweb -falign-functions=4 -ffast-math -falign-jump=4

 

oltre a quanto già detto da Ic3M4n, cioé che potresti ottenere l'effetto contrario, esagerando con le ottimizzazioni (e mi pare sia il tuo caso) farei particolare attenzione a queste qui, anzi... io le eliminerei subito, senza pensarci nemmeno due volte.

danno buoni risultati una volta si e dieci no... in particolare rischi di creare codice davvero cattivo

io una volta buttavo via ore e ore a compilare e ricompilare. adesso ho queste flag:

```
CFLAGS="-march=pentium4 -O2 -pipe -mmmx -msse -fomit-frame-pointer -funroll-loops"
```

ed è il sistema più veloce che abbia mai avuto. questo la dice lunga  :Wink: 

viva la semplicità!!!

----------

## Occasus

mi sono riletto meglio il manuale di gcc e ho optato per:

```
SAFE_CFLAGS="-march=pentium4 -Os -pipe -fomit-frame-pointer"

CFLAGS="${SAFE_CFLAGS} -mmmx -msse -msse2 -fstack-protector-all -fno-ident -ftracer -ffast-math"

CXXFLAGS="${CFLAGS} -fvisibility-inlines-hidden"

LDFLAGS="-Wl, -O1 -Wl, --sort-common -s"
```

.

tento...se va male mi ricompilo un sistema estremamente minimale da stage1 con flags sicure ed effettuo un backup incrementale...

----------

## Cazzantonio

```
fstack-protector-all
```

?

Non la conoscevo ma ad occhio e croce il suo funzionamento sembra molto interessante... nessuna controindicazione?   :Rolling Eyes: 

P.S.

se hai specificato march i vari mmmx msse etc... sono ridondanti

----------

## .:chrome:.

 *Cazzantonio wrote:*   

> 
> 
> ```
> fstack-protector-all
> ```
> ...

 

ce ne sono un'infinità

il problema è che quella flag viene CORRETTAMENTE impiegata nei profili hardened, in congiunzione con le flag hardened, pie, e ssp (soprattutto con ssp). usarla al di fuori di questi contesti porta ad un'altissima probabilità di generare codice instabile, causa continui overflow dello stack e soprattutto dello heap.

lo stesso discorso vale per -ffast-math. prova a mandare un bug report e dire che stai usando -ffast-math: se sei fortunato vieni impalato.

suggerirei di usare qualcosa di molto più conservativo

----------

## Occasus

 *k.gothmog wrote:*   

> il problema è che quella flag viene CORRETTAMENTE impiegata nei profili hardened.
> 
> lo stesso discorso vale per -ffast-math. prova a mandare un bug report e dire che stai usando -ffast-math: se sei fortunato vieni impalato.
> 
> suggerirei di usare qualcosa di molto più conservativo

 

ho capito...quindi tolgo altre due flags dalla lista  :Smile: 

ma le flags possono effettivamente influire positivamente sulla gestione delle allocazioni di risorse per ogni programma?

a me interessano soprattutto la bassa latenza e il non bloccaggio sotto carico...

----------

## .:chrome:.

 *Occasus wrote:*   

> ma le flags possono effettivamente influire positivamente sulla gestione delle allocazioni di risorse per ogni programma?
> 
> a me interessano soprattutto la bassa latenza e il non bloccaggio sotto carico...

 

cosa intendi di preciso per "allocazioni di risorse per ogni programma"?

posso dirti che usando dimensioni di pagine di 4 kB, invece che di 8 kB si ha un migliore fruttamento della memoria, con minor segmentazione, ecc... a fronte però di un maggior overhead di gestione da parte dei vari controller (e del processore in primis), ma non so se è questo che intendevi tu...

per il fatto della bassa latenza, non è una cosa che puoi gestire a livello di applicazione, ma dovresti lavorare a livello kernel. la prima la otterresti con un kernel RT (o che si avvicini ad un RT, come caratteristiche), ma seconda con una buona scelta delle politiche di scheduling di processo e di I/O, nonché ovviamente con una buona dotazione di RAM

----------

## Occasus

per allocazioni ecc. intendo una gestione intelligente di ram e cicli di clock.

ad esempio, mi piacerebbe che il sistema ponga un limite ad applicazioni esigenti molte risorse, a vantaggio della fluidità generale.

esempio pratico: imposizione di un limite a gcc, mentre sono avviati processi (gnome, firefox, gaim, bittorrent ed altri)

ora, quando avvio gcc (o più spesso il trasferimento dei file dalla sandbox ai percorsi di installazione) il sistema si blocca al 99,5%, costringendomi ad un riavvio manuale del pc (si muove solo la freccia a scatti).

in altre parole, intendo una specie di qos per gestire ram, cpu e banda di accesso all'hd.

credo comunque di essermi espresso male...

----------

## Ic3M4n

bene... effettivamente nè il dma nè il file hosts possono essere il problema, però tipongo un quesito:

io con un pentium3 a 450MHz con 512M di ram come posso eseguire gli aggiornamenti e nel contempo utilizzare OOo, rhythmbox e l'ambiente intero di gnome senza subire problemi^ logicamente tutte le applicazioni vanno più lente, il processore e la frequenza delle ram è quella che è, non ci si può fare molto, però è comunque un caso di studio che può mettersi in contrapposizione con il tuo.

```
CFLAGS="-Os -march=pentium3 -pipe -fomit-frame-pointer"
```

io compilo con queste e mi trivo bene così.

per il tuo problema: la partizione di swap è sufficientemente grande da poter contenere i dati che per forza di cose devono swappare? calcola che 256 Mb non sono poi molti, se esegui più programmi vai inesorabilmente ad esaurirli abbastanza velocemente.

prova a controllare nel kernel, soprattutto lo scheduling ed il Timer frequency. la voce consigliara per i Desktop è 1000, le altre sono per i server.

----------

## Occasus

io ora ho 128MB si swap. devo usarne ~2(ram)MB, quindi ~512MB giusto?  :Rolling Eyes: 

inoltre il timer è impostato a 250...forse quello è un altro problema. magari metto i ck-sources e faccio prima  :Very Happy: 

rigurado lo scheduling, non trovo nulla

----------

## .:chrome:.

 *Occasus wrote:*   

> ...

 

queste richieste sono più che ragionevoli, ma non sono implementabili in questo modo. dipendono per la maggior parte dal codice che stai compilando, nel senso che un programma ben scritto fa già da solo queste cose; uno scrittomale non le fa e non c'è modo di fargliele fare.

 *Quote:*   

> gestione intelligente di ram e cicli di clock.

 

come sopra

 *Quote:*   

> mi piacerebbe che il sistema ponga un limite ad applicazioni esigenti molte risorse, a vantaggio della fluidità generale.

 

questa è una cosa diversa. non dipende né dal kernel né dal programma, né dal compilatore.

puoi ottenere questo tramite le facility di sistema (vedi limits.conf che c'è in /etc)

 *Quote:*   

> imposizione di un limite a gcc, mentre sono avviati processi (gnome, firefox, gaim, bittorrent ed altri)
> 
> ora, quando avvio gcc (o più spesso il trasferimento dei file dalla sandbox ai percorsi di installazione) il sistema si blocca al 99,5%, costringendomi ad un riavvio manuale del pc (si muove solo la freccia a scatti).

 

questo lo puoi risolvere in modo indiretto, nel senso che il processore sarà sempre al 100%, ma puoi dare ad emerge una bassa priorità, in modo che non disturbi il normale utilizzo del PC.

guarda in man make.conf la sezione relativa alla voce portage niceness

 *Quote:*   

> in altre parole, intendo una specie di qos per gestire ram, cpu e banda di accesso all'hd.

 

questo è un altro discorso ancora... puoi scegliere, in fase di compilazione, diversi scheduler di processo. hai a disposizione anche tre scheduler I/O che puoi cambiare dinamicamente tramite il file system /sys

dovrebbe essere quello che fa al caso tuo

 *Quote:*   

> credo comunque di essermi espresso male...

 

ma no, dai... c'è chi ha fatto di peggio  :Wink: 

----------

## Occasus

 *k.gothmog wrote:*   

> questa è una cosa diversa. non dipende né dal kernel né dal programma, né dal compilatore.
> 
> puoi ottenere questo tramite le facility di sistema (vedi limits.conf che c'è in /etc)

 

da ciò che ho capito, dovrei assegnare i processi da controllare ad un user fittizio e impostargli delle limitazioni in /etc/limits . sbaglio?

 *Quote:*   

> 
> 
> questo lo puoi risolvere in modo indiretto, nel senso che il processore sarà sempre al 100%, ma puoi dare ad emerge una bassa priorità, in modo che non disturbi il normale utilizzo del PC.
> 
> guarda in man make.conf la sezione relativa alla voce portage niceness

 

interessante...meglio un valore 10-15 che 0 quando uso altre applicazioni in contemporanea  :Very Happy: 

 *Quote:*   

> questo è un altro discorso ancora... puoi scegliere, in fase di compilazione, diversi scheduler di processo. hai a disposizione anche tre scheduler I/O che puoi cambiare dinamicamente tramite il file system /sys
> 
> dovrebbe essere quello che fa al caso tuo

 

non ho capito  :Embarassed:  c'è della documentazione a riguardo?

p.s. esistono dei comandi per liberare spazio inutilizzato della swap e/o della ram?

----------

## .:chrome:.

 *Occasus wrote:*   

> da ciò che ho capito, dovrei assegnare i processi da controllare ad un user fittizio e impostargli delle limitazioni in /etc/limits . sbaglio?

 

più o meno. considera che molti server (e sono quelli, che possono dare fastidio) girano con il loro utente

 *Occasus wrote:*   

> interessante...meglio un valore 10-15 che 0 quando uso altre applicazioni in contemporanea 

 

io metto sempre a 10

 *Occasus wrote:*   

> non ho capito  c'è della documentazione a riguardo?

 

guarda tra la documentazione del kernel nella sezione relativa agli scheduler I/O

 *Occasus wrote:*   

> p.s. esistono dei comandi per liberare spazio inutilizzato della swap e/o della ram?

 

di questo non te ne devi assolutamente preoccupare tu. il kernel esiste per questo

----------

## makami

 *k.gothmog wrote:*   

>  *Occasus wrote:*   p.s. esistono dei comandi per liberare spazio inutilizzato della swap e/o della ram? 
> 
> di questo non te ne devi assolutamente preoccupare tu. il kernel esiste per questo

 

Non so se può interessarti ma puoi dire al kernel in che modo gestire la ram e il file di swap

Nel file 

```
/etc/sysctl.conf
```

puoi impostare la variabile 

```
vm.swappiness
```

Mi pare che di default sia 60, io l'ho impostata a 30

Più il valore è vicino a zero più il kernel libererà ram per poterci scrivere nuovi dati, più il valore è vicino a 100 più il kernel tenderà a scrivere nella swap.

----------

## Occasus

quello l'avevo già letto nel tutorial "come fare volare gentoo". io imposterò il valore a 20.

grazie comunque  :Smile: 

----------

## .:chrome:.

 *Occasus wrote:*   

> quello l'avevo già letto nel tutorial "come fare volare gentoo". io imposterò il valore a 20.
> 
> grazie comunque 

 

fai attenzione però... è un'arma a doppio taglio, perché potresti trovarti ad avere i dischi che frullano come dei dannati per stare dietroa  quel valore, e ti ricordo che la differenza di prestazioni tra hard disk e RAM è di tre ordini di grandezza

----------

## makami

 *k.gothmog wrote:*   

>  *Occasus wrote:*   quello l'avevo già letto nel tutorial "come fare volare gentoo". io imposterò il valore a 20.
> 
> grazie comunque  
> 
> fai attenzione però... è un'arma a doppio taglio, perché potresti trovarti ad avere i dischi che frullano come dei dannati per stare dietroa  quel valore, e ti ricordo che la differenza di prestazioni tra hard disk e RAM è di tre ordini di grandezza

 

K.gothmog, quello che dici vale se hai poca ram, se ne hai tanta non penso che il disco frulli come un dannato, o mi sbaglio?

----------

## .:chrome:.

 *makami wrote:*   

> K.gothmog, quello che dici vale se hai poca ram, se ne hai tanta non penso che il disco frulli come un dannato, o mi sbaglio?

 

secondo me, per tanta che sia la RAM, impostarlo a 20 implica dei grossi trasferimenti sul disco

poi considera che la RAM non viene usata solo come spazio di lavoro. buona parte è costituita anche da buffers... se costringi il sistema ad avere sempre l'80% di memoria libera, vuol dire che rinunci ai buffers, e quindi si verifica per forza quello cheti ho detto.

non sei d'accordo?

----------

## makami

ma impostare quella variabile a 20 non significa che l' 80% della ram debba sempre essere libera, significa che quando tutta la ram è occupata il kernel tende a liberare una parte di ram occupata da dati ora inutili e occuparla con i nuovi dati anzichè scriverli in swap

più il valore è prossimo a zero più il kernel farà questo lavoro, ma solo quando non c'è ram libera.. io ho sempre capito che la cosa funzioni in questo modo, altrimenti sarebbe inutile, tenere sempre l' 80% della ram libera che senso avrebbe?

----------

## xdarma

@Occasus

Quasi quasi ti uso come cavia  :-)

Tanto per provare, ho ricompilato il kernel con qualche piccolo aggiustamento alle HOSTCFLAGS del Makefile, aggiungendo:

-march=pentium3 -pipe

L'impressione che ne ho ricavato è che tutto il sistema sia leggermente più responsivo e non è assolutamente diminuita la stabilità.

Però è solo la mia impressione, per questo, se ne hai voglia, potresti "strizzare" anche il tuo kernel e dirmi cosa ti sembra...

ciao

xdarma

----------

## .:chrome:.

 *makami wrote:*   

> ma impostare quella variabile a 20 non significa che l' 80% della ram debba sempre essere libera, significa che quando tutta la ram è occupata il kernel tende a liberare una parte di ram occupata da dati ora inutili e occuparla con i nuovi dati anzichè scriverli in swap
> 
> più il valore è prossimo a zero più il kernel farà questo lavoro, ma solo quando non c'è ram libera.. io ho sempre capito che la cosa funzioni in questo modo, altrimenti sarebbe inutile, tenere sempre l' 80% della ram libera che senso avrebbe?

 

è proprio quello che ti sto chiedendo... quello è un valore percentuale, a quanto ne so io

----------

## Ic3M4n

in ogni caso, ripeto: il tuo problema _non_ può risiedere nelle flag use sbagliate. e comunque lavorare molto di swap come detto da k.gothmog ti costringe a sprecare molti cicli processore per copiare dati della ram. se vuoi migliorare l'utilizzo della ram fatti un regalo di natale posticipato e comprati un banco di ram aggiuntivo. i benefici che otterrai saranno maggiori che litigare con la swap.

----------

## makami

 *k.gothmog wrote:*   

>  *makami wrote:*   ma impostare quella variabile a 20 non significa che l' 80% della ram debba sempre essere libera, significa che quando tutta la ram è occupata il kernel tende a liberare una parte di ram occupata da dati ora inutili e occuparla con i nuovi dati anzichè scriverli in swap
> 
> più il valore è prossimo a zero più il kernel farà questo lavoro, ma solo quando non c'è ram libera.. io ho sempre capito che la cosa funzioni in questo modo, altrimenti sarebbe inutile, tenere sempre l' 80% della ram libera che senso avrebbe? 
> 
> è proprio quello che ti sto chiedendo... quello è un valore percentuale, a quanto ne so io

 

E' un valore percentuale che indica al kernel cosa bisogna fare quando la ram è piena, non un valore percentuale che indica al kernel quanta ram devi usare.

Con 20 scriverà molto poco in swap ma tenderà molto a cancellare vecchi dati ormai inutili dalla ram per metterci i nuovi

----------

## fejfbo

A giorni (spero prestissimo   :Very Happy:  ) mi dovrebbe arrivare un Ibm T30.

Controllando sul sito ibm, mi dice che il processore è un P4-mobile.

Da qui il dubbio? E' meglio usare cflag ottimizzate per pentium4 o per pentium-m?   :Embarassed: 

----------

## lavish

Ho fatto il merge del thread aperto da fejfbo in modo da condensare tutte le info sulle CFLAGS  :Wink: 

Ciao!

----------

## Ferdinando

 *fejfbo wrote:*   

> Da qui il dubbio? E' meglio usare cflag ottimizzate per pentium4 o per pentium-m?  

 

Un p4m non è un pentium-m (purtroppo): usa pentium4, poi le caratteristiche "mobile" le attivi dal kernel.

Ciao

----------

