# DEC Alpha

O DEC Alpha, também conhecido como Alpha AXP, é um microprocessador de 64 bit construído na arquitetura RISC. Ele foi desenvolvido pela Digital Equipment Corporation (DEC).
Suporta os seguintes Sistemas Operacionais: OpenVMS (conhecido como OpenVMS AXP), Tru64 UNIX(Conhecido como DEC OSF/1 AXP e Digital UNIX), Windows NT (que usava uma camada de emulação de 32 bits, que posteriormente foi descontinuado pelo 4.0 SP6 e o Windows 2000RC1), Linux (Debian GNU/Linux, SUSE Linux, Gentoo Linux e Red Hat Linux), BSD UNIX (NetBSD, OpenBSD e FreeBSD até 6.x), Plan 9 from Bell Labs, e também o kernel L4Ka::Pistachio.

## História

A empresa que procurava um sucessor para seu processador VAX que era de 32 bits, começou um projeto RISC com nome de "Prisma" no ano de 1980. Com a finalidade de oferecer aos usuário um microcódigo programavel que ficou conhecido como Epicode, juntamente com um SO chamado "Esmeralda", o qual executava programas do VMS. Mas o projeto prisma logo foi cancelado porque computadores VAX ainda estavam sendo vendidos e com isso a equipe achava que VAX teria um futuro promissor.
Entre 1980 e nos primeiros anos da década de 90, processadores RISC com arquitetura MPIS e Sparc se tornaram populares por oferecer uma melhor relação entre custo/desempenho comparado com os sistemas VAX, e então a DEC decidiu criar um processador RISC que seria o sucessor do VAX, com base nos conceitos do projeto PRISMA, os responsáveis pelo novo projeto foram Richard L. Sites e Richard T. Witek, algumas características do PRISMA foram alteradas para atender alguns novos objetivos do Alpha, como por exemplo, o reajuste para que programas VMS pudessem rodar em uma velocidade razoável sem sofrer conversão e o novo design foi para uma atualização que passou de 32 bits do prisma para 64 bits, porque iria acabar os bits das arquiteturas de 32bits. Na criação de uma nova arquitetura foi levado em conta alguns objetivos como, alta performance, longevidade, capacidade de executar sistemas operacionais UNIX e VMS tendo uma migração fácil de arquiteturas VAX e MIPS, todos esses objetivos influenciaram na concepção do projeto.
Somente em meados da década de 1990 os processadores receberam o nome de "Alpha", pois originalmente eram designados como a série DECchip 21 x 64, onde os dois primeiros dígitos "21" significa o século XXI e os dígitos "64" vem de 64 bits. Também eram identificados por número de EV (que seria uma abreviação formal de "Extended VAX" ou também tendo um significado humorístico de "Electric Vlasic" que homenageia o experimento elétrico picles no Western Research Lab).
Em 1996 a produção dos chips foi licenciada para Samsung Electronics Company. Após a aquisição da Digital pela Compaq, a maioria dos produtos alpha foram colocados como API NetWorks Inc, sendo uma empresa privada financiada pela Samsung e Compaq.
Em outubro de 2001, MicroWay tornou-se a vendedora e prestadora de serviços da linha de produtos baseado em Alpha NetWorks API.
Em 2001 a Compaq anunciou que Alpha poderia ser extinto até 2004 em favor ao Itanium da Intel, vendendo toda propriedade do Alpha para a Intel. No mesmo ano, HP como nova proprietária da Compaq anunciou que continuaria com a produção por mais alguns anos.

## Arquitetura Alpha

