Newsgroup: it.comp.hardware.cpu
Titolo: IA-64 e articolo su Byte.

Sull' ultimo numero di Byte c' è un lungo articolo sulla nuova cpu di
Intel che dovrebbe essere presentata alla fine del prossimo anno. Fralle
varie cose vi viene illustrato come questa nuova architettura sia frutto
di anni di ricerche in particolare sulla possibilità di parallelizzare
le istruzioni per aumentare le prestazioni (ovvio). L' articolista fa
molte considerazioni sulla superiorità di questa architettura rispetto
alle normali architetture Risc, ma conclude sollevando un problema che
mi pare non da poco. Dice in sostanza che questa architettura permette
sì di avere delle elevate prestazioni che con x86 non sarebbero neanche
pensabili, ma sarà necessario avere dei compilatori molto potenti in
grado di generare codice molto ben ottimizzato. In sostanza, le
prestazioni dipendono molto da compilatore. E in ogni caso, per avere
sempre il massimo, occorrerà ricompilare per ogni nuovo processore della
famiglia.
Alcune aziende che hanno prodotto processori per vari scopi con
architetture simili concettualmente, sostengono che hanno impiegati 10
anni (dieci!) per mettere a punto i loro compilatori. Naturalmente mi
aspetto che i tempi per IA-64 si riducano sensibilmente. Ma se anche
dovessero restare nell' ordine dei 3 o 4 anni mi parrebbero decisamente
tanti. Oltretutto, si dice che anche con codice bene ottimizzato, in un
primo tempo le cpu Risc esistenti saranno ancora più potenti e più
economiche. Avranno cioè un die più piccolo (anche a parità di tecnica
costruttiva) e, per esempio, un Alpha (che forse è il più diretto
concorrente) andrà circa il doppio! Per vedere le reali potenzialità di
IA-64, secondo l' articolista, occorrerà aspettare le cpu di seconda
generazione (attese per il 2004 circa). Per allora la competizione si
dovrebbe fare serrata, dato che potenzialmente la nuova architettura di
Intel ha margini di miglioramento superiori rispetto alle attuali
tecnologie Risc, le cui prestazioni aumenteranno ma meno rapidamente.
Io dico:
1. Attualmente non vedo la ragione di passare a IA-64. Un Alpha è più
potente, conoscendo la tendenza di Intel a non svendere le sue
"rivoluzioni" tecniche costerà anche meno e ha già 2 sistemi operativi a
64 bit e uno a 32 bit abbastanza ben testati e in grado potenzialmente
di sostituirsi a ciò che c' è ora;
2. Se oltretutto le prime macchine non saranno poi così drammaticamente
potenti e comunque dipenderanno dalle prestazioni dei compilatori stiamo
freschi, c' è da attendersi un po' poco;
3. Ricompilare per ogni nuovo processore che esce? Ma questo si dovrebbe
già fare già con l' attuale architettura x86 (e gli utenti Linux in
effetti lo fanno) ma se non mi sbaglio il codice Winzozz che gira (sia
sistema operativo che applicazioni) non è ricompilato per una cippa: è
la solita zuppa di istruzioni 386 messe in fila!
Conclusione: questa è la volta che Intel o sbaraglia tutti gli avversari
o si auto-sbaraglia.
Voi cosa ne pensate?

Voi cosa ne pensate?
La seconda che hai detto! ;-)
A parte gli scherzi, aspettiamo e vedremo.
PS. Qualche tempo fa' trovai un po' di informazioni sulla
    struttura a predicati delle istruzioni EPIC. Se trovo
    il tempo le potro' postare.
Lorenzo Allegrucci
par...@tin.it

o si auto-sbaraglia.
Staremo a vedere.
Marco

tempo, quindi questo non mi preoccupa affatto.
Fai bene, perche' Intel mi sembra abbia dichiarato che Merced
non sara' mai disponibile per i normali utenti. Solo servers.
Lorenzo Allegrucci
par...@tin.it

OK, ma Intel aspettando IA-64 cosa farà ??? Continuerà a sfornare vaccate come il P II ??
A la prochaine...
-
============="LUDO ERGO SUM"=====================                                              
GIANLUCA GATTI                                   
Como   
stry...@tin.it
 
stry...@hotmail.com
 
gga...@komodo.ing.unico.it
 (Politecnico di Milano )                      
 
"He who controls the past ,
 commands the future.
 He who commands the future 
 conquers the past."
                      - KANE                                   
================================================

Lorenzo Allegrucci
Marco

    Questo IA-64 è forse quel processore battezzato in codice MERCED oppure
si tratta di un'altra evoluzione?
    Io credo che i processori con architettura RISC siano in questo momento
i migliori; tuttavia nel proseguire degli anni, con l'aumento della potenza
elaborativa, i processori CISC potrebbero affermarsi perchè le istruzioni
più potenti non sarebbero penalizzate, come invece accade oggi con una
efficenza mediocre. Non credo però che l'architettura RISC scomparirà del
tutto; probabilmente ci sarà una maggiore differenziazione dei settori e
ognuno avrà a disposizione un sistema di elaborazione che si adatterà alle
proprie esigenze.
P.S. : per la cronaca tale articolo è stato scritto da un 17nne.

