o que é a diferença entre Superscaling e pipelining?

https://stackoverflow.com/questions/1656608

11-09-2019
|

Pergunta

Bem parece muito simples, uma pergunta a ser feita, mas eu pedi depois de passar por alguns PPTS em ambos.

Ambos os métodos aumentar a instrução de transferência. E Superscaling quase sempre faz uso de pipelining também. Superscaling tem mais de uma unidade de execução e assim se canalizando ou estou errado aqui?

Solução

projeto Superscalar envolve o processador ser capaz de emitir múltiplas instruções em um único relógio, com instalações redundantes para executar uma instrução. Estamos falando de dentro de um único núcleo, você mente -. Processamento multicore é diferente

Pipelining divide uma instrução em etapas, e uma vez que cada passo é executado em uma parte diferente do processador, várias instruções podem estar em diferentes "fases" cada relógio.

Eles são quase sempre usados ??juntos. Esta imagem da Wikipedia mostra ambos os conceitos em uso, como esses conceitos são melhor explicadas graficamente:

Aqui, duas instruções estão sendo executadas em um momento em um pipeline de cinco estágios.

Para quebrá-lo ainda mais para baixo, dada a sua recente edição:

No exemplo acima, uma instrução passa por 5 estágios para ser "realizada". Estes são IF (busca de instrução), ID (decodificação de instrução), EX (executar), MEM (memória atualização), WB (write-back para cache).

Em um projeto de processador muito simples, cada relógio um estágio diferente seria concluída, então teríamos:

O que faria uma instrução em cinco relógios. Se nós, em seguida, adicionar uma unidade de execução redundante e apresentar projeto superscalar, teríamos este, por duas instruções A e B:

IF (A) SE (B)
ID (A) ID (B)
EX (A) EX (B)
MEM (A) MEM (B)
WB (A) WB (B)

Duas instruções em cinco relógios -. Um ganho teórico máximo de 100%

Pipelining permite que as peças a serem executadas simultaneamente, de modo que iria acabar com algo como (para obter instruções dez de A a J):

IF (A) SE (B)
ID (A) BI (B) SE (C) FI (D)
EX (a) ex (B) O ID (C) O ID (D) IF (E) IF (F)
MEM (A) MEM (B) EX (C) EX (D) O ID (E) Código (F) IF (L) IF (H)
WB (A) WB (B) MEM (C) MEM (D) EX (E) EX (F) Código (L) O ID (H) IF (I) IF (J)
WB (C) WB (D) MEM (E) MEM (F) EX (G) EX (H) O ID (I) ID (J)
WB (E) WB (F) MEM (L) MEM (H) EX (I) EX (J)
BM (G) WB (H) MEM (I) em MEM (J)
WB (I) WB (J)

Em nove relógios, temos executado instruções dez - você pode ver onde pipelining realmente move as coisas. E isso é uma explicação do exemplo ilustrativo, não como ele é realmente implementado no campo (que de magia negra ).

Os artigos da Wikipédia para Superscalar e gasoduto Instrução são muito bons.

Outras dicas

Um longo tempo atrás, CPUs executado apenas uma instrução máquina de cada vez . Só quando foi totalmente concluído que o CPU buscar a próxima instrução da memória (ou, mais tarde, o cache de instrução).

Por fim, alguém percebeu que isso significava que mais de uma CPU não fez nada maior parte do tempo, uma vez que havia várias subunidades de execução (como o decodificador de instrução, a unidade aritmética inteira e unidade aritmética FP, etc.) e execução uma instrução mantido apenas um deles ocupado por vez.

Assim, " simples " pipelining nasceu: uma vez que uma instrução foi feito decodificação e passou para a subunidade execução seguinte, por que não já buscar e decodificar a próxima instrução ? Se você tivesse 10 tais " etapas ", então por tendo cada processo estágio uma instrução diferente você poderia, teoricamente, aumentar a instrução de transferência dez vezes sem aumentar o clock do processador em tudo! Claro, isso só funciona perfeitamente quando não há saltos condicionais no código (isso levou a uma grande quantidade de esforço extra para lidar com saltos condicionais especialmente).

Mais tarde, com a lei de Moore continua a ser correto por mais tempo do que o esperado, os fabricantes de CPU encontraram-se com cada vez mais transistores para fazer uso de e pensei "por que apenas um de cada subunidade de execução?". Assim, superscalar CPUs com várias subunidades de execução capaz de fazer o mesma coisa em paralelo nasceram, e os projetos de CPU se tornou muito, muito mais complexo para distribuir instruções através destas unidades totalmente paralelas, garantindo os resultados foram os mesmos que se as instruções foram executadas sequencialmente.

Uma analogia: Roupa de lavagem

Imagine uma loja de limpeza a seco com os seguintes instalações:. Uma cremalheira para pendurar sujo ou roupas limpas, uma máquina de lavar e um secador (cada um dos quais pode lavar uma peça de cada vez), uma mesa dobrável, e uma tábua de engomar

O atendente que faz todo o lavagem real e secagem é bastante estúpido para que o dono da loja, que leva as ordens de limpeza a seco, tem um cuidado especial para escrever cada instrução com muito cuidado e de forma explícita.