Como um dos principais objetivos do projeto era longevidade e alta performance foi definido que o processador teria uma arquitetura de 64 bits, pois as arquiteturas que existiam na época ainda eram de 32 bits, sendo esse um dos principais pontos onde o Alpha se diferenciava das demais. Outro fato importante em que Alpha se destacou em relação aos concorrentes foi a técnica de múltiplas instruções, como não é possível acelerar um ciclo de clock, era necessário aumentar o trabalho que deve ser feito por um ciclo de clock, implementando cerca de 10 novas instruções por ciclo.
Processador RISC com 64 bits, executava instruções de comprimento fixo de 32 bits cada, possui 32 registradores de inteiro e 32 registradores de ponto flutuante.
5 grupos foram criados para simplificar e facilitar ações pepiling no conjunto de instruções:
* Instruções de inteiro – São instruções de aritmética, comparação e lógica, que envolvem soma, subtração e multiplicação de números inteiros;
* Instruções de ponto flutuante – são as instruções convencionais encontradas em arquiteturas RISC e possuem operações adicionais para mesclar operações de sinal/expoente;
* Instruções Branch – São testes condicionais como positivo ou negativo, par ou ímpar, igual ou não a zero.;
* Instruções Load/Store – Realizam operações entre registradores;
* PALcode instruções – É um conjunto de sub-rotinas, sendo específico para o sistema operacional, as sub-rotinas são utilizadas no contexto de comutação, interrupções de exceções e gerenciamento de memória. As sub-rotinas são chamadas pelo hardware ou por instruções de CALL_PAL, PALcode somente é executado em PALmode, um modo privilegiado que acaba com alguns eventos do sistema permitindo o controle completo do PALcode do sistema físico do hardware.
A arquitetura foi projetada para sistemas multiprocessadores. Sua primeira versão executava dois comandos em unidades diferentes, em versões posteriores de 7 a 13 estágios de pipeline são processadas, dependendo da UC e a geração do processador.
A arquitetura alpha não possui branch delay slots, instruções suppressed e instruções byte load/store (mais tardes adicionadas com BWX), porque seu objetivo principal era ter um alto desempenho suportando um aumento de 1 milhão de vezes no desempenho por 25 anos.
O cache L1 foi integrado: 8Kb para instruções (I-cache, cache de instrução), mapeamento-direto (uma linha na cache deve ser armazenada em um lugar específico, o qual depende do seu índice), também de 8Kb para dados (D-cache, cache de dados), mapeamento-direto e write-through (é uma politica de escrita, onde cada escrita é imediatamente repetida na memória principal). Latência de leitura de D-cache foi 3 ciclos.

### Especificações da arquitetura
#### Registradores

O conjunto de registradores foi definido sendo, 32 registradores de inteiros, 32 de ponto flutuante, 1 contador chamado de PC (program counter), 2 registradores de fechamento chamados LR0 e LR1, também um registrador FPCR (floating-point control register) para controle de ponto flutuante. Os registradores de inteiros receberam os nomes de R0 até R31, os de ponto flutuante de F0 até F31, sendo os registradores R31 e F31 sempre zeros (hardwired) e a escrita nestes registradores era ignorada. O registrador PC (Program Counter) é de 64 bits e contém o endereço da próxima instrução quando uma instrução é decodificada, incrementando ao seu valor atual. Os registradores LR0 e LR1 são usados pelas instruções de load e store/condicional para suporte a multiprocessadores.
O registrador FPCR (registrador para controle de ponto flutuante) é usado para implementações do Alpha em hardware compatível com IEEE 754.

#### Formato de dados

Por ser uma arquitetura load/store todas as operações são realizadas entre registradores. Com registradores de 64 bits, sendo 32 de inteiros e 32 de ponto flutuante. Os tipos de inteiros suportados são Longword (32-bit) e quadword (64-bit) e também suporta 4 tipos de ponto flutuante, que são eles: IEEE single (32-bits), IEEE double (64-bits), VAX F-float e VAX G-float, estes dois últimos foram incluídos para manter a compatibilidade com o VAX.
| 1 byte | 8 bits |
| Palavra | 16 bits |
| Código | 32 bits |
| Quadword | 64 bits |
| Octaword | 128 bits |

#### Formato de instrução

