# cflags per Intel

## Hal-10000

Ciao, leggendo il post precedente mi sono chiesto anch'io se le impostazioni in make.conf siano adatte al mio processore che e' un intel core duo T2250 a 32 bit : 

```
 $ grep -m1 -A3 "vendor_id" /proc/cpuinfo

vendor_id   : GenuineIntel

cpu family   : 6

model      : 14

model name   : Genuine Intel(R) CPU           T2250  @ 1.73GHz

```

questa e' l'impostazione che ho in make.conf che avevo tratto dal manuale di installazione di gentoo e che ho finora utilizzato 

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

In questa pagina del wiki invece http://wiki.gentoo.org/wiki/Safe_CFLAGS#Core_2_Duo si suggerisce una impostazione diversa, anche se pero' qui la cpu e' piu' recente (T7500) mentre la mia e' T2250 e l'esempio e' riferito ad un'architettura 64 bit.

Non so se possa servire, ma, quando ricompilo il kernel uso questa stringa 

```
KCFLAGS="-march=native -O2 -pipe" KCPPFLAGS="-march=native -O2 -pipe" make -j3 && make modules_install && make install

```

Grazie per l'aiuto

----------

## sabayonino

ciao

se hai la flag "lm" (Long Mode) nelle flags del processore , allora è un 64 bit

```
# grep  -m1 lm /proc/cpuinfo 
```

se hai installato da uno snapshot x86  ... mi sa che dovrai tornare indietro   :Rolling Eyes:  o continuare ad ottimizzare per i686

se lo snapshot era un amd64 , beh allora cambia ottimizzazione e buon lavoro  :Wink: 

PS : abilitando la USE "experimental" per i kernel , troverai nella configurazione del kernel alcune voci per il tipo di processore da ottimizzare (o meglio il codice da ottimizzare) oltre ad altri inserimenti , questo ti eviterà di passare i parametri ad ogni compilazione.

```
Processor type and features  --->

  Processor family (...) --->
```

vedi anche : https://wiki.gentoo.org/wiki/Project:Kernel/Experimental

PS : il tuo processore secondo le specifiche intel è un 32bit : http://ark.intel.com/products/27232/Intel-Core-Duo-Processor-T2250-%282M-Cache-1_73-GHz-533-MHz-FSB%29

per cui .... continua con 32 bit passando 

i686

oppure

native se non vuoi sbattimenti 

oppure aggiungi le flags manualmente secondo l'output di 

```
# gcc -march=native -E -v - </dev/null 2>&1 | grep cc1
```

ci sono un paio di thread appena sotto a questo a riguardo

----------

## Hal-10000

Ciao sabayonino e grazie per la risposta.

Intanto sto cercando di capire qualcosa dell'argomento -che almeno per me non e' dei piu' facili- leggendo i precedenti thread e i vari link indicati. Quindi magari ti chiedero' qualche altra spiegazione in seguito.

Premesso cio' e confidando nella tua pazienza   :Laughing:   partirei dalla fine del tuo post, dove scrivi: 

 *Quote:*   

> .... continua con 32 bit passando
> 
> i686
> 
> oppure
> ...

 

Allora, visto che ho gia' i686 settato in make.conf 

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

 lascio cosi, oppure sostituisco i686 con native?

Mi sembra, che secondo te la cosa sia pressocche' uguale.

Non devo  quindi inserire core2 al posto di i686, come invece sembrerebbe dal qui http://wiki.gentoo.org/wiki/Safe_CFLAGS#Core_2_Duo dove si parla dei processori Core Duo, ma di una generazione piu' recente?

Quanto poi all'output di 

```
gcc -march=native -E -v - </dev/null 2>&1 | grep cc1
```

 ho questo, ma non so come muovermi 