Em um dia típico destas instruções pode ser algo ao longo das linhas de:

tomar a camisa da cremalheira
lavar a camisa
secar a camisa
ferro camisa
dobre a camisa
colocar a camisa de volta na prateleira
tirar as calças do rack
lavar as calças
secar as calças
dobrar as calças
colocar as calças de volta na prateleira
levar o casaco do rack
lavar o revestimento
secar o casaco
ferro o casaco
colocar a volta casaco na prateleira

O atendente segue estas instruções para o tee, sendo muito cuidado para não nunca fazer qualquer coisa fora de ordem. Como você pode imaginar, é preciso um longo tempo para obter lavanderia do dia feito porque leva muito tempo para lavar totalmente, seca e dobra cada peça de roupa, e tudo deve ser feito um de cada vez.

No entanto, um dia os quites atendente e um novo, mais inteligente, atendente é contratado que percebe que a maioria dos equipamentos está colocando ocioso a qualquer momento durante o dia. Enquanto as calças estavam secando nem a tábua de passar roupa, nem a máquina de lavar estavam em uso. Então ele decidiu fazer melhor uso do seu tempo. Assim, em vez da série acima das etapas, ele faria isso:

tomar a camisa da cremalheira
lavar a camisa, tirar as calças do rack
secar a camisa, lavar as calças
ferro a camisa, secar as calças
dobre a camisa, (pegue o casaco do rack)
colocar a camisa de volta na prateleira, dobrar as calças , (lavar o casaco)
colocar as calças de volta na prateleira , (secar o casaco)
(ferro o brasão)
(colocar a parte de trás casaco no rack)

Esta é pipelining. sequenciamento atividades não relacionadas de tal forma que eles usam componentes diferentes ao mesmo tempo. Ao manter o máximo dos diferentes componentes ativos ao mesmo tempo que você maximizar a eficiência e acelerar o tempo de execução, neste caso a redução de 16 "ciclos" a 9, um aumento de velocidade de mais de 40%.

Agora, a loja de limpeza pouco seco começou a ganhar mais dinheiro, porque eles poderiam trabalhar muito mais rápido, de modo que o proprietário comprou uma máquina de lavar extra, secador de cabelo, tábua de engomar, dobrar estação, e até contratou outro atendente. Agora as coisas são ainda mais rápido, em vez do acima, você tem:

tomar a camisa do rack, tirar as calças do rack
lavar a camisa, lavar as calças , (pegue o casaco do rack)
secar a camisa, secar as calças , (lavar o casaco)
ferro a camisa, dobrar as calças , (secar o revestimento)
dobre a camisa, colocar as calças de volta na prateleira , (ferro o brasão)
colocar a camisa de volta na prateleira, (colocar a parte de trás casaco no rack)

Este é projeto superscalar. Vários sub-componentes capazes de fazer a mesma tarefa simultaneamente, mas com o processador de decidir como fazê-lo. Neste caso, resultou em um aumento de velocidade de cerca de 50% (em 18 "ciclos" a nova arquitectura podia correr através de 3 iterações deste "programa", enquanto a arquitectura anterior só poderia funcionar através de dois).

processadores mais antigos, como o 386 ou 486, são processadores escalares simples, eles executar uma instrução de cada vez exatamente na ordem em que foi recebido. Os processadores modernos de consumo since o PowerPC / Pentium estão em pipeline e superscalar. A Core2 CPU é capaz de executar o mesmo código que foi compilado para um 486 e ainda tirar proveito do nível de instrução paralelismo porque contém sua própria lógica interna que analisa o código de máquina e determina como para reordenar e executá-lo (o que pode ser executado em paralelo , o que não pode, etc.) Esta é a essência do design superscalar e por que é tão prático.

Em contraste, um vector paralelo operações executa processadores em vários pedaços de dados de uma só vez (um vector). Assim, em vez de apenas adicionar x e y um processador vector acrescentaria, digamos, x0, x1, x2 para y0, y1, y2 (resultando em z0, Z1, Z2). O problema com este projeto é que ele está intimamente ligado ao grau específico de paralelismo do processador. Se você executar o código escalar em um processador vectorial (supondo que você poderia) você veria nenhuma vantagem da paralelização vector porque ele precisa ser usado de forma explícita, da mesma forma, se você quisesse tirar proveito de um processador mais novo vector com unidades de processamento mais paralelas (por exemplo, capaz de agregar vetores de 12 números em vez de apenas 3) você precisa de recompilar seu código. designs de processadores Vector eram populares na geração mais antiga de super computadores, porque eles eram fáceis de desenhar e há grandes classes de problemas em ciência e engenharia, com uma grande quantidade de paralelismo natural.

processadores superescalares também pode ter a capacidade de executar execução especulativa. Em vez de deixar o processamento unidades ocioso e esperando por um caminho de código para concluir a execução antes de ramificar um processador pode fazer uma melhor suposição e iniciar a execução de código passado o ramo antes do código anterior tem o processamento final. Quando a execução do código antes alcança o ponto de ramificação do processador pode então comparar o ramo real com o palpite ramo e quer continuar se o palpite estava correto (já bem à frente de onde ele teria sido por apenas à espera) ou pode invalidar os resultados da execução especulativa e executar o código para o ramo correto.