Todas as instruções são de 32 bits, todos tem um código de operando (Opcode) de 6 bits.
Cada um dos tipos será especificado logo abaixo da tabela:
| 31 | 30 | 29 | 28 | 27 | 26 | 25 | 24 | 23 | 22 | 21 | 20 | 19 | 18 | 17 | 16 | 15 | 14 | 13 | 12 | 11 | 10 | 9 | 8 | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 | Tipo |
| Opcode | Opcode | Opcode | Opcode | Opcode | Opcode | Ra | Ra | Ra | Ra | Ra | Rb | Rb | Rb | Rb | Rb | Unused | Unused | Unused | 0 | Function | Function | Function | Function | Function | Function | Function | Rc | Rc | Rc | Rc | Rc | Integer operate |
| Opcode | Opcode | Opcode | Opcode | Opcode | Opcode | Ra | Ra | Ra | Ra | Ra | Literal | Literal | Literal | Literal | Literal | Literal | Literal | Literal | 1 | Function | Function | Function | Function | Function | Function | Function | Rc | Rc | Rc | Rc | Rc | Integer operate, literal |
| Opcode | Opcode | Opcode | Opcode | Opcode | Opcode | Ra | Ra | Ra | Ra | Ra | Rb | Rb | Rb | Rb | Rb | Function | Function | Function | Function | Function | Function | Function | Function | Function | Function | Function | Rc | Rc | Rc | Rc | Rc | Floating-point operate |
| Opcode | Opcode | Opcode | Opcode | Opcode | Opcode | Ra | Ra | Ra | Ra | Ra | Rb | Rb | Rb | Rb | Rb | Displacement | Displacement | Displacement | Displacement | Displacement | Displacement | Displacement | Displacement | Displacement | Displacement | Displacement | Displacement | Displacement | Displacement | Displacement | Displacement | Memory format |
| Opcode | Opcode | Opcode | Opcode | Opcode | Opcode | Ra | Ra | Ra | Ra | Ra | Displacement | Displacement | Displacement | Displacement | Displacement | Displacement | Displacement | Displacement | Displacement | Displacement | Displacement | Displacement | Displacement | Displacement | Displacement | Displacement | Displacement | Displacement | Displacement | Displacement | Displacement | Branch format |
| Opcode | Opcode | Opcode | Opcode | Opcode | Opcode | Function | Function | Function | Function | Function | Function | Function | Function | Function | Function | Function | Function | Function | Function | Function | Function | Function | Function | Function | Function | Function | Function | Function | Function | Function | Function | CALL_PAL format |
O formato Integer operate é usado por instruções de inteiro, o primeiro campo possui 6 bits e contém o opcode da instrução, o próximo campo é definido como Ra que específica o registrador que contém o primeiro operando e o Rb específica o segundo operando. Logo após um campo com 3 bits não é utilizado ficando reservado. Em seguida 1 bit contendo o valor "0" para distinguir do formato tipo de número inteiro literal. O campo function é definido com 7 bits e usado para especificar uma operação. Por último o campo Rc específica que o resultado do cálculo deve ser escrito.
O formato integer literal é similar ao integer operate, o que diferencia é o campo Rb e o unosed, ambos não existem, em vez disso este espaço é usado pelo número literal formando um campo de 8 bits, que é a grande diferença entre os dois formatos. Este formato é usado quando um dos operando é um número literal. O campo com 1 bit de espaço passa a ser definido pelo valor "1".
O formato floating-point operate também é similar ao integer operate, suas particularidades esta no campo function que utiliza um espaço de 11 bits onde é possível utilizar o campo literal (antes usado no formato integer literal) e o campo unused (usado no formato integer operate).
O formato memory é usado principalmente por instruções de Load/Store. Consiste em um campo de 6 bits para o opcode (como os demais), campo Ra com 5 bits e um campo displacement para deslocamento com 16 bits.
O formato branch possui apenas um campo para o opcode (6 bits), um campo Ra (5 bits) e um campo displacement (21 bits). No campo Ra é feito um teste em instruções de desvio condicional, se a condição por atendida o PC é atualizado, adicionando o conteúdo do campo displacement com o valor do PC (program counter). Se o valor do campo displacement for positivo, o PC é incrementado, mas se o valor do campo displacement for negativo o PC é decrementado, ambos se o desvio (branch) ocorrer.
O formato CALL_PAL é usado apenas pela instrução CALL_PALL que por sua vez é usada para chamar sub-rotinas PALcode. Este formato possui apenas dois campos, sendo eles, o opcode (6 bits) e o function (26 bits) que contém um número inteiro especificando uma sub-rotina PAL.