```
gcc -march=native -E -v - </dev/null 2>&1 | grep cc1

 /usr/libexec/gcc/i686-pc-linux-gnu/4.7.3/cc1 -E -quiet -v - -march=pentium-m -mno-cx16 -mno-sahf -mno-movbe -mno-aes -mno-pclmul -mno-popcnt -mno-abm -mno-lwp -mno-fma -mno-fma4 -mno-xop -mno-bmi -mno-bmi2 -mno-tbm -mno-avx -mno-avx2 -mno-sse4.2 -mno-sse4.1 -mno-lzcnt -mno-rdrnd -mno-f16c -mno-fsgsbase --param l1-cache-size=32 --param l1-cache-line-size=64 --param l2-cache-size=2048 -mtune=generic

```

----------

## sabayonino

la versione di gcc che stai utilizzando vede "-march" come Pentium-M se passi il parametro "native" più tutte le atre flags 

```
-march=pentium-m -mno-cx16 -mno-sahf -mno-movbe -mno-aes -mno-pclmul -mno-popcnt -mno-abm -mno-lwp -mno-fma -mno-fma4 -mno-xop -mno-bmi -mno-bmi2 -mno-tbm -mno-avx -mno-avx2 -mno-sse4.2 -mno-sse4.1 -mno-lzcnt -mno-rdrnd -mno-f16c -mno-fsgsbase --param l1-cache-size=32 --param l1-cache-line-size=64 --param l2-cache-size=2048 -mtune=generic 
```

che si dice delle flags processore ?   :Wink: 

```
# cat /proc/cpuinfo | tail  | grep flags
```

----------

## Hal-10000

 *Quote:*   

> la versione di gcc che stai utilizzando vede "-march" come Pentium-

 

Ecco, e' proprio questo il fatto. Lasciando tutto cosi', non ci sarebbe alcuna ottimizzazione per il tipo del mio processore che non e' un Pentium ma un Core Duo (di qualche anno fa)  :Confused:  .

Ecco le info della cpu

```
 # cat /proc/cpuinfo | tail  | grep flags

flags      : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov clflush dts acpi mmx fxsr sse sse2 ss ht tm pbe nx constant_tsc arch_perfmon bts aperfmperf pni monitor est tm2 xtpr pdcm dtherm

```

Devo precisare poi che nella configurazione del kernel 

```
Processor type and features  --->

  Processor family (...) --->   

```

ho attivato Core Duo ...

----------

## loxdegio

Io ho trovato questo link se può aiutare, secondo me la situazione è identica

----------

## sabayonino

 *loxdegio wrote:*   

> Io ho trovato questo link se può aiutare, secondo me la situazione è identica

 

 *Quote:*   

> Intel Core Solo/Duo, Pentium Dual-Core T20xx/T21xx
> 
> vendor_id  : GenuineIntel
> 
> cpu family  : 6
> ...

 

dalle tue info precedenti :

```
cpu family   : 6

model      : 14 
```

puoi vedere i cabiamenti della tua arch anche qua --> http://www.cpu-world.com/CPUs/Core_Duo/index.html

stando a quantp indicato dovreti utilizzare

```
CFLAGS="-march=prescott -O2 -pipe -fomit-frame-pointer" 
```

----------

## Hal-10000

Ohh, perfetto!!!

1000 grazie a loxdegio e sabayonino

a questo punto vado di 

```
CFLAGS="-march=prescott -O2 -pipe -fomit-frame-pointer" 
```

e poi

```
# emerge -e world
```

mi confermate per favore?

(intanto aggiorno il backup, non si sa mai..)  :Razz: 

----------

## Hal-10000

Beh, per la ricompilazione di tutto il sistema ci ha messo circa 14 ore! Erano 916 pacchetti ed il portatile è un pò lentino.

Adesso con le nuove CFLAGS non è che abbia guadagnato gran che in termini di prestazioni, che, almeno ad occhio, sembrano invariate; poi non saprei.

Questo ovviamente sempre a condizione che il comando 

```
emerge -e world
```

 sia stato quello giusto  :Rolling Eyes: 

----------

## Hal-10000