Pipelining é o que uma companhia de carro faz na fabricação de seus carros. Eles quebram o processo de montar um carro em etapas e executar os diferentes estágios em diferentes pontos ao longo de uma linha de montagem feito por pessoas diferentes. O resultado líquido é que o carro é fabricado exatamente na velocidade de sozinho o estágio mais lento.

Em CPUs o processo de pipelining é exatamente o mesmo. Uma "instrução" é dividido em vários estágios de execução, geralmente algo como 1. buscar instrução, 2. buscar operandos (registos ou valores de memória que são lidos), 2. realizar computação, 3. Resultados de gravação (para a memória ou registos) . O mais lento de esta pode ser a parte de computação, caso em que a velocidade geral de transferência das instruções através deste gasoduto é apenas a velocidade da parte computação (como se as outras partes foram "livre".)

Super-escalar em microprocessadores refere-se à capacidade de executar várias instruções de um único fluxo de execução ao mesmo tempo em paralelo. Então, se uma companhia de carro correu duas linhas de montagem então, obviamente, eles poderiam produzir duas vezes mais carros. Mas se o processo de colocar um número de série do carro estava na última fase e teve que ser feito por uma única pessoa, então eles teriam que se alternam entre os dois dutos e garantia de que eles poderiam conseguir cada feito na metade do tempo de o estágio mais lento, a fim de evitar tornar-se o estágio mais lento si mesmos.

Super-escalar em microprocessadores é semelhante, mas geralmente tem muito mais restrições. Assim, a busca de instrução fase produzirá normalmente mais de uma instrução durante a sua fase - é isso que torna super-escalar em microprocessadores possíveis. Haveria, então, dois buscar estágios, duas etapas de execução, e dois estágios escrever de volta. Isto, obviamente, se generaliza para mais do que apenas dois gasodutos.

Isto é tudo muito bem e dândi, mas a partir da perspectiva da execução de som ambas as técnicas poderia levar a problemas se feito cegamente. Para correta execução de um programa, presume-se que as instruções são executadas completamente um após o outro em ordem. Se duas instruções sequenciais têm cálculos inter-dependentes ou usam os mesmos registros, em seguida, pode haver um problema, As necessidades de instrução mais tarde para esperar a gravação de trás da instrução anterior para completar antes que ele possa realizar o operando buscar palco. Assim, você precisa parar a segunda instrução por dois estágios antes de ser executado, o que vai contra o propósito do que foi adquirida por estas técnicas em primeiro lugar.

Existem muitas técnicas usar para reduzir o problema da necessidade de tenda que são um pouco complicada para descrever, mas vou enumerá-los: o encaminhamento 1. Registo, (também armazenar para o encaminhamento de carga) 2. renomeação de registradores, 3. Scoreboard embarque, 4. execução fora-de-ordem. 5. execução especulativa com reversão (e reforma) Todos os processadores modernos usar praticamente todas estas técnicas para implementar super-escalar e pipelining. No entanto, estas técnicas tendem a ter retornos decrescentes em relação ao número de pipelines em um processador antes de barracas tornou inevitável. Na prática, nenhum fabricante CPU faz mais de 4 pipelines em um único núcleo.

Multi-core não tem nada a ver com qualquer uma destas técnicas. Esta é, basicamente, batendo dois micro-processadores juntos para implementar o multiprocessamento simétrico em um único chip e partilha apenas os componentes que fazem sentido para ação (normalmente L3 cache, e I / O). No entanto, uma técnica que a Intel chama de "hyperthreading" é um método de tentar implementar praticamente a semântica de multi-core no âmbito super-escalar de um único núcleo. Assim, um único micro-arquitetura contém os registros de duas (ou mais) núcleos virtuais e busca instruções de duas (ou mais) fluxos de execução diferentes, mas a execução de um sistema de super-escalar comum. A ideia é que, porque os registros não podem interferir uns com os outros, haverátendem a ser mais paralelismo levando a menos tendas. Então, ao invés de simplesmente executar dois execução virtual core córregos na metade da velocidade, é melhor devido à redução global em baias. Isso parece sugerir que a Intel poderia aumentar o número de pipelines. No entanto, esta técnica tem sido encontrado para ser um pouco falta de implementações práticas. Como ele é parte integrante de técnicas de super-escalar, porém, eu ter mencionado isso de qualquer maneira.

Pipelining é a execução simultânea de diferentes estágios de múltiplas instruções ao mesmo ciclo. Baseia-se no processamento de instruções dividindo-se em fases e tendo unidades para cada fase e registos especializada para armazenar os resultados intermédios.

Superscaling está despachando múltiplas instruções (ou microinstruções) para múltiplas unidades executoras existentes na CPU. Baseia-se, assim, em unidades redundantes na CPU.

Claro, isso abordagens podem complementar-se.

Licenciado em: CC-BY-SA com atribuição

Não afiliado a StackOverflow