#### Memória

O processador Alpha possui um endereço de memória virtual de 64 bits sem segmentação de memória, podendo ser implementado no mínimo 43 bits. Mesmo não utilizando todos os bits possíveis como por exemplo TLBs, é necessário implementar para verificação dos bits iguais a zero para garantir a compatibilidade do software que implementarem um espaço maior ou o espaço completo de endereços virtuais.

## Principais Modelos

A primeira versão do processador (1992) foi o Alpha 21064 ou EV4, sendo o primeiro microprocessador CMOS, rodava em 192 MHz e meses depois chegou a rodar em 200 MHz, com design superescalar e superpipelined.
A segunda versão, 21164 ou EV5 (1995), foi o primeiro a introduzir uma grande cache secundária no chip, com frequência de até 333 MHz, 500 MHz em 1996 e em 1998 chegou a velocidade de 666 MHz.
A terceira versão,21264 ou EV6 (1998),com 450 MHz, foi a primeira a combinar alta frequência operacional e a micro-arquitetura de execução fora de ordem. Em 2001 foi lançado o 21264C/EV68CB com frequência de 1,25 GHz
O controlador de memória no chip foi implementado pela primeira vez na quarta versão do processador, 21364 ou EV7 (2003).
A versão 21464 ou EV8 teria sido a primeira a incluir multithreading simultâneo, mas esta versão não foi produzida porque a empresa DEC foi vendida para a Compaq. Como última versão que ficou conhecido apenas pelo projeto de pesquisa, EV9, teria sido o primeiro processador a possuir uma unidade de vetor.
| Model | Model number | Year | Frequency [MHz] | Process [µm] | Transistors [millions] | Die size [mm$^2$] | IO Pins | Power [W] | Voltage | Dcache [KB] | Icache [KB] | Scache | Bcache | ISA |
| EV4 | 21064 | 1992 | 100–200 | 0.75 | 1.68 | 234 | 290 | 30 | 3.3 | 8 | 8 | – | 128 KB–16 MB | |
| EV4S | 21064 | 1993 | 100–200 | 0.675 | 1.68 | 186 | 290 | 27 | 3.3 | 8 | 8 | – | 128 KB–16 MB | |
| EV45 | 21064A | 1994 | 200–300 | 0.5 | 2.85 | 164 | | 33 | 3.3 | 16 | 16 | – | 256 KB–16 MB | |
| LCA4 | 21066 | 1993 | 100–166 | 0.675 | 1.75 | 209 | | 21 | 3.3 | 8 | 8 | – | | |
| LCA4 | 21068 | 1994 | 66 | 0.675 | 1.75 | 209 | | 9 | 3.3 | 8 | 8 | – | | |
| LCA45 | 21066A | 1994 | 100–266 | 0.5 | 1.8 | 161 | | 23 | 3.3 | 8 | 8 | – | | |
| LCA45 | 21068A | 1994 | 100 | 0.5 | 1.8 | 161 | | | 3.3 | 8 | 8 | – | | |
| EV5 | 21164 | 1995 | 266–500 | 0.5 | 9.3 | 299 | 296 | 56 | 3.3/2.5 | 8 | 8 | 96 KB | Up to 64 MB | R |
| EV56 | 21164A | 1996 | 366–666 | 0.35 | 9.66 | 209 | | 31–55 | 3.3/2.5 | 8 | 8 | 96 KB | Up to 64 MB | R,B |
| PCA56 | 21164PC | 1997 | 400–533 | 0.35 | 3.5 | 141 | 264 | 26–35 | 3.3/2.5 | 8 | 16 | – | 512 KB–4 MB | R,B,M |
| PCA57 | 21164PC | | 600–666 | 0.28 | 5.7 | 101 | 283 | 18–23 | 2.5/2.0 | 16 | 32 | – | 512 KB–4 MB | R,B,M |
| EV6 | 1998 | 450–600 | 0.35 | 15.2 | 314 | 389 | 73 | 2.0 | 64 | 64 | – | 2–8 MB | R,B,M,F |
| EV67 | 21264A | 1999 | 600–750 | 0.25 | 15.2 | 210 | 389 | | 2.0 | 64 | 64 | – | 2–8 MB | R,B,M,F,C |
| EV68AL | 21264B | 2001 | 800–833 | 0.18 | 15.2 | 125 | | | 1.7 | 64 | 64 | – | 2–8 MB | R,B,M,F,C,T |
| EV68CB | 21264C | 2001 | 1000–1250 | 0.18 | 15.2 | 125 | | 65–75 | 1.65 | 64 | 64 | – | 2–8 MB | R,B,M,F,C,T |
| EV68CX | 21264D | | | | | | | | 1.65 | 64 | 64 | – | 2–8 MB | R,B,M,F,C,T |
| EV7 | 21364 | 2003 | 1000–1150 | 0.18 | 130 | 397 | | 125 | 1.5 | 64 | 64 | 1.75 MB | – | R,B,M,F,C,T |
| EV7z | 21364 | 2004 | 1300 | 0.18 | 130 | 397 | | 125 | 1.5 | 64 | 64 | 1.75 MB | – | R,B,M,F,C,T |
| Cancelled |||||||||||||||
| EV78/EV79 | 21364A | Slated for 2004 | 1700 | 0.13 | 152 | 300 | | 120 | 1.2 | 64 | 64 | 1.75 MB | – | R,B,M,F,C,T |
| EV8 | 21464 | Slated for 2003 | 1200–2000 | 0.125 | 250 | 420 | 1800 | ?? | 1.2 | 64 | 64 | 3 MB | – | R,B,M,F,C,T |
| Model | Model number | Year | Frequency [MHz] | Process [µm] | Transistors [millions] | Die size [mm²] | IO Pins | Power [W] | Voltage | Dcache [KB] | Icache [KB] | Scache | Bcache | ISA |
Legenda de extensões ISA:
R - Suporte a hardware para o arrendodamento para maior que zero e menores que zero;
B - BWX, extensão de "Byte/Word", instruções que permitem operações de 8 bits e 16 bits e memória e i/o;
M - MVI, instruções de "multimedia";
F - Instruções para mover dados entre inteiros e registradores de ponto flutuante.
C - CIX, contagem
T - melhorar o desempenho da primeira tentativa de adquirir um bloqueio;