Scusate se ritorno sull'argomento, ma mi e' sorto un dubbio.

Avevo modificato le CFLAGS specificando il tipo di processore (prescott) per cui il make.conf adesso e' cosi

```
CFLAGS="-march=prescott -O2 -pipe -fomit-frame-pointer"
```

mentre prima avevo 

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

e dopo ho dovuto ricompilare tutto il sistema con la nuova flag dando 

```
emerge -e world
```

.

Ci e' voluta una giornata intera (!)

Ora mi chiedo se, prima di ricompilare tutto il sistema, avrei dovuto ricompilare il kernel con la nuova flag.

Mi spiego. Prima, quando installavo un nuovo kernel, lo ricompilavo cosi:

```
KCFLAGS="-march=native -O2 -pipe" KCPPFLAGS="-march=native -O2 -pipe" make -j3 && make modules_install && make install
```

Domanda:

adesso, dopo che ho cambiato la flag in make.conf, devo PRIMA ricompilare il kernel cosi:

```
KCFLAGS="-march=prescott -O2 -pipe -fomit-frame-pointer" KCPPFLAGS="-march=prescott -O2 -pipe -fomit-frame-pointer" make -j3 && make modules_install && make install
```

e POI ricompilare DI NUOVO tutto il sistema con 

```
emerge -e world
```

???

Grazie per l'aiuto

----------

## sabayonino

no. il kernel ha le sue opzioni a parte.

comunque se attivi la flag  "experimental" ai gentoo-sources , alla voce  "Processor Type and features" -->"Processor family"

avrai la possibilità di selezionare alcune flags di ottimizzazione

```

                                                               │  hotkey of the item you wish to select followed by the <SPACE │  

                                                               │  BAR>. Press <?> for additional information about this        │  

                                                               │ ┌───────────^(-)────────────────────────────────────────────┐ │  

                                                               │ │       ( ) Intel Core i7                                   │ │  

                                                               │ │       ( ) Intel Core 2nd Gen AVX                          │ │  

                                                               │ │       ( ) Intel Core 3rd Gen AVX                          │ │  

                                                               │ │       ( ) Intel Core AVX2                                 │ │  

                                                               │ │       ( ) Generic-x86-64                                  │ │  

                                                               │ │       (X) Native optimizations autodetected by GCC        │ │  

                                                               │ └────────────────────────────────────────────────────
```

nel caso di autodeect

```
 CONFIG_MNATIVE:                                                                                                                                                                         │  

  │                                                                                                                                                                                         │  

  │                                                                                                                                                                                         │  

  │ GCC 4.2 and above support -march=native, which automatically detects                                                                                                                    │  

  │ the optimum settings to use based on your processor. -march=native                                                                                                                      │  

  │ also detects and applies additional settings beyond -march specific                                                                                                                     │  

  │ to your CPU, (eg. -msse4). Unless you have a specific reason not to                                                                                                                     │  

  │ (e.g. distcc cross-compiling), you should probably be using                                                                                                                             │  

  │ -march=native rather than anything listed below.                                                                                                                                        │  

  │                                                                                                                                                                                         │  

  │ Enables -march=native                                                                                                                                                                   │  

  │                                                                                                                                                                                         │  

  │ Symbol: MNATIVE [=y]                                                                                                                                                                    │  

  │ Type  : boolean                                                                                                                                                                         │  

  │ Prompt: Native optimizations autodetected by GCC                                                                                                                                        │  

  │   Location:                                                                                                                                                                             │  

  │     -> Processor type and features                                                                                                                                                      │  

  │       -> Processor family (<choice> [=y])                                                                                                                                               │  

  │   Defined at arch/x86/Kconfig.cpu:357                                                                                                                                                   │  

  │   Depends on: <choice>                                                                                                                                                                  │  

  │                        
```

e non necessita di passre i parametri manualmente (se non vuoi)

buon esperimento

----------

## Hal-10000

Grazie per la risposta. Sto sperimentando un pò  :Smile: 

----------