compilazione non consiste di un solo passo).
Qui non si sta parlando dei passi che un compilatore deve compiere
per compilare il codice, questa e' un'altra cosa.
Per unica compilazione intendo dire che il codice verra' compilato
una sola volta (come avviene oggi) per poter girare su qualsiasi
processore della sua famiglia.
In piu' (al contrario di oggi) questa unica compilazione dovra' fare
in modo che il codice da lei prodotto possa sfruttare le
caratteristiche superscalari dei processori di diverse generazioni.
E' chiaro adesso?
Lorenzo Allegrucci
par...@tin.it

proprie esigenze.
Esatto, niente scompare.
Basta guardare l'architettura x86 vecchia di vent'anni.
Lorenzo Allegrucci
par...@tin.it

Lorenzo Allegrucci
Marco

Per me sì. E per te????
Il tuo problema e' che non ti informi.
Lorenzo Allegrucci
par...@tin.it

Scusa, Lorenzo, ma non sono stato io ad inviare il precedente messaggio al
NG. E' stato un mio collega che si è divertito a rispondere ad alcuni post a
nome mio (un
altro suo intervento, non so se l'hia letto, riguardava sempre l'IA-64).
Spero comunque che avrai notato che il "mio" tono - di solito calmo - è
inspiegabilmente diventato arrogante e polemico.
Be', ora rispondo io.
Compilazione EPIC e out-of-order execution
------------------------------------------------------
Non credo che si tratti di situazioni completamente differenti (comunque,
per fare un parallelo, non si deve parlare di due cose spiccicatamente :-))
uguali, non trovi?)
Nessuno ci vieta di pensare che un compilatore possa lavorare in tre passi
principali:
    1. Generazione di una sorta di "codice intermedio" (che, in parole
povere, indica quello che c'è da fare).
    2. Ricerca delle dipendenze logiche e organizzazione delle istruzioni
(una specie di riordino del "codice intermedio")
    3. Generazione di codice per Merced (e riempimento del template), in
base alla sequenza riordinata.
Il problema di generare un flusso ottimo di istruzioni è stato già
affrontato da tempo, quindi non si dovrà "inventare" niente di
particolarmente rivoluzionario.
La differenza starà nel fatto che, mentre una CPU si limita ad esaminare una
piccola parte del codice (i k della cache L1, suppongo) e quindi genera la
sequenza che, localmente, appare quella ottima, da un compilatore ci
aspetteremo un lavoro considerevolmente più approfondito.
Compatibilità HW con il set x86
---------------------------------------
Secondo me può essere effettuata in due modi differenti.
    1. Introdurre un processore separato (ma sempre all'interno del die) per
le istruzioni x86 (alla faccia dell'economia).
    2. Applicare un decodificatore per questo tipo di istruzioni.
Ma il problema è che, se la soluzione adottata sarà troppo efficiente,
finiremo per usare Merced solo per il codice x86. Questo non sarà un
incoraggiamento per le softwarehouses a scrivere compilatori per Merced.
Secondo me sarebbe stato meglio adottare la soluzione di Digital.
L'unica compilazione
--------------------------
Non è ovvio che un compilatore debba capire tutto con le proprie forze,
visto che l'apporto umano potrebbe semplificargli notevolmente il lavoro.
Esempio: scrivere un codice per "schiarire" un'immagine. Devo prendere ogni
singolo punto e modificare il colore (che non è altro che un numero). Ora:
il cambiamento di ogni singolo pixel è indipendente dai pixel circostanti,
quindi il programmatore potrebbe scrivere il seguente pseudocodice
for (i=0; i<NumRighe;i++)
    for(j=0;j<NumColonne;j++)
        {
        Schiarisci il colore del punto i,j;
        }
e comunicare al compilatore che questi due for annidati possono essere
eseguiti COMPLETAMENTE in parallelo.
A questo, poi, occorrerebbe aggiungere un analizzatore che si occupi di
scovare il parallelismo laddove il programmatore non può arrivare (troppi
calcoli?).
Ciao,
Marco (quello vero :-)).

calcoli?).
A questo proposito leggevo che in effetti siamo di fronte a una sorta
di paradosso: moli problemi di natura non lineare vengono linearizzati
dal programmatore (es la matrice che tu dicevi prima) e poi il
compilatore (o nelle macchine attuali direttamente il processore cerca
di parallelizzarle). Infatti si parlava di rispolverare un linguaggio
di cui non ricordo il nome che in pratica e` basato su operazioni
matriciali..
Just my 2 cents.
_____________________________________________________
mmi...@iname.nunmerumpete.com
 <Matteo Migliavacca>
per rispondermi direttamente togli nunmerumpete dall'indirizzo