## Principais Diferenças

O projeto Alpha possui algumas diferenças comparando com outros processadores RISC convencionais, como principal diferença é que o projeto Alpha foi desenvolvido como uma arquitetura de 64 bits com um número mínimo de instruções de 32 bits, já outras arquiteturas RISC eram inicialmente de 32 bits e somente mais tarde foram ampliadas.
Outra diferença significativa está no fato de que o Alpha foi projetado para permitir implementações de velocidade muito alta, onde as instruções são muito simples, as quais não possuem load de 4 registradores e realiza a verificação de bytes iguais a zero. O Alpha não tem nenhum registrador especial que impeça o pipelining de realizar várias operações. Todas as instruções interagem umas com as outras somente por uma instrução de escrita num registrador ou por memória e também uma leitura no mesmo lugar, com isso ficou fácil de criar implementações que emitissem várias instruções por ciclo de clock.
Alpha também não é convencional na abordagem á traps (overflow, underflow, etc.), onde estas são imprecisas. Podem ocorrer várias instruções depois da instrução que disparou a trap e ao mesmo tempo, traps de muitas instruções diferentes podem ser reportadas. Outro aspecto que diferencia esta arquitetura é na abordagem da memória compartilhada entre vários processadores, onde a partir de um segundo processador, uma sequência de leituras e escritas emitidas por um processador podem ser reordenados por uma implementação. Há uma série de dicas para implementações que a arquitetura Alpha disponibiliza, como por exemplo, dicas de pré-busca para o sistema de memória que pode permitir que a taxa de acerto na cache (hit) seja maior, dicas de mapeamento de endereço virtual permitindo um uso mais eficaz para grandes estruturas contíguas.
Outro aspecto que torna a arquitetura especialmente atraente para sistemas operacionais é a biblioteca chamada PALcalls sendo muito flexível pois permite a execução de recursos do VAX, VMS, MIPS e NT OSF/1, existe também uma versão da biblioteca para ensino de sistemas em tempo real, onde os processadores convencionais não são permitidos.

