Word (arquitetura de computador) - Word (computer architecture)
Larguras de bits da arquitetura do computador |
---|
Pedaço |
Aplicativo |
Precisão de ponto flutuante binário |
Precisão de ponto flutuante decimal |
Na computação , uma palavra é a unidade natural de dados usada por um projeto de processador específico . Uma palavra é um de tamanho fixo pedaço de dados manipulados como uma unidade pelo conjunto de instruções ou o hardware do processador. O número de bits em uma palavra (o tamanho da palavra , largura da palavra ou comprimento da palavra ) é uma característica importante de qualquer projeto de processador específico ou arquitetura de computador .
O tamanho de uma palavra se reflete em muitos aspectos da estrutura e operação de um computador; a maioria dos registradores em um processador geralmente tem o tamanho de uma palavra e o maior pedaço de dados que pode ser transferido de e para a memória de trabalho em uma única operação é uma palavra em muitas (não em todas) arquiteturas. O maior tamanho de endereço possível , usado para designar um local na memória, é normalmente uma palavra de hardware (aqui, "palavra de hardware" significa a palavra natural de tamanho completo do processador, em oposição a qualquer outra definição usada).
Documentação para computadores com tamanho de palavra fixo tamanhos de memória comumente declarados em palavras em vez de bytes ou caracteres. Termos como kilowords (KW) significando 1.024 palavras (2 10 ) e megawords (MW) significando 1.048.576 palavras (2 20 ) eram normalmente usados. Com a padronização em bytes de 8 bits e capacidade de endereçamento de bytes, declarar os tamanhos de memória em bytes, kilobytes e megabytes se tornou a norma.
Vários dos primeiros computadores (e alguns modernos também) usavam decimais codificados em binários em vez de binários simples , normalmente tendo um tamanho de palavra de 10 ou 12 dígitos decimais , e alguns computadores decimais antigos não tinham nenhum comprimento de palavra fixo. Os primeiros sistemas binários tendiam a usar comprimentos de palavra que eram alguns múltiplos de 6 bits, com a palavra de 36 bits sendo especialmente comum em computadores mainframe . A introdução do ASCII levou à mudança para sistemas com comprimentos de palavra que eram múltiplos de 8 bits, com máquinas de 16 bits sendo populares na década de 1970 antes da mudança para processadores modernos com 32 ou 64 bits. Projetos para fins especiais, como processadores de sinal digital , podem ter qualquer comprimento de palavra de 4 a 80 bits.
O tamanho de uma palavra às vezes pode ser diferente do esperado devido à compatibilidade com computadores anteriores. Se múltiplas variações compatíveis ou uma família de processadores compartilham uma arquitetura comum e conjunto de instruções, mas diferem em seus tamanhos de palavras, sua documentação e software podem se tornar notacionalmente complexos para acomodar a diferença (consulte Famílias de tamanhos abaixo).
Usos de palavras
Dependendo de como um computador está organizado, unidades de tamanho de palavra podem ser usadas para:
- Números de ponto fixo
- Suportes para pontos fixos , geralmente inteiros , valores numéricos podem estar disponíveis em um ou em vários tamanhos diferentes, mas um dos tamanhos disponíveis quase sempre será a palavra. Os outros tamanhos, se houver, provavelmente serão múltiplos ou frações do tamanho da palavra. Os tamanhos menores são normalmente usados apenas para uso eficiente da memória; quando carregados no processador, seus valores geralmente vão para um suporte de tamanho de palavra maior.
- Números de ponto flutuante
- Os detentores de valores numéricos de ponto flutuante são normalmente uma palavra ou um múltiplo de uma palavra.
- Endereços
- Os portadores dos endereços de memória devem ter um tamanho capaz de expressar a faixa de valores necessária, mas não excessivamente grandes; portanto, frequentemente o tamanho usado é a palavra, embora também possa ser um múltiplo ou uma fração do tamanho da palavra.
- Registros
- Os registradores do processador são projetados com um tamanho apropriado para o tipo de dados que armazenam, por exemplo, números inteiros, números de ponto flutuante ou endereços. Muitas arquiteturas de computador usam registradores de propósito geral que são capazes de armazenar dados em múltiplas representações.
- Transferência de memória para processador
- Quando o processador lê do subsistema de memória para um registro ou grava o valor de um registro na memória, a quantidade de dados transferidos costuma ser uma palavra. Historicamente, essa quantidade de bits que podiam ser transferidos em um ciclo também era chamada de catena em alguns ambientes (como o Bull GAMMA 60 ). Em subsistemas de memória simples, a palavra é transferida pelo barramento de dados da memória , que normalmente tem a largura de uma palavra ou meia palavra. Em subsistemas de memória que usam caches , a transferência de tamanho de palavra é aquela entre o processador e o primeiro nível de cache; em níveis mais baixos da hierarquia de memória, transferências maiores (que são um múltiplo do tamanho da palavra) são normalmente usadas.
- Resolução de unidade de endereço
- Em uma dada arquitetura, os valores de endereço sucessivos designam unidades sucessivas de memória; esta unidade é a unidade de resolução de endereço. Na maioria dos computadores, a unidade é um caractere (por exemplo, um byte) ou uma palavra. (Alguns computadores usaram resolução de bits.) Se a unidade for uma palavra, uma quantidade maior de memória pode ser acessada usando um endereço de um determinado tamanho ao custo de complexidade adicional para acessar caracteres individuais. Por outro lado, se a unidade for um byte, então caracteres individuais podem ser endereçados (isto é, selecionados durante a operação de memória).
- Instruções
- As instruções de máquina normalmente têm o tamanho da palavra da arquitetura, como nas arquiteturas RISC , ou um múltiplo do tamanho "char" que é uma fração dele. Essa é uma escolha natural, pois as instruções e os dados geralmente compartilham o mesmo subsistema de memória. Nas arquiteturas de Harvard, os tamanhos das palavras de instruções e dados não precisam ser relacionados, pois as instruções e os dados são armazenados em memórias diferentes; por exemplo, o processador na central telefônica eletrônica 1ESS tinha instruções de 37 bits e palavras de dados de 23 bits.
Escolha do tamanho da palavra
Quando uma arquitetura de computador é projetada, a escolha do tamanho da palavra é de grande importância. Existem considerações de design que encorajam tamanhos de grupos de bits específicos para usos específicos (por exemplo, para endereços), e essas considerações apontam para tamanhos diferentes para usos diferentes. No entanto, as considerações de economia no design pressionam fortemente para um tamanho, ou muito poucos tamanhos relacionados por múltiplos ou frações (submúltiplos) para um tamanho principal. Esse tamanho preferido torna-se o tamanho da palavra da arquitetura.
O tamanho dos caracteres era no passado ( codificação de caracteres de tamanho pré-variável ) uma das influências na resolução da unidade de endereço e na escolha do tamanho da palavra. Antes de meados da década de 1960, os caracteres eram mais frequentemente armazenados em seis bits; isso permitia no máximo 64 caracteres, portanto, o alfabeto era limitado a maiúsculas. Como é eficiente no tempo e no espaço ter o tamanho da palavra um múltiplo do tamanho do caractere, os tamanhos das palavras neste período eram geralmente múltiplos de 6 bits (em máquinas binárias). Uma escolha comum era a palavra de 36 bits , que também é um bom tamanho para as propriedades numéricas de um formato de ponto flutuante.
Após a introdução do design IBM System / 360 , que usava caracteres de oito bits e letras minúsculas, o tamanho padrão de um caractere (ou mais precisamente, um byte ) passou a ser de oito bits. Daí em diante, os tamanhos das palavras eram naturalmente múltiplos de oito bits, com 16, 32 e 64 bits sendo comumente usados.
Arquiteturas de palavras variáveis
Os primeiros projetos de máquinas incluíam alguns que usavam o que costuma ser denominado um comprimento de palavra variável . Nesse tipo de organização, um operando numérico não tinha comprimento fixo, mas seu final era detectado quando um caractere com uma marcação especial, muitas vezes chamado de marca nominativa , era encontrado. Essas máquinas costumavam usar decimais codificados em binários para números. Essa classe de máquinas incluía IBM 702 , IBM 705 , IBM 7080 , IBM 7010 , UNIVAC 1050 , IBM 1401 e IBM 1620 .
A maioria dessas máquinas funciona em uma unidade de memória por vez e, como cada instrução ou dado tem várias unidades de comprimento, cada instrução leva vários ciclos apenas para acessar a memória. Essas máquinas costumam ser muito lentas por causa disso. Por exemplo, as buscas de instruções em um IBM 1620 Modelo I levam 8 ciclos apenas para ler os 12 dígitos da instrução (o Modelo II reduziu para 6 ciclos, ou 4 ciclos se a instrução não precisasse de ambos os campos de endereço). A execução da instrução levou um número de ciclos completamente variável, dependendo do tamanho dos operandos.
Endereçamento de palavra e byte
O modelo de memória de uma arquitetura é fortemente influenciado pelo tamanho da palavra. Em particular, a resolução de um endereço de memória, ou seja, a menor unidade que pode ser designada por um endereço, muitas vezes foi escolhida para ser a palavra. Nesta abordagem, a abordagem de máquina endereçável por palavra , os valores de endereço que diferem em um designam palavras de memória adjacentes. Isso é natural em máquinas que lidam quase sempre com unidades de palavras (ou de várias palavras) e tem a vantagem de permitir que as instruções usem campos de tamanho mínimo para conter endereços, o que pode permitir um tamanho de instrução menor ou uma variedade maior de instruções.
Quando o processamento de bytes deve ser uma parte significativa da carga de trabalho, geralmente é mais vantajoso usar o byte , em vez da palavra, como a unidade de resolução de endereço. Os valores de endereço que diferem em um designam bytes adjacentes na memória. Isso permite que um caractere arbitrário em uma sequência de caracteres seja tratado de forma direta. Uma palavra ainda pode ser endereçada, mas o endereço a ser usado requer alguns bits a mais do que a alternativa de resolução de palavra. O tamanho da palavra precisa ser um múltiplo inteiro do tamanho do caractere nesta organização. Essa abordagem de endereçamento foi usada no IBM 360 e tem sido a abordagem mais comum em máquinas projetadas desde então.
Em uma máquina orientada por byte ( endereçável por byte ), mover um único byte de um local arbitrário para outro normalmente é:
- CARREGAR o byte de origem
- ARMAZENE o resultado de volta no byte de destino
Bytes individuais podem ser acessados em uma máquina orientada por palavra de uma das duas maneiras. Os bytes podem ser manipulados por uma combinação de operações de mudança e máscara em registradores. Mover um único byte de um local arbitrário para outro pode exigir o equivalente ao seguinte:
- CARREGAR a palavra que contém o byte de origem
- MUDE a palavra de origem para alinhar o byte desejado à posição correta na palavra de destino
- E a palavra fonte com uma máscara para zerar tudo, exceto os bits desejados
- CARREGAR a palavra que contém o byte alvo
- E a palavra-alvo com uma máscara para zerar o byte-alvo
- OU os registros contendo as palavras de origem e destino para inserir o byte de origem
- ARMAZENE o resultado de volta no local de destino
Alternativamente, muitas máquinas orientadas por palavras implementam operações de byte com instruções usando ponteiros de byte especiais em registradores ou memória. Por exemplo, o ponteiro de bytes PDP-10 continha o tamanho do byte em bits (permitindo que bytes de tamanhos diferentes fossem acessados), a posição do bit do byte na palavra e o endereço da palavra dos dados. As instruções podem ajustar automaticamente o ponteiro para o próximo byte em, por exemplo, carregar e depositar (armazenar) operações.
Poderes de dois
Diferentes quantidades de memória são usadas para armazenar valores de dados com diferentes graus de precisão. Os tamanhos comumente usados são geralmente uma potência de dois múltiplos da unidade de resolução do endereço (byte ou palavra). Converter o índice de um item em uma matriz no deslocamento de endereço de memória do item requer apenas uma operação de deslocamento , em vez de uma multiplicação. Em alguns casos, esse relacionamento também pode evitar o uso de operações de divisão. Como resultado, a maioria dos projetos de computador modernos tem tamanhos de palavras (e outros tamanhos de operandos) que são duas vezes maiores que o tamanho de um byte.
Famílias de tamanho
À medida que os projetos de computador se tornam mais complexos, a importância central de um único tamanho de palavra para uma arquitetura diminui. Embora um hardware mais capaz possa usar uma variedade maior de tamanhos de dados, as forças de mercado exercem pressão para manter a compatibilidade com versões anteriores, ao mesmo tempo em que estendem a capacidade do processador. Como resultado, o que poderia ter sido o tamanho da palavra central em um novo design deve coexistir como um tamanho alternativo ao tamanho da palavra original em um design compatível com versões anteriores. O tamanho da palavra original permanece disponível em designs futuros, formando a base de uma família de tamanhos.
Em meados da década de 1970, a DEC projetou o VAX para ser um sucessor de 32 bits do PDP-11 de 16 bits . Eles usaram word para uma quantidade de 16 bits, enquanto longword se referiu a uma quantidade de 32 bits. Isso foi em contraste com as máquinas anteriores, onde a unidade natural de endereçamento de memória seriam chamados a palavra , enquanto uma quantidade que é metade uma palavra seria chamado de halfword . De acordo com este esquema, uma palavra quádrupla VAX tem 64 bits. Eles continuaram esta terminologia palavra / palavra longa / palavra quádrupla com o Alpha de 64 bits .
Outro exemplo é a família x86 , da qual foram lançados processadores de três comprimentos de palavra diferentes (16 bits, mais tarde 32 e 64 bits), enquanto a palavra continua a designar uma quantidade de 16 bits. Como o software é rotineiramente portado de uma extensão de palavra para a próxima, algumas APIs e documentação definem ou se referem a uma extensão de palavra mais antiga (e portanto mais curta) do que a extensão de palavra completa na CPU para a qual o software pode ser compilado. Além disso, semelhante a como os bytes são usados para números pequenos em muitos programas, uma palavra mais curta (16 ou 32 bits) pode ser usada em contextos onde o intervalo de uma palavra mais ampla não é necessário (especialmente onde isso pode economizar espaço de pilha ou cache considerável espaço de memória). Por exemplo, a API do Windows da Microsoft mantém a definição da linguagem de programação de WORD como 16 bits, apesar do fato de que a API pode ser usada em um processador x86 de 32 ou 64 bits, onde o tamanho da palavra padrão seria de 32 ou 64 bits, respectivamente . As estruturas de dados contendo palavras de tamanhos diferentes referem-se a elas como WORD (16 bits / 2 bytes), DWORD (32 bits / 4 bytes) e QWORD (64 bits / 8 bytes), respectivamente. Um fenômeno semelhante foi desenvolvido na linguagem assembly x86 da Intel - devido ao suporte para vários tamanhos (e compatibilidade com versões anteriores) no conjunto de instruções, alguns mnemônicos de instrução carregam identificadores "d" ou "q" denotando "double-", "quad-" ou "double-quad-", que são em termos do tamanho de palavra de 16 bits original da arquitetura.
Em geral, os novos processadores devem usar os mesmos comprimentos de palavra de dados e larguras de endereço virtual que um processador mais antigo para ter compatibilidade binária com esse processador mais antigo.
Freqüentemente, o código-fonte cuidadosamente escrito - escrito com compatibilidade de código-fonte e portabilidade de software em mente - pode ser recompilado para rodar em uma variedade de processadores, mesmo aqueles com diferentes comprimentos de palavra de dados ou diferentes larguras de endereço ou ambos.
Tabela de tamanhos de palavras
chave: bit: bits , d: dígitos decimais , w : tamanho da palavra da arquitetura, n : tamanho variável | |||||||
---|---|---|---|---|---|---|---|
Ano | Arquitetura de computador |
Tamanho da palavra w | Tamanhos inteiros |
De ponto flutuante tamanhos |
Tamanhos de instrução |
Resolução de unidade de endereço |
Tamanho char |
1837 |
Mecanismo analítico de Babbage |
50 d | C | - | Cinco cartões diferentes foram usados para funções diferentes, o tamanho exato dos cartões não é conhecido. | C | - |
1941 | Zuse Z3 | 22 bits | - | C | 8 bits | C | - |
1942 | abc | 50 bits | C | - | - | - | - |
1944 | Harvard Mark I | 23 d | C | - | 24 bits | - | - |
1946 (1948) {1953} |
ENIAC (c / Painel # 16) {c / Painel # 26} |
10 d |
w , 2 w (w) {w} |
- | - (2 d, 4 d, 6 d, 8 d) {2 d, 4 d, 6 d, 8 d} |
- - {w} |
- |
1948 | Manchester Baby | 32 bits | C | - | C | C | - |
1951 | UNIVAC I | 12 d | C | - | 1 ⁄ 2 w | C | 1 d |
1952 | Máquina IAS | 40 bits | C | - | 1 ⁄ 2 w | C | 5 bits |
1952 | Computador digital universal rápido M-2 | 34 bits | C? | C | 34 bits = opcode de 4 bits mais endereço de 3 × 10 bits | 10 bits | - |
1952 | IBM 701 | 36 bits | 1 ⁄ 2 w , w | - | 1 ⁄ 2 w | 1 ⁄ 2 w , w | 6 bits |
1952 | UNIVAC 60 | n d | 1 d, ... 10 d | - | - | - | 2 d, 3 d |
1952 | ARRA I | 30 bits | C | - | C | C | 5 bits |
1953 | IBM 702 | n d | 0 d, ... 511 d | - | 5 d | d | 1 d |
1953 | UNIVAC 120 | n d | 1 d, ... 10 d | - | - | - | 2 d, 3 d |
1953 | ARRA II | 30 bits | C | 2 w | 1 ⁄ 2 w | C | 5 bits |
1954 (1955) |
IBM 650 (c / IBM 653 ) |
10 d | C | - (w) |
C | C | 2 d |
1954 | IBM 704 | 36 bits | C | C | C | C | 6 bits |
1954 | IBM 705 | n d | 0 d, ... 255 d | - | 5 d | d | 1 d |
1954 | IBM NORC | 16 d | C | w , 2 w | C | C | - |
1956 | IBM 305 | n d | 1 d, ... 100 d | - | 10 d | d | 1 d |
1956 | ARMAC | 34 bits | C | C | 1 ⁄ 2 w | C | 5 bits, 6 bits |
1957 | Autonetics Recomp I | 40 bits | w , 79 bits, 8 d, 15 d | - | 1 ⁄ 2 w | 1 ⁄ 2 w , w | 5 bits |
1958 | UNIVAC II | 12 d | C | - | 1 ⁄ 2 w | C | 1 d |
1958 | SÁBIO | 32 bits | 1 ⁄ 2 w | - | C | C | 6 bits |
1958 | Autonetics Recomp II | 40 bits | w , 79 bits, 8 d, 15 d | 2 w | 1 ⁄ 2 w | 1 ⁄ 2 w , w | 5 bits |
1958 | Setun | 6 trit (~ 9,5 bits) | até 6 tryte | até 3 trytes | 4 trit ? | ||
1958 | Electrologica X1 | 27 bits | C | 2 w | C | C | 5 bits, 6 bits |
1959 | IBM 1401 | n d | 1 d, ... | - | 1 d, 2 d, 4 d, 5 d, 7 d, 8 d | d | 1 d |
1959 (TBD) |
IBM 1620 | n d | 2 d, ... | - (4 d, ... 102 d) |
12 d | d | 2 d |
1960 | LARC | 12 d | w , 2 w | w , 2 w | C | C | 2 d |
1960 | CDC 1604 | 48 bits | C | C | 1 ⁄ 2 w | C | 6 bits |
1960 | IBM 1410 | n d | 1 d, ... | - | 1 d, 2 d, 6 d, 7 d, 11 d, 12 d | d | 1 d |
1960 | IBM 7070 | 10 d | C | C | C | w , d | 2 d |
1960 | PDP-1 | 18 bits | C | - | C | C | 6 bits |
1960 | Elliott 803 | 39 bits | |||||
1961 |
IBM 7030 (Stretch) |
64 bits | 1 bit, ... 64 bit, 1 d, ... 16 d |
C | 1 ⁄ 2 w , w | b, 1 ⁄ 2 w , w | 1 bit, ... 8 bit |
1961 | IBM 7080 | n d | 0 d, ... 255 d | - | 5 d | d | 1 d |
1962 | GE-6xx | 36 bits | w , 2 w | w , 2 w , 80 bits | C | C | 6 bits, 9 bits |
1962 | UNIVAC III | 25 bits | w , 2 w , 3 w , 4 w , 6 d, 12 d | - | C | C | 6 bits |
1962 | Computador de orientação
Autonetics D-17B Minuteman I |
27 bits | 11 bits, 24 bits | - | 24 bits | C | - |
1962 | UNIVAC 1107 | 36 bits | 1 ⁄ 6 w , 1 ⁄ 3 w , 1 ⁄ 2 w , w | C | C | C | 6 bits |
1962 | IBM 7010 | n d | 1 d, ... | - | 1 d, 2 d, 6 d, 7 d, 11 d, 12 d | d | 1 d |
1962 | IBM 7094 | 36 bits | C | w , 2 w | C | C | 6 bits |
1962 | SDS 9 Series | 24 bits | C | 2 w | C | C | |
1963 (1966) |
Computador de orientação Apollo | 15 bits | C | - | w , 2 w | C | - |
1963 | Computador digital do veículo de lançamento de Saturno | 26 bits | C | - | 13 bits | C | - |
1964/1966 | PDP-6 / PDP-10 | 36 bits | C | w , 2 w | C | C | 6 bits, 9 bits (típico) |
1964 | Titã | 48 bits | C | C | C | C | C |
1964 | CDC 6600 | 60 bits | C | C | 1 ⁄ 4 w , 1 ⁄ 2 w | C | 6 bits |
1964 | Computador de orientação
Autonetics D-37C Minuteman II |
27 bits | 11 bits, 24 bits | - | 24 bits | C | 4 bits, 5 bits |
1965 | Computador de orientação Gemini | 39 bits | 26 bits | - | 13 bits | 13 bits, 26 | -pedaço |
1965 | IBM 360 | 32 bits |
1 ⁄ 2 w , w , 1 d, ... 16 d |
w , 2 w | 1 ⁄ 2 w , w , 1 1 ⁄ 2 w | 8 bits | 8 bits |
1965 | UNIVAC 1108 | 36 bits | 1 ⁄ 6 w , 1 ⁄ 4 w , 1 ⁄ 3 w , 1 ⁄ 2 w , w , 2 w | w , 2 w | C | C | 6 bits, 9 bits |
1965 | PDP-8 | 12 bits | C | - | C | C | 8 bits |
1965 | Electrologica X8 | 27 bits | C | 2 w | C | C | 6 bits, 7 bits |
1966 | SDS Sigma 7 | 32 bits | 1 ⁄ 2 w , w | w , 2 w | C | 8 bits | 8 bits |
1969 | Sistemas Four-Phase AL1 | 8 bits | C | - | ? | ? | ? |
1970 | MP944 | 20 bits | C | - | ? | ? | ? |
1970 | PDP-11 | 16 bits | C | 2 w , 4 w | w , 2 w , 3 w | 8 bits | 8 bits |
1971 | TMS1802NC | 4 bits | C | - | ? | ? | - |
1971 | Intel 4004 | 4 bits | w , d | - | 2 w , 4 w | C | - |
1972 | Intel 8008 | 8 bits | w , 2 d | - | w , 2 w , 3 w | C | 8 bits |
1972 | Calcomp 900 | 9 bits | C | - | w , 2 w | C | 8 bits |
1974 | Intel 8080 | 8 bits | w , 2 w , 2 d | - | w , 2 w , 3 w | C | 8 bits |
1975 | ILLIAC IV | 64 bits | C | w , 1 ⁄ 2 w | C | C | - |
1975 | Motorola 6800 | 8 bits | w , 2 d | - | w , 2 w , 3 w | C | 8 bits |
1975 |
MOS Tech. 6501 MOS Tech. 6502 |
8 bits | w , 2 d | - | w , 2 w , 3 w | C | 8 bits |
1976 | Cray-1 | 64 bits | 24 bits, w | C | 1 ⁄ 4 w , 1 ⁄ 2 w | C | 8 bits |
1976 | Zilog Z80 | 8 bits | w , 2 w , 2 d | - | w , 2 w , 3 w , 4 w , 5 w | C | 8 bits |
1978 (1980) |
X86 de 16 bits ( Intel 8086 ) (com ponto flutuante: Intel 8087 ) |
16 bits | 1 ⁄ 2 w , w , 2 d | - (2 w , 4 w , 5 w , 17 d) |
1 ⁄ 2 w , w , ... 7 w | 8 bits | 8 bits |
1978 | VAX | 32 bits | 1 ⁄ 4 w , 1 ⁄ 2 w , w , 1 d, ... 31 d, 1 bit, ... 32 bit | w , 2 w | 1 ⁄ 4 w , ... 14 1 ⁄ 4 w | 8 bits | 8 bits |
1979 (1984) |
Motorola série 68000 (c / ponto flutuante) |
32 bits | 1 ⁄ 4 w , 1 ⁄ 2 w , w , 2 d | - ( w , 2 w , 2 1 ⁄ 2 w ) |
1 ⁄ 2 w , w , ... 7 1 ⁄ 2 w | 8 bits | 8 bits |
1985 | IA-32 ( Intel 80386 ) (com ponto flutuante) | 32 bits | 1 ⁄ 4 w , 1 ⁄ 2 w , w | - ( w , 2 w , 80 bits) |
8 bits, ... 120 bits 1 ⁄ 4 w ... 3 3 ⁄ 4 w |
8 bits | 8 bits |
1985 | ARMv1 | 32 bits | 1 ⁄ 4 w , w | - | C | 8 bits | 8 bits |
1985 | MIPS | 32 bits | 1 ⁄ 4 w , 1 ⁄ 2 w , w | w , 2 w | C | 8 bits | 8 bits |
1991 | Cray C90 | 64 bits | 32 bits, w | C | 1 ⁄ 4 w , 1 ⁄ 2 w , 48 bits | C | 8 bits |
1992 | Alfa | 64 bits | 8 bits, 1 ⁄ 4 w , 1 ⁄ 2 w , w | 1 ⁄ 2 w , w | 1 ⁄ 2 w | 8 bits | 8 bits |
1992 | PowerPC | 32 bits | 1 ⁄ 4 w , 1 ⁄ 2 w , w | w , 2 w | C | 8 bits | 8 bits |
1996 |
ARMv4 (com polegar ) |
32 bits | 1 ⁄ 4 w , 1 ⁄ 2 w , w | - |
w ( 1 ⁄ 2 w , w ) |
8 bits | 8 bits |
2000 |
IBM z / Architecture (c / facilidade de vetor) |
64 bits |
1 ⁄ 4 w , 1 ⁄ 2 w , w 1 d, ... 31 d |
1 ⁄ 2 w , w , 2 w | 1 ⁄ 4 w , 1 ⁄ 2 w , 3 ⁄ 4 w | 8 bits | 8 bits, UTF-16 , UTF-32 |
2001 | IA-64 | 64 bits | 8 bits, 1 ⁄ 4 w , 1 ⁄ 2 w , w | 1 ⁄ 2 w , w | 41 bits | 8 bits | 8 bits |
2001 |
ARMv6 (com VFP) |
32 bits | 8 bits, 1 ⁄ 2 w , w | - (w, 2w) |
1 ⁄ 2 w , w | 8 bits | 8 bits |
2003 | x86-64 | 64 bits | 8 bits, 1 ⁄ 4 w , 1 ⁄ 2 w , w | 1 ⁄ 2 w , w , 80 bit | 8 bits, ... 120 bits | 8 bits | 8 bits |
2013 | ARMv8-A e ARMv9-A | 64 bits | 8 bits, 1 ⁄ 4 w , 1 ⁄ 2 w , w | 1 ⁄ 2 w , w | 1 ⁄ 2 w | 8 bits | 8 bits |
Ano | Arquitetura de computador |
Tamanho da palavra w | Tamanhos inteiros |
De ponto flutuante tamanhos |
Tamanhos de instrução |
Resolução de unidade de endereço |
Tamanho char |
chave: bit: bits, d: dígitos decimais, w : tamanho da palavra da arquitetura, n : tamanho variável |