## Extensões

Byte-Word Extensions (BMX)
Este conjunto de instruções foi introduzido a partir do microprocessador 21164A (EV56), sua funcionalidade é de manipular tipos de dados de 8bits e 16bits, sua principal vantagem foi o fato de que antes de sua implementação existiam várias instruções para realizar a mesma implementação, assim melhorando a densidade do código e também influenciava no desempenho de aplicativos. Outro ponto positivo foi a facilidade com que era feita a emulação de máquinas x86 com o auxilio do BMX.
| Instrução | Descrição |
| LDBU | Load Zero-Extended Byte from Memory to Register |
| LDWU | Load Zero-Extended Word from Memory to Register |
| SEXTB | Sign Extend Byte |
| SEXTW | Sign Extend Word |
| STB | Store Byte from Register to Memory |
| STW | Store Word from Register to Memory |
Motion Video Instructions (MVI)
Os processadores 21164PC (PCA56 e PCA57), 21264 (EV6) e o 21364 (EV7) foram os pioneiros na implementação das instruções MVI, adicionando instruções SIMD (Simple Instruction Multiple Data). Foi um conjunto de instruções simples, que era composto por instruções que operavam em tipos de dados inteiros, armazenando em registradores de inteiros. Teve como objetivo dois fatores que contribuíram para sua simplicidade, onde a decodificação de DVD era realizada por software, assim não requeria contribuição do hardware, no processador 21164. Outro fator foi a exigência de manter o propósito inicial do projeto que era de manter os ciclos de clock com alto desempenho, onde se fossem adicionadas muitas instruções reduziria a frequência de um ciclo.
| Instrução | Descrição |
| MAXSB8 | Vector Signed Byte Maximum |
| MAXSW4 | Vector Signed Word Maximum |
| MAXUB8 | Vector Unsigned Byte Maximum |
| MAXUW4 | Vector Unsigned Word Maximum |
| MINSB8 | Vector Signed Byte Minimum |
| MINSW4 | Vector Signed Word Minimum |
| MINUB8 | Vector Unsigned Byte Minimum |
| MINUW4 | Vector Unsigned Word Minimum |
| PERR | Pixel Error |
| PKLB | Pack Longwords to Bytes |
| PKWB | Pack Words to Bytes |
| UNPKBL | Unpack Bytes to Longwords |
| UNPKBW | Unpack Bytes to Words |
Floating-Point Extensions (FIX)
O primeiro processador a utilizar foi o Alpha 21264 (EV6), foi responsável por introduzir nove instruções entre raiz quadrada e para transferência de dados entre registradores inteiros e de ponto flutuante.
| Instrução | Descrição |
| FTOIS | Floating-point to Integer Register Move, S_floating |
| FTOIT | Floating-point to Integer Register Move, T_floating |
| ITOFF | Integer to Floating-point Register Move, F_floating |
| ITOFS | Integer to Floating-point Register Move, S_floating |
| ITOFT | Integer to Floating-point Register Move, T_floating |
| SQRTF | Square root F_floating |
| SQRTG | Square root G_floating |
| SQRTS | Square root S_floating |
| SQRTT | Square root T_floating |
Count Extensions (CIX)
O primeiro a utilizar foi o Alpha 21264A (EV67), o conjunto era composto por três instruções para a contagem de bits, as quais foram categorizadas como instruções aritmética de número inteiro.
| Instrução | Descrição |
| CTLZ | Count Leading Zero |
| CTPOP | Count Population |
| CTTZ | Count Trailing Zero |

## Sistemas baseados em Alpha

A série de workstations e servidores DEC 3000 AXP, servidores DEC 4000 AXP e servidores DEC 7000 AXP e 10000, foram os primeiros sistemas baseado no DEC Alpha.
DECpc AXP também conhecido como DEC 2000 AXP foi o primeiro sistema a oferecer suporte a Windos NT, tempos depois foi produzido as versões Celebris XL e Digital Personal Workstation PC com o processador 21164.
DEC também produziu computadores industriais (VMEbus), incluindo o 64 AXPvme baseado no 21068 e o AXPvme 64LC, baseado no 21066.
Como modelos mais recente temos, AXPvme 100, AXPvme 166 e AXPvme 230 baseados no processador 21064A. Os últimos foram o VME Alpha 5/352 e VME Alpha 5/480 que foram baseados no processador 21164.
Em 1994 foi lançado uma linha de AlphaStation e sistemas AlphaServer, utilizando processadores 21064 ou 21164, introduziram barramento PCI, buffers compatíveis com VGA e PS/2 (teclados e mouses).
A série 8000 AlphaServer substitui o DEC 7000/10000 AXP. O AlphaStation XP1000 foi o primeiro a trabalhar com processador 21264, os modelos mais recentes foram categorizados em DS (servidor departamental), ES (servido corporativo) ou GS (servidor global).
Os modelos AlphaServer ES47, ES80, GS 1280 e AlphaStation ES47 utilizaram o chip 21364.
Para ajudar a terceiros no desenvolvimento de hardware e software para a plataforma, DEC produziu placas de avaliação, tais como o EB64 + e EB164 para o alpha 21064A e 21164 respectivamente.
Os processadores 21164 e 21264 foram utilizados pela NetApp em vários sistemas de armazenamento conectado à rede, enquanto os processadores 21064 e 21164 foram utilizados por Cray em seus supercomputadores massivamente paralelos T3D e T3E (foto ao lado).

## Comparação de Desempenho

Para ilustrar o desempenho comparativo de sistemas baseados em Alpha, alguns números de desempenho SPEC (SPECint95, SPECfp95) são listados abaixo. Levando em consideração um computador (CPU, barramento, memória, otimizador de compilador), não apenas a CPU e também considerar que estes dados são de 1992 a 1995. A tabela mostra que o desempenho da arquitetura Alpha comparando com a arquitetura da HP e Intel. O desempenho entre a Intel e a Alpha é considerável, chegando razoavelmente perto da Alpha, por outro lado a HP também é chega razoavelmente perto da Alpha, mas as duas rodam em taxas de clock (MHz) menores. O destaque da tabela abaixo mostra os valores de consumo de energia e o preço de uma CPU.
SPEC Benchmark 1995 Performance comparison (using SPECint95 and SPECfp95 Result ) :
| System | CPU | MHz | integer | floating point |
2000 Performance comparison (using SPECint95 and SPECfp95 Result) :
| System | CPU | MHz | integer | floating point |