Embed Size (px)
Citation preview
Multiprocessamento Simétrico
Sistema Distribuído
Multinúcleo
Thread
Multitarefa
Sumário
Multiprocessamento Simétrico ......................................................................... 4
Funcionamento ........................................................................................... 4
Gerenciamento ........................................................................................... 5
Vantagens ................................................................................................. 5
Tecnologias ................................................................................................ 5
Sistema de processamento distribuído.............................................................. 6
Desenvolvimento ........................................................................................ 6
Arquitetura ................................................................................................ 7
Soluções .................................................................................................... 7
Multinúcleo ................................................................................................... 7
Descrição ................................................................................................... 8
Surgimento ................................................................................................ 8
Incentivos Comerciais ................................................................................. 9
Vantagens ................................................................................................. 9
Desvantagens ............................................................................................ 9
Arquitetura ............................................................................................... 10
Exemplos de Hardware ............................................................................... 10
Futuro da Tecnologia Multicore .................................................................... 11
Thread ........................................................................................................ 12
Exemplo ................................................................................................... 12
Particularidades ......................................................................................... 12
Estados de uma linha de execução ............................................................... 13
ULT e KLT ................................................................................................. 13
Criar (thread creation) ............................................................................. 14
Terminar (thread termination) .................................................................. 15
Sincronizar(Thread Join) .......................................................................... 15
Thread Yield (Rendimento da thread) ........................................................ 15
Escalonamento .......................................................................................... 16
Linha de execução ao nível do usuário ....................................................... 16
Linha de execução ao nível do núcleo ........................................................ 16
Comparação entre linha de execução e Processo ............................................ 17
Modelo de Geração de Multithreads .............................................................. 18
Modelo Muitos-Para-Um ........................................................................... 18
Modelo Um-Para-Um ............................................................................... 18
Modelo Muitos-Para-Muitos ....................................................................... 18
Cancelamento ........................................................................................... 18
Exemplos .................................................................................................. 18
Java ...................................................................................................... 18
Java, exemplo simples em português ........................................................ 20
C .......................................................................................................... 22
C++ ...................................................................................................... 22
Ruby ..................................................................................................... 23
Delphi.................................................................................................... 23
Multitarefa ................................................................................................... 26
História .................................................................................................... 26
Tarefas ..................................................................................................... 27
Alternância de tarefas ................................................................................ 27
No Mundo das Placas-mãe para PCs ................................................................ 27
As melhores marcas ................................................................................... 29
Placas-mãe multi CPUs ............................................................................... 29
Placas-mãe multi CPUs/GPUs ...................................................................... 30
Componentes integrados nas placas-mãe ..................................................... 30
Os tipos de placas-mãe .............................................................................. 31
Os Fabricantes e Marcas de placas-mãe ........................................................ 31
As melhores marcas – Quais são elas? ......................................................... 31
Os fabricantes de placas-mãe – Quais são? ................................................... 32
Os fabricantes de hardware – Quais são? ...................................................... 32
Tecnologia SMP (Symmetric Mult Processing) ................................................ 32
Alguns termos técnicos usados .................................................................... 33
4
Multiprocessamento Simétrico O multiprocessamento simétrico ou SMP (Symmetric Multi-Processing) ocorre em
um sistema computacional com vários processadores com memória compartilhada
sob controle de um único sistema operacional. Em contraste o multiprocessamento
assimétrico emprega sistemas diferentes.
O multiprocessamento simétrico oferece um aumento linear na capacidade de
processamento a cada processador adicionado. Não há necessariamente um
hardware que controle este recurso, cabe ao próprio sistema operacional suportá-
lo.
Este método também é chamado de "processamento paralelo".
Funcionamento Os processadores trabalham sozinhos compartilhando os recursos de hardware,
geralmente são processadores iguais, similares ou com capacidades parecidas.
Todos tem os mesmos privilégios de acesso ao hardware, ao contrário do que
acontece em sistemas multiprocessados assimétricos, onde um processador é
encarregado de gerenciar e coordenar as tarefas e ações dos demais, o que pode
proporcionar melhor controle sobre a sobrecarga ou a ociosidade dos processadores
subordinados. Por tratar todos os processadores de forma igualitária, no
multiprocessamento simétrico, qualquer processador pode assumir as tarefas
realizadas por qualquer outro processador, as tarefas são divididas e também
podem ser executadas de modo concorrente em qualquer processador que esteja
disponível. Os acessos dos processadores aos dispositivos de entrada e saída e a
memória são feitos por um mecanismo de intercomunicação constituído por um
barramento único.
A memória principal da máquina é compartilhada por todos os processadores
através de um único barramento que os interliga, de modo que esse acesso a
memória é nativo, não existe a necessidade de um mascaramento da memória real
a nível de aplicação. Por todo acesso à memória principal ser realizado através de
um único barramento, aqui temos um ponto de gargalo do sistema, pois o acesso é
serial, ou seja, o sistema fica limitado a passagem de apenas uma instrução de
cada vez pelo barramento, abrindo uma lacuna de tempo entre uma instrução e
outra. Memórias caches junto aos processadores diminuem o tempo de latência
entre um acesso e outro à memória principal e ajudam também a diminuir o
tráfego no barramento. Como estamos falando em mais de um processador, cada
um com sua memória cache é imprescindível garantir que os processadores sempre
acessem a cópia mais recente da memória cache, isso se chama coerência de cache
geralmente implementada diretamente por hardware. Um dos métodos de
coerência de cache mais conhecido é o snooping, quando um dado compartilhado
nas caches dos processadores é alterado, todas as cópias das caches são
consideradas inválidas e logo após atualizadas mantendo assim a integridade do
dado.
5
Gerenciamento O sistema operacional é quem se encarrega de realizar a interação entre os
processadores e as aplicações do sistema. Deixando a existência de múltiplos
processadores transparente para os usuários, pois o próprio sincroniza os processos
com os processadores.
Mesmo as arquiteturas de SMP já existirem há muitos anos no mercado, até pouco
tempo os sistemas não tinham uma padronização para as funções básicas de
operação, cada sistema implementava suas próprias funções. O que tornava
impossível que os sistemas operacionais fossem portáveis. A partir dessa
necessidade foi criada a MPS (Específicações da Intel para Multiprocessadores ou do
inglês - Intel's Multiprocessor Specification), com o objetivo de padronizar o
desenvolvimento de SOs que suportassem essas arquiteturas. A criação da MPS fez
com que a Intel saísse na frente no desenvolvimento da tecnologia multicore.
Vantagens Sistemas de multiprocessamento simétrico são considerados mais poderosos em
relação aos de multiprocessamento assimétricos, abaixo alguns descritivos de
comparação entre eles.
No multiprocessamento simétrico muitos processos podem ser executados ao
mesmo tempo sem queda no desempenho, pois o sistema operacional delega as
instruções a cada processador;
Se um processador falhar o sistema não tranca pois qualquer outro processador
pode assumir as tarefas daquele que falhou, já no assimétrico por exemplo, se o
processador mestre falhar o sistema trava;
No SMP o usuário pode melhorar o desempenho da máquina simplesmente
adicionando um processador.
Tecnologias Antigamente para utilizar SMP era necessário hardware específico, placas-mãe com
dois ou mais soquetes de CPU, grandes estruturas de servidores clusterizados. Hoje
em dia com a tecnologia multi-core, as fabricantes já integram tudo isso em apenas
um dispositivo físico, também conhecidos como processadores multi-core.
Alguns exemplos de processadores multi-core:
Intel Xeon;
Intel Core (2,2 Duo,i3,i5,i7)
Intel Pentium D;
Intel Itanium;
AMD Athlon 64 ou X2;
Opteron 200 e 2000 processadores da série;
UltraSPARC da Sun Microsystems;
Fujitsu SPARC64 III;
Hewlett Packard PA-RISC;
6
IBM POWER;
PowerPC Apple Computer(G4 e séries G5);
Sistema de processamento distribuído Um sistema de processamento distribuído ou paralelo é um sistema que interliga
vários nós de processamento (computadores individuais, não necessariamente
homogéneos) de maneira que um processo de grande consumo seja executado no
nó "mais disponível", ou mesmo subdividido por vários nós. Conseguindo-se,
portanto, ganhos óbvios nestas soluções: uma tarefa qualquer, se divisível em
várias subtarefas pode ser realizada em paralelo.
A nomenclatura geralmente utilizada neste contexto é HPC (High Performance
Computing) e/ou DPC (Distributed/Parallel Computing).
Desenvolvimento Este é um assunto muito vasto e, embora com alguma idade, só em 2001 se
começou a falar em padrões para estas soluções, que são utilizadas (em larga
escala) geralmente nos meios científicos e outros de cálculo intensivo pela sua
extensibilidade. São bastante flexíveis, já que permitem a coexistência de sistemas
desenhados especificamente para isso (por exemplo, a arquitectura NUMA), de
sistemas desktop, e mesmo de sistemas considerados obsoletos, mas não o
suficiente para permitir a coexistência de soluções semelhantes.
7
Antes de avançar, será necessário distinguir um sistema de multiprocessamento
paralelo (SMP) de um sistema distribuído. Para um sistema ser de processamento
distribuído, uma ou várias unidades de processamento (CPU) estará separada
fisicamente da(s) outra(s), enquanto que num sistema SMP todas as unidades de
processamento se encontram na mesma máquina. Ambos sistemas são capazes de
processamento paralelo, e qualquer um deles pode ser visto como elemento de um
sistema distribuído!
Com os desenvolvimentos nesta área, surgiram soluções por software que fazem,
geralmente (mas não necessariamente), alterações no núcleo do sistema operativo
e que, na maioria dos casos, não são compatíveis entre elas, e dificilmente entre
versões diferentes da mesma solução. Assentam, no entanto, em arquitecturas de
comunicação padrão, como é o caso da Parallel Virtual Machine e Message Passing
Interface. Resumidamente, estas arquitecturas conseguem transportar um processo
(tarefa) e o seu contexto (ficheiros abertos, etc.) pela rede até outro nó. O nó que
originou o processo passa, assim, a ser apenas um receptor dos resultados desse
processo.
Atualmente, a principal barreira destes sistemas é implementar mecanismos de
Inter-Process Communication (IPC), os Distributed IPC, dada a sua extrema
complexidade.
Arquitetura A Figura 1 ilustra as várias camadas de interoperabilidade de um sistema
distribuído. Através do gateway a rede pública tem acesso a um supercomputador,
sem ter conhecimento disso, dado que só conhece o gateway. Qualquer aplicação
executada no gateway (preparada para ser paralelizada) pode ser distribuída por
vários nós, entregando os resultados mais rápido do que se fosse processada por
apenas um nó.
Soluções Software
Scyld (Beowulf)
openMosix
openSSI
Open Source Cluster Application Resources (OSCAR)
Multinúcleo Multinúcleo (múltiplos núcleos, do inglês multicore) consiste em colocar dois ou
mais núcleos de processamento (cores) no interior de um único chip. Estes dois ou
mais núcleos são responsáveis por dividir as tarefas entre si, ou seja, permitem
trabalhar em um ambiente multitarefa. Em processadores de um só núcleo, as
funções de multitarefa podem ultrapassar a capacidade da CPU, o que resulta em
queda no desempenho enquanto as operações aguardam para serem processadas.
Em processadores de múltiplos núcleos o sistema operacional trata cada um desses
núcleos como um processador diferente. Na maioria dos casos, cada unidade possui
seu próprio cache e pode processar várias instruções simultaneamente. Adicionar
8
novos núcleos de processamento a um processador (único encapsulamento)
possibilita que as instruções das aplicações sejam executadas em paralelo, como se
fossem 2 ou mais processadores distintos.
Os dois núcleos não somam a capacidade de processamento, mas dividem as
tarefas entre si. Por exemplo, um processador de dois núcleos com clock de 1.8
GHz não equivale a um processador de um núcleo funcionando com clock de 3.6
Ghz, e sim dois núcleos 1,8GHZ operando em paralelo. O termo multinúcleo ou
multicore (como é popularmente conhecido), são por vezes utilizados para
descrever arquiteturas multicore com um número particularmente elevado de
núcleos (dezenas ou centenas).
O surgimento dos processadores multicore, tornou-se necessário principalmente
devido a missão cada vez mais difícil de resfriar processadores singlecore
(processadores de apenas um núcleo) com clocks cada vez mais altos; devido a
concentração cada vez maior de transistores cada vez menores em um mesmo
circuito integrado. E além dessa e outras limitações dos processadores singlecore,
existe a grande diferença entre a velocidade da memória e do processador, aliada à
estreita banda de dados, que faz com que aproximadamente 75 por cento do uso
do microprocessador seja gasto na espera por resultados dos acessos à memória.
Descrição Na maioria dos processadores de mais de um núcleo, cada núcleo pode possuir sua
própria cache e alguns casos realizam acesso direto e independente à memória
principal; possibilita-se, assim, que as instruções de aplicações sejam executadas
em paralelo, ou seja, cada processador realiza os cálculos de que é requisitado
concorrentemente com o outro, ganhando desempenho. Este, porém, depende
muito dos algoritmos de software utilizados e de suas implementações.
Outra vantagem do processamento em paralelo é a capacidade de cada
processador ficar responsável pela execução de um aplicativo, como por exemplo,
quando o usuário está executando algum arquivo de som e ao mesmo tempo
executando a varredura do antivírus.
A diferença desse processamento paralelo e do até então usado nos processadores
singlecore pode ser visto nas figuras abaixo; observe o gargalo (bottleneck) criado
pelos aplicativos executados simultaneamente no singlecore, e como ele
desaparece na figura com os dois núcleos (cores).
Surgimento Embora a tecnologia de fabricação tenha melhorado, reduzindo o tamanho de
processadores individuais, limites físicos de semicondutores baseados em
microeletrônica haviam se tornado uma preocupação principal. Estas limitações
físicas poderiam causar dissipação de calor significativa e problemas de
sincronização de dados. Vários métodos foram e estão sendo usados para melhorar
o desempenho da CPU. Alguns paralelismos por nível de instrução (ILP), métodos
como pipelining superescalares são adequados para muitas aplicações, mas são
ineficientes para os que são difíceis de prever código. Muitas aplicações são mais
adequadas para paralelismo por nível de thread (TLP), métodos e múltiplas CPUs
independentes são comumente usados para aumentar a TLP geral de um sistema.
Uma combinação de espaço disponível aumentou (devido a processos de fabricação
9
refinados) e a demanda por TLP aumento e levou ao desenvolvimento de CPUs
multi-core.
Incentivos Comerciais Vários negócios impulsionaram o desenvolvimento da arquitetura multicore.
Durante décadas, foi possível melhorar o desempenho de uma CPU, reduzindo a
área do circuito integrado, que diminuiu o custo por dispositivo. Como alternativa,
mais transistores poderiam ser utilizados no projeto, o que aumentou a
funcionalidade, especialmente para as arquiteturas CISC. Eventualmente, estas
técnicas atingiram o seu limite e não puderam continuar a melhorar o desempenho
da CPU. Múltiplos processadores tiveram que ser empregados para ganhar
velocidade no processamento. Vários núcleos foram usados no mesmo chip para
melhorar o desempenho, o que poderia então levar a melhores vendas de CPUs que
tinham dois ou mais núcleos.
Vantagens Uma das principais vantagens dos processadores multicore é também um dos
principais motivos da sua invenção. Essa vantagem é a sua maior capacidade -
comparado aos singlecores - de resfriamento; o que ainda possibilitou e ainda
possibilita o aumento do poder de processamento dos processadores.
Economia no preço de licenciamento de softwares proprietários, passando a ter um
maior poder de processamento sem necessitar de uma nova máquina.
Processadores multicore também permitem maior desempenho com menor energia.
Isso pode ser um fator importante em dispositivos móveis que funcionam com
baterias. Uma vez que cada núcleo em multicore é geralmente mais eficiente em
termos energéticos, o chip se torna mais eficiente do que ter um grande núcleo
único e monolítico.
As outras vantagens quase que por completo relacionam-se com a capacidade de
processamento, principalmente quando se trata da execução de mais de um
aplicativo ao mesmo tempo ou mesmo e aplicativos capazes de realizar o seu
processamento paralelamente, conseguindo assim trabalhar com dois ou mais
núcleos concomitantemente. Nos processadores mais recentemente desenvolvidos
existe também uma melhora no acesso a memória e na troca de dados entre os
próprios núcleos.
Porém, é importante destacar também que para que a qualidade de processamento
paralelo dos multicores seja utilizada na sua totalidade os softwares instalados na
máquina devem ser escritos para aproveitar esse recurso; para isso as aplicações
devem ser escritas utilizando e armazenando os conceitos de threads, assim uma
única aplicação utilizará o poder de processamentos dos dois ou mais
processadores.
Desvantagens Processadores multicore possuem um bom desempenho, performance,
disponibilidade e segurança a um menor custo. Por outro lado, esta tecnologia
possui algumas desvantagens, entre as principais podemos destacar:
10
O aumento da utilização dos recursos computacionais fornecidos por processadores
multicore requerem ajustes, tanto para o sistema operacional de apoio quanto para
o software aplicativo já existente.
A capacidade dos processadores multicore depende da utilização de vários
segmentos dentro das aplicações para aumentar o desempenho da aplicação.
Arquitetura Com o surgimento dos multicores tornou-se necessário algumas adaptações a nível
de arquitetura para o melhor aproveitamento dos seus núcleos, e as primeiras a
serem feitas tem como objetivo melhorar o paralelismo a nível de threads e assim
criar uma arquitetura que propicie o chamado paralelismo ao nível do chip.
Algumas vantagens da arquitetura são: a melhor localização dos dados em se
comparando com outras arquiteturas de multiprocessamento; a melhor
comunicação entre as unidades e o número reduzido de quantidade de espaço e
energia necessários.
A arquitetura é geralmente um SMP, ou seja, um multiprocessamento simétrico;
implementado em um circuito VLSI - Very Large Scale Integration. Essa é uma
arquitetura onde dois ou mais processadores idênticos são ligados a uma única
memória principal. Porém ao SMP existem outras alternativas de se criar uma
arquitetura com variantes para o tratamento da memória ou até mesmo a
comunicação entre os diversos núcleos presentes no processador. Algumas dessas
variantes podem ser observadas nos artigos abaixo:
Arquitetura Intel Core2
Arquitetura AMD Athlon 64 X2
Exemplos de Hardware Segue abaixo alguns exemplos de hardware que utilizam a tecnologia multi-core.
Comercial
AMD
Athlon 64, Athlon 64 FX e Athlon 64 X2, processadores AMD Athlon™ para
desktops.
Athlon II, processador AMD Athlon™ II Dual-Core para desktops.
Phenom, processador AMD Phenom™ X4 de quatro núcleos e AMD Phenom™
X3 de três núcleos para desktops.
Phenom II, processador multi-core. Oferece uma melhor experiência visual
para entretenimento de alta definição, desempenho avançado em
multitarefa e inovações de economia de energia, proporcionando máquinas
menores e mais refrigeradas, com uso eficiente da energia.
Sempron, processador AMD Sempron™ para desktops.
Turion 64 X2, processador dual-core para laptop.
Opteron, processador para servidores.
IBM
POWER5, processador dual-core, lançado em 2004.
11
POWER6, processador dual-core, lançado em 2007.
POWER7, processadores 4,6,8-core, lançados em 2010.
PowerPC 970MP, processador dual-core usado na Apple Power Mac G5.
Xenon, processador triple-core, usado pela Microsoft no Xbox 360.
Intel
Celeron Dual-Core, primeiro processador dual-core comercializado.
Core Duo, processador dual-core.
Core 2 Duo, processador dual-core.
Core 2 Quad, 2 processadores dual-core embutido em um multi-chip.
Core i3, Core i5 e Core i7, família de processadores multi-core. São os
sucessores do Core 2 Duo e do Core 2 Quad.
Itanium 2, processador dual-core.
Pentium D, 2 single-core embutido em um multi-chip.
Pentium Extreme Edition, 2 single-core embutido em um multi-chip.
Pentium Dual-Core, processador dual-core.
Xeon processadores dual-, quad-, hexa-, octo- e 12-core.
Nvidia
GeForce 9 Series multi-core, a Unidade de processamento gráfico possui 8
cores e 16 Scalar processor/Stream processing por core.
GeForce 200 Series multi-core, a Unidade de processamento gráfico possui
10 cores e 24 Scalar processor/Stream processing por core.
Tesla multi-core, a GPGPU possui 10 cores e 24 Scalar processor/Stream
processing por core.
Free
OpenSPARC
Futuro da Tecnologia Multicore O MIT, Instituto de Tecnologia de Massachusetts, anunciou um processador com 64
núcleos, cujo design difere drasticamente dos processadores existentes hoje1 . O
novo chip, chamado Tile64, evita o que é hoje o maior gargalo no desempenho dos
processadores multicores e ele consome menos energia.
Nos processadores multicores existentes hoje, cada núcleo se comunica com o
outro através de um barramento comum. Se pensarmos em dois ou quatro núcleos
dividindo um barramento, a performance não é muito afetada. Quando pensamos
em 16 ou mais núcleos sendo usados ao mesmo tempo, a historia é completamente
diferente. Este é o maior gargalo no desempenho dos processadores multicores.
O Tile64 não possui um barramento central. Ao invés disso, os núcleos estão
diretamente conectados. Cada núcleo possui todas as característica de um
processador e memória. O novo conceito aplicado nesses processadores é a
estrutura de malha na conexão entre os núcleos. Essa estrutura é similar à
encontrada na Internet, uma rede que possui vários nós descentralizados. Uma
razão que faz a Internet capaz de transmitir dado tão rapidamente é que os
pacotes de informação são enviados através de uma vasta rede interligada,
evitando assim o congestionamento desses pacotes. Essa nova arquitetura abre
12
portas para que novos processadores recebam números cada vez maiores de
núcleos. A existência de um número tão grande de cores, começa a requerer a
utilização de um esquema de manipulação próximo a grades computacionais.
Thread Linha ou Encadeamento de execução (em inglês: Thread), é uma forma de um
processo dividir a si mesmo em duas ou mais tarefas que podem ser executadas
concorrentemente. O suporte à thread é fornecido pelo próprio sistema operacional,
no caso da linha de execução ao nível do núcleo (em inglês: Kernel-Level Thread
(KLT)), ou implementada através de uma biblioteca de uma determinada
linguagem, no caso de uma User-Level Thread (ULT).
Uma thread permite, por exemplo, que o usuário de um programa utilize uma
funcionalidade do ambiente enquanto outras linhas de execução realizam outros
cálculos e operações.
Em hardwares equipados com uma única CPU, cada thread é processada de forma
aparentemente simultânea, pois a mudança entre uma thread e outra é feita de
forma tão rápida que para o utilizador isso está acontecendo paralelamente. Em
hardwares com múltiplos CPUs ou multi-cores, as threads são realizadas realmente
de forma simultânea;
Os sistemas que suportam apenas uma única thread (em real execução) são
chamados de monothread enquanto que os sistemas que suportam múltiplas
threads são chamados de multithread.
Exemplo Um exemplo simples pode ser expressado através de um jogo onde o mesmo pode
ser modelado com linhas de execução diferentes, sendo uma para desenho de
imagem e outra para áudio; Neste caso, há um thread para tratar rotinas de
desenho e outro thread para tratar áudio; No ponto de vista do usuário, a imagem
é desenhada ao mesmo tempo em que o áudio é emitido pelos alto-falantes;
Porém, para sistemas com uma única CPU, cada linha de execução é processada
por vez;
Particularidades Cada thread tem o mesmo contexto de software e compartilha o mesmo espaço de
memória (endereçado a um mesmo processo-pai), porém o contexto de hardware é
diferente. Sendo assim o overhead causado pelo escalonamento de uma thread é
muito menor do que o escalonamento de processos. Entretanto não há acesso
protegido à memória nativa (sua implementação fica a cargo do programador)
devido ao compartilhamento do espaço de memória.
Um dos benefícios do uso das threads advém do facto do processo poder ser
dividido em várias threads; quando uma thread está à espera de determinado
dispositivo de entrada/saída ou qualquer outro recurso do sistema, o processo
como um todo não fica parado, pois quando uma thread entra no estado de
'bloqueio', uma outra thread aguarda na fila de prontos para executar.
13
Uma thread possui um conjunto de comportamentos padrão, normalmente
encontrados em qualquer implementação ou sistema operativo.
Uma thread pode:
criar outra da mesma forma que um processo, através do método thread-
create, onde a thread retorna um ID como primeiro argumento (resultado
da função de criação);
esperar outra thread se sincronizar, através do método join;
voluntariamente "desistir" da CPU por não precisar mais do processamento
proposto pela própria ou por vontade do utilizador. Feito através do método
thread-yield;
replicar-se sem a necessidade de duplicar todo o processo, economizando
assim memória, processamento da CPU e aproveitando o contexto
(variáveis, descritores, dispositivos de I/O).
Estados de uma linha de execução Uma thread pode assumir os seguintes estados:
Unstarted: logo após ser criada (antes do Start());
Running: após ser ativada (Start()) ou após método Resume();
Suspended: após método Suspended();
Stopped: após método Abort().
ULT e KLT Usualmente as threads são divididas em duas categorias: thread ao nível do
utilizador (em inglês: User-Level Thread (ULT)), e thread ao nível do núcleo (em
inglês: Kernel-Level Thread (KLT)).
Thread em modo usuário
Thread em modo kernel
14
As threads da primeira categoria (ULT) são suportadas pela aplicação, sem
conhecimento do núcleo e geralmente são implementadas por pacotes de rotinas
(códigos para criar, terminar, escalonamento e armazenar contexto) fornecidas por
uma determinada biblioteca de uma linguagem, como é o caso da thread.h
(biblioteca padrão da linguagem C). Estas threads suportam as mesmas operações
que as threads KLT (criar, sincronizar, duplicar e abortar). Possuem como
vantagens a possibilidade de implementação em sistemas operativos que não
suportam nativamente este recurso, sendo geralmente mais rápidas e eficientes
pois dispensam o acesso ao núcleo. Evita assim mudança no modo de acesso, e a
estrutura de dados fica no espaço do utilizador, levando a uma significativa queda
de overhead, além de poder escolher entre as diversas formas de escalonamento
em que melhor se adequa.
A gestão da thread (KLT) não é realizada através do código do próprio programa;
todo o processo é subsidiado pelo SO. Esse modelo tem a vantagem de permitir o
suporte a multiprocessamento e o facto do bloqueio de uma linha de execução não
acarretar bloqueio de todo processo, não obstante, temos a desvantagem de ter
que mudar o tipo de acesso sempre que o escalonamento for necessário,
aumentando assim o tão temido overhead.
Há quatro operações básicas na gestão de threads: criar, terminar, thread join e
thread yield.
Criar (thread creation)
Basicamente uma thread pode criar outra(s), sendo que depois essas mesmas
threads são executas 'simultaneamente'. A thread criadora é a thread-mãe e a
thread criada é a thread-filho. Threads incluídas na função main quando executadas
podem criar threads-filho. No diagrama a seguir há a thread A que executa
inicialmente. Mais tarde é criada a thread B indicada no ponto amarelo. Depois de
criadas, a thread A e thread B executam simultaneamente. Em seguida a thread A
pode criar uma ou mais threads (por exemplo uma thread C). Depois de criada a
15
thread C, há três threads executando simultaneamente e todas disputam o uso da
CPU. Entretanto, a thread que pode ser executada a qualquer momento não é de
conhecimento da CPU.
Terminar (thread termination)
Para maioria dos casos, as threads não são criadas e executadas eternamente.
Depois de terminado o seu objectivo, a thread termina. No facto, a thread que criou
estas duas threads-filho termina também, porque sua tarefa atribuída se completa.
Na matrix de multiplicação (matrix multiplication), uma vez que o valor de C[i,j] é
computado, a thread correspondente termina. Em geral quando a tarefa atribuída a
thread completa, a thread pode ser terminada. Além disso, se a thread-mãe
terminar, todas as threads filho terminam também. Porque isso é importante? Isso
é importante porque as threads-filho compartilham recursos com a thread-mãe,
incluindo variáveis. Quando a thread-mãe termina, todas as variáveis são perdidas
e a thread-filho não poderá aceder aos recursos que a thread-mãe possuia. Assim,
se a thread-mãe terminar mais cedo que a thread-filho haverá um problema! Uma
thread pode terminar das seguintes maneiras:
Retornando da sua rotina mais externa, a thread criadora.
Quando termina a rotina em que foi começada.
Chamando pthread_exit, fornecendo um estado de saída.
Terminando através da função pthread_cancel
Sincronizar(Thread Join)
Imagine a seguinte situação: Você está estudando para uma prova. Então você
pede o seu irmão mais novo para comprar uma pizza. Neste caso você é a thread
principal e seu irmão a thread-filho. Uma vez que você deu a ordem, você e seu
irmão começam a “executar uma tarefa” simultaneamente. Agora há dois casos a
se considerar: Primeiro: Seu irmão traz a pizza e termina enquanto você estuda.
Nesse caso você pode parar de estudar e comer a pizza. Segundo: Você acaba de
estudar mais cedo e dorme e depois a pizza chegará.
A junção de threads (thread join) é destinada para resolver este problema. A
thread pode executar o thread join e aguardar até a outra thread terminar. No caso
acima, você é a thread principal (thread main) e deve executar o thread
joinaguardando o seu irmão (thread-filho) terminar. Em geral o thread join é
utilizado para a thread-mãe se sincronizar com uma das threads-filho.
Thread Yield (Rendimento da thread)
Suponha que você executa um certo número de programas o tempo todo no
computador. Isso é possível devido a CPU escalonar pouco a pouco outros ciclos da
CPU, assim outros programas podem ser executados. Isso pode ser um problema
de política de planeamento do Sistema Operativo. Entretanto, quando escrevemos
programas com múltiplas threads, temos que fazer correctamente para que
algumas threads não ocupem a CPU eternamente, ou por um tempo muito longo
sem abandoná-lo. Senão terminar na situação acima quando uma ou duas threads
executam enquanto outras simplesmente esperam para retornar. Liberamos espaço
na memória graças a thread yield. Quando a thread executa o thread yield, a
execução da thread é suspensa e a CPU passa para uma outra thread em execução.
Essa thread aguardará até a CPU tornar-se disponível novamente.
16
Escalonamento Da mesma forma que os processos sofrem escalonamento, as threads também têm
a mesma necessidade. Quando vários processos são executados em uma CPU, eles
dão a impressão que estão sendo executados simultaneamente. Com as threads
ocorre o mesmo, elas esperam até serem executadas. Como esta alternância é
muito rápida, há impressão de que todas as threads são executadas paralelamente.
Linha de execução ao nível do usuário
As ULT são escalonadas pelo programador, tendo a grande vantagem de cada
processo usar um algoritmo de escalonamento que melhor se adapte a situação, o
sistema operacional neste tipo de thread não faz o escalonamento, em geral ele
não sabe que elas existem. Neste modo o programador é responsável por criar,
executar, escalonar e destruir a thread. Um exemplo prático de processo chamado
P1 que contém tais threads: P1T1, P1T2 e P1T3, quando o sistema operacinal da a
CPU para o processo P1 cabe a ele destinar qual thread será executada, caso esta
thread use todo processo do quantum, o sistema operacional chamará outro
processo, e quando o processo P1 voltar a executar, P1T1 voltará a ser executada e
continuará executando até seu término ou intervenção de P1, este comportamento
não afetará outros processos pois o sistema continua escalonando os processos
normalmente.
Linha de execução ao nível do núcleo
As KLT são escalonadas diretamente pelo sistema operacional, comumente são
mais lentas que as Threads ULT pois a cada chamada elas necessitam consultar o
sistema, exigindo assim a mudança total de contexto do processador, memória e
outros níveis necessários para alternar um processo. Um exemplo prático de
processo chamado P2 que contém as threads P2T1, P2T2 e P2T3 e um processo
chamado P3 que contém as threads P3T1, P3T2 E P3T3. O Sistema Operacional não
entregará a CPU ao processo e sim a uma thread deste processo, note agora que o
sistema é responsável por escalonar as threads e este sistema tem que suportar
threads, a cada interrupção de thread é necessário mudar todo o contexto de CPU e
memória, porém as threads são independentes dos processos, podendo ser
executadas P3T2, P2T1, P2T2, P2T1, P3T1,P2T3,P3T3, ou seja a ordem em que o
escalonador do sistema determinar. Já com as threads em modo usuário não se
consegue ter a mesma independência, pois quando passamos o controle ao
processo, enquanto seu quantum for válido ele irá decidir que thread irá rodar. Um
escalonamento típico do sistema é onde o escalonador sempre escolhe a thread de
maior prioridade, que são divididas em duas classes: Real Time e Normal. Cada
thread ganha uma prioridade ao ser criada que varia de 0 a 31(0 é a menor e 31
maior), processos com prioridade 0 a 15(Real Time) tem prioridade ajustada no
tempo de execução como nos processos de E/S que tem a prioridade aumentada
variando o periférico, processos com prioridade 16 a 31 são executados até
terminar e não tem prioridade alterada, mas somente uma thread recebe a
prioridade zero que é a responsável por zerar páginas livres no sistema. Existe
ainda uma outra classe chamada de idle, uma classe mais baixa ainda, só é
executada quando não existem threads aptas, threads dessa classe não interferem
na performance.
17
Comparação entre linha de execução e Processo Um sistema baseado em linha de execução é diferente de um sistema operacional
multi-tarefa tradicional, em que processos são tipicamente independentes,
carregam considerável estado da informação, tem endereço de memória separado e
interagem somente através de mecanismos de inter-processos de comunicação. As
threads, por outro lado, compartilham o estado da informação de processos únicos,
e compartilham memória e outros recursos diretamente.
A troca de contexto através de linha de execução num mesmo processo é
tipicamente mais rápida que a troca de contexto entre processos diferentes.
Sistemas como o Windows NT e o OS/2 são feitos para ter linha de execução
"baratas" e processos "caros", enquanto em outros sistemas operacionais não há
grandes diferenças.
O multithreading é um modelo de programação popular que permite a execução de
múltiplas linha de execução dentro de um contexto simples, compartilhando
recursos do processo, e capazes de executar de forma independente. O modelo de
programação em linha de execução fornece ao desenvolvedor uma execução
simultânea. Entretanto, a aplicação mais interessante da tecnologia ocorre quando
ela é utilizada em um processo simples permitindo uma execução paralela em
sistemas multi-processados.
Um sistema multi-threaded possui um melhor desempenho que um sistema de
computadores com múltiplas CPUs e com múltiplos núcleos, ou que um cluster de
máquinas. Isto acontece porque a linha de execução empresta a ela mesmo uma
execução simultânea. Em alguns casos, o programador precisa ter cuidado em
evitar condições de concorrência e outros comportamentos inesperados.
Para um dado ser manipulado corretamente, as linhas de execução freqüentemente
precisarão ser sincronizadas, para que os dados sejam processados na ordem
correta. As linha de execução podem também executar operações atômicas
(freqüentemente implementadas usando semáforos) com intuito de prevenir que
dados comuns sejam simultaneamente modificados ou lidos enquanto o processo
esta sendo modificado.
Os sistemas operacionais implementam as linhas de execução de duas formas:
multithreading preemptiva ou multithreadingcooperativa. A multithreading
preemptiva é geralmente considerada uma implementação superior, porque
permite ao sistema determinar quando uma troca de contexto pode acontecer. A
multithreading cooperativa, por outro lado, confia nas threadspara ceder o controle,
o que pode ser um problema caso uma tarefa “monopolize” o uso da CPU ou se
houver espera pela disponibilidade de um recurso. A desvantagem da multithread
preemptiva é que o sistema pode fazer uma troca em um tempo inapropriado,
causando uma inversão de prioridade ou outros efeitos ruins que podem ser
evitados por uma multithreadingcooperativa.
Em geral:
Criar um processo pode ser caro em termos de tempo, memória, e
sincronização entre processos.
18
As linhas de execução podem ser criadas sem a replicação do processo
inteiro.
O trabalho de criar uma linha de execução pode ser feito no espaço do
usuário.
Como as linhas de execução partilham o espaço de endereçamento a
comunicação entre elas é mais rápida.
O tempo gasto para troca de linha de execução é menor, em parte por que
não há necessidade de troca de espaço de endereçamento.
Modelo de Geração de Multithreads
Modelo Muitos-Para-Um
O modelo muitos-para-um mapeia muitos threads de nível de usuário para threads
do kernel. O gerenciamento dos threads é realizado no espaço do usuário e assim é
eficiente, mas o processo inteiro ficará bloqueado. Além disso, como somente um
thread pode acessar o kernel de cada vez, múltiplos threads são incapazes de
executar em paralelo em multiprocessadores.1
Modelo Um-Para-Um
O modelo um-para-um mapeia cada thread de usuário para um thread de kernel,
gera mais concorrência do que o modelo muitos-para-um. Permite a um outro
thread ser executado, enquanto um thread realiza uma chamada de sistema de
bloqueio, ele também permite que múltiplos threads executem em paralelo em
multiprocessadores. A única desvantagem deste modelo é que a criação de um
thread de usuário requer a criação do correspondente thread de kernel.1
Modelo Muitos-Para-Muitos
O modelo muitos-para-muitos multiplexa muitos threads de nível de usuário para
um número menor ou igual de threads de kernel. O número de threads de kernel
pode ser específico tanto para uma aplicação em particular quanto para uma
máquina em particular. Os desenvolvedores podem criar tantos threads de usuário
quantos forem necessários, e os correspondentes threads de kernel podem
executar em paralelo em um multiprocessador. Além disso, quando um thread
realiza uma chamada de sistema de bloqueio, o kernel pode agendar um outro
thread para execução.1
Cancelamento O cancelamento de threads corresponde à tarefa de terminar um thread antes que
se complete. Por exemplo, se múltiplos threads estão pesquisando
concorrentemente em um banco de dados e um thread retorna o resultado, os
threads que ainda estão sendo executados podem ser cancelados. Uma outra
situação pode ocorrer quando um usuário pressionar um botão em um navegador
da Web. Com frequência, uma página da Web é carregada em um thread separado.
Quando um usuário pressionar o botão stop, o thread que estava carregando a
página é cancelado. Um thread que está para ser cancelado é frequêntemente
denominado thread-alvo.1
Exemplos
Java
import java.io.*;
19
public class Example implements Runnable
{
static Thread threadCalculate; // Cria o thread.
static Thread threadListen;
long totalPrimesFound = 0;
public static void main (String[] args)
{
Example e = new Example();
threadCalculate = new Thread(e);
threadListen = new Thread(e);
threadCalculate.start();
threadListen.start();
}
public void run()
{
Thread currentThread = Thread.currentThread();
if (currentThread == threadCalculate)
calculatePrimes();
else if (currentThread == threadListen)
listenForStop();
}
public void calculatePrimes()
{
int n = 1;
while (true)
{
n++;
boolean isPrime = true;
for (int i = 2; i < n; i++)
if ((n / i) * i == n)
{
isPrime = false;
break;
}
if (isPrime)
{
totalPrimesFound++;
System.out.println(n);
}
20
}
}
private void listenForStop()
{
BufferedReader input = new BufferedReader(new
InputStreamReader(System.in));
String line = "";
while (!line.equals("stop"))
{
try
{
line = input.readLine();
}
catch (IOException exception) {}
}
System.out.println("Found " + totalPrimesFound +
" prime numbers before you said stop");
System.exit(0);
}
}
Java, exemplo simples em português
import java.util.logging.Level;
import java.util.logging.Logger;
class Threaded extends Thread {
Synchronized1 base;
public Threaded( Synchronized1 bse ) {
this.base = bse;
}
}
public class Synchronized1 {
public Synchronized1() {
}
public void ini() {
new Threaded( this ) {
public void run() {
while( true ) {
synchronized( base ) {
21
System.out.print( "Este é A, agora vai mostrar
B.\n" );
try {
Thread.sleep(1000);
} catch (InterruptedException ex) {
Logger.getLogger(Synchronized1.class.getName()).log(Level.SEVERE,
null, ex);
}
try {
base.notify();
base.wait();
} catch (InterruptedException ex) {
Logger.getLogger(Synchronized1.class.getName()).log(Level.SEVERE,
null, ex);
}
}
}
}
}.start();
new Threaded( this ) {
public void run() {
while( true ) {
synchronized( base ) {
System.out.print( "Este é B, então foi já
mostrado A.\n" );
try {
Thread.sleep(1000);
} catch (InterruptedException ex) {
Logger.getLogger(Synchronized1.class.getName()).log(Level.SEVERE,
null, ex);
}
try {
base.notify();
base.wait();
} catch (InterruptedException ex) {
Logger.getLogger(Synchronized1.class.getName()).log(Level.SEVERE,
null, ex);
}
}
}
22
}
}.start();
}
public static void main(String[] args) {
new Synchronized1().ini();
}
}
C
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#define THREADS_MAX 4
void *function(void *param)
{
int id = (int)param;
int i, loops = 10;
for(i = 0; i < loops; i++)
{
printf("thread %d: loop %d\n", id, i);
}
pthread_exit(NULL);
}
int main(void)
{
pthread_t threads[THREADS_MAX];
int i;
printf("pre-execution\n");
for (i = 0; i < THREADS_MAX; i++)
{
pthread_create(&threads[i], NULL, function, (void *)i);
}
printf("mid-execution\n");
for (i = 0; i < THREADS_MAX; i++)
{
pthread_join(threads[i], NULL);
}
printf("post-execution\n");
return EXIT_SUCCESS;
}
C++
#include <iostream>
#include <boost/thread/thread.hpp>
23
using namespace std;
const int THREADS_MAX = 4;
struct function
{
function( const int &_id )
: id( _id )
{ }
void operator()()
{
for( int i = 0; i < 10; ++i )
{
cout << "thread " << id << ": loop " << i << endl;
}
}
private:
const int id;
};
int main(void)
{
boost::thread_group threads;
cout << "pre-execution" << endl;
for( int i = 0; i < THREADS_MAX; ++i )
{
threads.create_thread( function( i ) );
}
cout << "mid-execution" << endl;
threads.join_all();
cout << "post-execution" << endl;
return 0;
}
Ruby
count = 0
a = Thread.new { loop { count += 1 } }
sleep(0.1)
Thread.kill(a)
puts count #=> 93947
Delphi
unit UExemplo;
interface
24
uses
Classes, Generics.Collections;
type
TThreadExemplo = class(TThread)
private
FPrimeiroNumero: Integer;
FUltimoNumero: Integer;
FListaPrimos : TList<Integer>;
function IsPrimo(const pNumero : Integer) : Boolean;
protected
procedure Execute; override;
public
constructor Create(const pCreateSuspended: Boolean; const
pPrimeiroNumero, pUltimoNumero: Integer);
destructor Destroy; override;
property PrimeiroNumero: Integer read FPrimeiroNumero write
FPrimeiroNumero;
property UltimoNumero: Integer read FUltimoNumero write
FUltimoNumero;
function GetListaAsString: String;
end;
implementation
uses
SysUtils;
{ TThreadExemplo }
constructor TThreadExemplo.Create(const pCreateSuspended: Boolean;
const pPrimeiroNumero, pUltimoNumero: Integer);
begin
inherited Create(pCreateSuspended);
FListaPrimos := TList<Integer>.Create;
FPrimeiroNumero := pPrimeiroNumero;
FUltimoNumero := pUltimoNumero;
end;
destructor TThreadExemplo.Destroy;
begin
FListaPrimos.Free;
25
inherited;
end;
procedure TThreadExemplo.Execute;
var
lNumero: Integer;
begin
lNumero := FPrimeiroNumero;
while not Terminated and (lNumero <= FUltimoNumero) do
begin
if IsPrimo(lNumero) then
begin
FListaPrimos.Add(lNumero);
end;
Inc(lNumero);
end;
end;
function TThreadExemplo.GetListaAsString: String;
var
lNum: Integer;
begin
Result := EmptyStr;
for lNum in FListaPrimos do
begin
Result := Result + IntToStr(lNum) + sLineBreak;
end;
end;
function TThreadExemplo.IsPrimo(const pNumero: Integer): Boolean;
var
lNum: Integer;
lMax: Integer;
begin
Result := True;
lNum := 2;
lMax := (pNumero div 2);
while Result and not Terminated and (lNum <= lMax) do
begin
Result := pNumero mod lNum <> 0;
Inc(lNum);
end;
26
end;
end.
Multitarefa Em computação, Multitarefa é a característica dos sistemas operativos que permite
repartir a utilização do processador entre várias tarefas aparentemente
simultaneamente.
História O primeiro sistema informatizado a usar multitarefa foi o britânico LEO III,
completado 1961. A multitarefa preemptiva foi implementada nas versões iniciais
do Unix em 1969, e é o padrão no Unix e em sistemas operacionais similares,
incluindo Linux, Solaris e BSD em suas variações.
Pode parecer, actualmente, difícil de imaginar um computador monotarefa, i.e., que
apenas permita utilizar uma aplicação mas, de facto, houve um percurso histórico
notável até se atingir o nível actual de paralelização de processos. Com efeito, os
primeiros computadores apenas permitiam executar uma única tarefa de cada vez.
O Apple DOS é um excelente exemplo disso, já que foi dos primeiros sistemas
operativos para computadores pessoais.
O primeiro passo para a multitarefa no MS-DOS foi a criação dos TSR's (Terminate
and Stay Resident), pequenos programas que permaneciam em memória enquanto
se executava outro programa, e que podiam instalar rotinas de tratamento de
interrupções para serem ativados posteriormente. Ou seja, estando o utilizador a
escrever um texto num processador de texto, por exemplo, poderia apertar uma
combinação de teclas que dispararia uma interrupção e chamaria a TSR de uma
agenda pessoal para tirar notas. Assim, do ponto de vista do processador, o
processo do processador de texto era bloqueado e passava-se o controle para a
agenda. Quando o utilizador terminasse, voltava-se ao processador. Ambos
programas coexistiam, mas não podiam ser executados simultâneamente.
O passo seguinte foi a emulação de multitarefa. Exemplos disto eram as primeiras
versões de Windows, que este executava sobre DOS (monotarefa), mas o núcleo do
Windows fazia a sua própria gestão dos processos. Curiosamente, se um processo
bloqueasse o Windows, todas as aplicações teriam que ser terminadas pois eram
todas dependentes.
Posteriormente, surgiu uma das principais componentes dos SO actuais: o
escalonador de processos, ou (em inglês) scheduler, que faria a gestão,
qualificação e o gerenciamento de prioridade dos processos sem afectar o núcleo do
sistema operativo. Ou seja, todas as tarefas núcleo são críticas, e todo o tempo que
sobrar é legado aos processos. Adivinha-se, portanto, a necessidade de estabilizar
o núcleo, por forma a minimizar o tempo de execução de tarefas internas.
O escalonador de processos é uma componente muito polêmica em termos de
inovação e de aplicações. Dependendo das situações, um escalonador de processos
deve gerir os seus processos por forma a diminuir a latência entre aplicações
27
interactivas, ou assegurar a coerência em termos de critérios no escalonamento: se
uma tarefa não é crítica, então não devia estar a ser executada.
Tarefas Os conceitos ligados ao paralelismo de tarefas não são consensuais. A linguagem
vulgar no UNIX sugere, no entanto, alguns termos razoavelmente universais.
No UNIX, existem dois níveis de tarefa: o processo e a thread. Os processos têm
uma série de threads associadas. Tipicamente, cada processo tem um determinado
espaço de endereçamento que as diferentes threads partilham. Cada thread tem o
seu próprio estado de processador e a sua própria pilha.
Alternância de tarefas Cada processador pode executar apenas um programa de cada vez. Por esta razão,
a multitarefa num sistema uniprocessador é apenas uma ilusão conseguida com a
alternância rápida entre as várias tarefas.
O núcleo do sistema operativo é responsável por isolar os contextos de execução
das diversas tarefas. Para conseguir isto, é necessário que uma rotina do núcleo
seja chamada a dada altura. Essa rotina (que pode ser chamada por uma
interrupção provocada por um temporizador interno do computador) geralmente
executa as seguintes operações:
Salva o estado do processador numa estrutura de dados do núcleo (a árvore
de processos);
Seleciona, com base num algoritmo, a próxima tarefa a executar;
Se for necessário, reconfigura o espaço de endereçamento de modo a que a
próxima tarefa encontre a memória no estado que espera;
Carrega o estado do processador referente à tarefa que vai receber tempo
de processador;
A rotina retorna permitindo que o programa execute.
No Mundo das Placas-mãe para PCs
Quais as melhores marcas?
Principais características técnicas
Atualmente no mercado mundial há muitos e muitos modelos de placas-mãe, e
com as mais diversas configurações tecnológicas – configurações bem básicas as
mais sofisticadas e avançadas.
Como exemplos, placas-mãe que suportam somente memória SDR (Single Data
Rate ou Taxas de dados transmitidos no modo simples – cada ciclo de pulso
transmite um dado por segundo), sendo que cada módulo de memória SDR possui
168 vias; Placas-mãe que suportam memóriasSDR e DDR (Double Data Rate ou
Taxas de dados transmitidos em dobro – cada ciclo de pulso transmite 2 dados),
sendo que cada módulo de memória SDR possui 184 vias.
E ainda, placas-mãe que suportam módulos de memórias do tipo
DDR2/DDR3/DDR4 (Double Data Rate ou Taxas de dados transmitidos em dobro ou
28
em quatro, ou seja, cada ciclo de pulso transmite 2 ou quatro dados), sendo que
cada módulo de memória DDR2/3/4 possui 240 vias elétricas.
Este modelo de placa-mãe desta imagem acima, por exemplo, é do tipo
"multiprocessadores". Ou seja, suporta quatro processadores AMD Opteron 6100
Series Processors (Magny-Cours) com tecnologia de 45 nm, sendo que cada
processador pode contar com 8 Cores (8 núcleos - 4 físicos e 4 lógicos) ou com 12
Cores (12 núcleos - 6 físicos e 6 lógicos), desta forma, um total de 32 a48 núcleos;
esta placa-mãe conta ainda com 32 slots para módulos de memória DDR3 de 16 GB
cada, portanto, totalizando 512 GB de memória instalada. Mais informações nestes
links abaixo:
http://www.tyan.com/product_SKU_spec.aspx?ProductType=MB&pid=670&SKU=600000180
http://www.kabum.com.br/cgi-
local/kabum3/produtos/descricao.cgi?id=01:01:11:69:26410&tag=
As memórias DDR2/3/4 operam com altas freqüências de clock, como no modo de
800 MHz (máximo para as DDR2 e mínimo para as DDR3), devido a técnica QDR
(Quad Data Rate ou Taxas de dados transmitidas de quatros em quatro dados por
segundo – cada ciclo de pulso transmite 4 dados). Neste caso a freqüência original
da memória é 200 MHz, mas como aproveitam cada ciclo de pulso para levar quatro
dados (dois dados na rampa de subida e dois na rampa de decida), é como se ela
estivesse operando à 800 MHz, por segundo.
Além do suporte para vários tipos de memórias, algumas placas-mãe também
suportam redes Gigabits, redes Wireless (sem fio), bus PCI Express x1 e x16
(imagem abaixo, direita), este substituto do bus AGP (imagem abaixo, esquerda);
somente HDs SATA (Serial ATA) e/ou SATA+PATA+SSD (Serial ATA+Parallel
ATA+). E a cada novo modelo de placa-mãe, o suporte as novas tecnologias
também aumentam.
29
As melhores marcas
Ao ler esta matéria muitos poderão dizer que estamos fazendo chover no molhado,
pode até ser. Porém, muitos e muitos usuários de microcomputadores estão
fazendo a mesma pergunta: “Quais são as melhores marcas de placas-mãe?”.
Isto porque – como acontece com as fontes de alimentação para
microcomputadores –, também estamos no “Mundo das placas-mãe para PCs”,
mundo este que conta com muitos fabricantes que realmente fabricam placas-mãe,
e também, empresas que não fabricam, mas que colocam suas marcas em modelos
de placas-mãe, e desta forma, ficam conhecidas no mercado nacional e
internacional.
Também pode ocorrer de alguns modelos de placas-mãe serem das melhores
marcas, mas não serem de boa qualidade. Outro fator de suma importância para
que uma ótima placa-mãe corresponda 100% de sua capacidade, refere-se a
montagem do microcomputador. Emparafusar a placa-mãe e outros componentes
no gabinete é uma coisa, montar o microcomputador é outra coisa muito diferente
– é uma arte para poucos.
A placa principal dos microcomputadores que recebe o chip (ou chips) CPU
(processador para dados), e também, que recebe muitos outros chips que são
integrados nela, também é conhecida por outros nomes, tais como: Placa-Mãe,
Placa de Sistema, Placa Principal, CPU Board, Main-Board.
Quanto aos preços dos modelos de placas-mãe, dependerá do modelo – se é antigo
ou recente –, dos recursos técnicos integrados (chips de som, de vídeo, de rede,
chipset e outros no modo on-boards), ou dos recursos técnicos não integrados, mas
que são suportados, como: placas externas off-boards (placas aceleradoras
gráficas, CPUs, etc.).
Placas-mãe multi CPUs
Já com relação aos modelos de Placas-mãe existentes, os mesmos são inúmeros;
os recursos tecnológicos que as mesmas suportam vão dos mais fracos aos
recursos mais potentes. Como exemplo, alguns modelos de placas-mãe suportam
QUATRO CPUs (processadores para dados) e , como o modelo da imagem acima,
30
modelos como o da imagem são conhecidas por placas-mãe para
multiprocessadores. Neste caso, o recurso é conhecido por multiprocessamento.
E para que a placa-mãe suporte o multiprocessamento de dados, ela deve suportar
a tecnologia conhecida por SMP (Symmetric Multprocessing ou algo como
Multiprocessamento de dados por dois ou mais processadores, conjuntamente).
Esta técnica é empregada quando se deseja que os dados sejam processados por
duas (ou mais) CPUs – no modo paralelo –, dividindo-se assim a carga que estaria
reservada a um único processador.
Placas-mãe multi CPUs/GPUs
Já alguns modelos de placas-mãe podem suportar até SETE GPUs (processadores
para dados gráficos integrados nas placas aceleradoras gráficas modernas, como
este modelo destes links abaixo:
http://www.baboo.com.br/conteudo/articlefiles/37786-01.jpg
http://www.evga.com/forums/tm.aspx?m=124528&mpage=1
Este modelo de placa-mãe da imagem acima e dos links acima (a EVGA (socket
LGA1366) modelo 270-GT-W555, com chipset Intel X58 integrado) realmente é
muito potente, pois suporta SETE placas aceleradoras gráficas e DOIS
processadores de 8 núcleos (4 físicos e quatro lógicos), totalizando 16 núcleos para
processamentos de dados binários; possui ainda 12 slots para módulos de memória
SDRAM DDR3, portanto, pode suportar ate 48 GB (12 slots x 4 GB de cada
módulo).
Componentes integrados nas placas-mãe
Nas placas-mãe – nos modelos antigos e modernos também – podemos ver as
interfaces (portas) para o teclado e mouse (PS/2 e USB); os conectores para a
fonte de alimentação (4, 8, 20 e 24 pinos); a bateria (20/32) e chip CMOS (a partir
31
do 286); os chips VLSI, mais conhecido por chipset; os slots ISA de 8 e 16 bits e
Slots VLB; os slots PCI de 32 bits, AGP e PCI-Express x1 e x16; o chip de memória
ROM/FlashROM BIOS; as interfaces para discos rígidos (IDE/PATA e IDE/SATA); a
interface para drives de disquetes (esta já foi extinta); as interfaces para portas
seriais e paralela; o socket (ou sockets, nos modelos de placas-mãe modernas)
para o microprocessador e co-processadores (nas placas 286 e 386), entre muitos
outros componentes integrados nas placas-mãe.
Os tipos de placas-mãe Os tipos de Placas-mãe vão desde uma XT (Extended Technology ou Tecnologia
estendida); umaAT (Advanced Technology ou Tecnologia avançada, a partir do
286), até as revolucionárias placas-mãe ATX (Advanced Technology Extended ou
Tecnologia Avançada e Estendida). A Intel desenvolveu o tipo BTX (Balanced
Technology Extended – Tecnologia estendida e balanceada) para os novos modelos
de gabinetes para microcomputadores – e respectivas placas-mãe e fontes que
seriam instaladas nestes gabinetes.
Os Fabricantes e Marcas de placas-mãe
Como já foi citado acima, no “Mundo das placas-mãe”, mundo este que conta com
muitas empresas que realmente fabricam placas-mãe, e também, empresas que
não fabricam, mas que colocam suas marcas em modelos de placas-mãe e desta
forma ficam conhecidas no mercado.
As melhores marcas – Quais são elas?
Ao ler esta matéria muitos poderão dizer que estamos fazendo chover no molhado,
ou seja, repetindo aquilo que muitos usuários (principalmente técnicos) de
microcomputadores já sabem, pode até ser. Porém, muitos e muitos usuários de
microcomputadores estão fazendo a mesma pergunta: “Quais são as melhores
marcas de placas-mãe?”.
E pela ordem, levando em conta requisitos, tais como: qualidade, aceitação do
mercado nacional e mundial, mais as análises de especialistas. E aqui também vale
a minha experiência de mais de 12 anos trabalhando com placas-mãe, sendo que
placas-mãe que menos dão problemas são os modelos produzidos pela empresa
Gigabyte.
Placas-mãe do “Top 15 ” são as seguintes:
> Gigabyte, Asus , MSI, *Intel, ECS, Zotac, EVGA, Foxcomm, XFX, TYAN,
Phitronics, Sapphire Technology, ABIT, VS Company e Micronic Computer
INC <
*A Intel não é primeira da lista, e pelo seguinte: A empresa Foxconn também
fabrica placas-mãe para a Intel (confira no link abaixo). Portanto, ao comprar
modelos de placas-mãe da Intel, na verdade esses modelos podem ter sidos
fabricados pela Foxconn.
32
http://pt.wikipedia.org/wiki/Anexo:Lista_de_fabricantes_de_hardware#Placa-M.C3.A3e
Os fabricantes de placas-mãe – Quais são?
É interessante observar que, quando se fala em placas-mãe – na verdade nos
fabricantes, respectivas marcas e modelos de placas-mãe – somente dois ou três
nomes são citados: Asus, Gigabyte e MSI.
Porém, já existiram (ou ainda existem) uma boa quantidade de empresas que
fabricam placas-mãe (ou apenas usam seus nomes nelas), como estas da lista (e
do link) abaixo:
( http://www.clubedohardware.com.br/artigos/970 )
>Asus, ABIT, Asrock, Aopen, Albatron, Amptron; BCM, BFG Technologies, Biostar;
Chaintech, Chantec. DFI (Design For Innovation), Digitron; ECS (Elite Group),
EVGA, EpoX; FIC, Foxconn; Gigabyte; Intel, IWILL; Jetway; Kinpo Electronic;
Mercury, Magic Pro, Mach Speed, MSI (Micro-Star International), Mitac
international, Micronic Computer INC; Netgate; PCWare, Phitronics, PCChips, PC-
Micro; Positivo (modelo POS MI945AA, por exemplo, modelo cedido pela MSI);
Soyo, Shuttle Computer, Soltek, Supermicro; TYAN; USI (Universal Scientific
Industrial), Universal Abit; VIA Tecnology, VS Company; XFX, Zotac; e muitas
outras fabricantes de placas-mãe de menor expressão no enorme mercado
mundial.
Os fabricantes de hardware – Quais são?
Se a lista de empresas que fabricam placas-mãe já é grande, imagine a lista dos
fabricantes de hardwares para os microcomputadores. Para isto basta conferir
neste link abaixo:
http://pt.wikipedia.org/wiki/Anexo:Lista_de_fabricantes_de_hardware#Placa-M.C3.A3e
Tecnologia SMP (Symmetric Mult Processing)
Este termo se refere a tecnologia para Multiprocessamentos de dados por dois ou
mais processadores instalados numa mesma placa-mãe, e operando conjuntamente
numa mesma placa-mãe. Na primeira imagem acima vemos um modelo de placa-
mãe que opera com quatro processadores.
33
Esta técnica é bem empregada quando se deseja que os dados sejam processados
por duas CPUs (no modo paralelo), dividindo-se assim, a carga que estaria
reservada a um único processador.
Vale lembrar aqui que no modo SMP de dois processadores operando a 2 GHz
cada, não será o mesmo que se a máquina estivesse operando a 4 GHz, como
ocorre no modo Dual Core (DC). No modo DC todo o processamento torna-se mais
estável, contínuo, seguro e mais rápido também, já que é como se a máquina
contasse com um processador operando a 4 GHz.
No modo SMP moderno, todo o processamento também se torna mais estável,
contínuo e seguro, podendo operar mais rápido ainda já que a máquina conta com
duas CPUs DualCore e opera como se existisse somente um processador operando
a 3 GHz, por exemplo. Entretanto, em termo de estabilidade no processamento o
desempenho da máquina é muito superior caso ele contasse com um processador
somente.
Nesta técnica ou arranjo SMP, cada CPU possui e usa seu próprio cachê L1 e L2 e,
como bem mostra a figura acima (da esquerda), caso a CPU 1 necessite de um
determinado dado e este dado não se encontre gravado no L1 (este geralmente
reservado para a gravação temporária de códigos e instruções utilizados pela
respectiva CPU) e também não se encontre na L2 (este sempre reservado para a
gravação temporária de dados que já foram ou serão processados pela respectiva
CPU). A CPU 1 terá que buscar o dado (ou dados) diretamente na memória RAM
(observe todo o processo acompanhando a imagem acima, a esquerda).
Observar ainda o seguinte: quando o cachê L1 é reservado somente para códigos e
instruções, a CPU acessa diretamente o L2 em busca do respectivo dado. Caso não
encontre o respectivo dado ela buscará na memória RAM usando o bus (barramento
para o tráfego de sinais digitais na placa-mãe), o FSB (Front Side Bus) e o
bus MB (Memory Bus – barramento da memória), como pode ser visto na imagem
acima (esquerda).
Atualmente o controlador de memória não mais se encontra no Chipset North
bridge, e sim, está integrado no próprio chip do processador (processadores da
AMD e da Intel). Portanto, não mais utiliza o lento FSB e as comunicações entre a
CPU (ou CPUs) tornam muito mais rápidas – veja um exemplo na imagem acima,
da direita.
Como exemplo, o processador DualCore Intel Core 2 Duo E8400, 1600 MHz (6 x
267) possui umL1 (Level 1) contando com 64 KB (sendo 32 KB para a paridade –
códigos para verificação de erros nos bits de dados; e 32 KB para o ECC – Error
Corretion Code, Códigos para a correção de erros). Já o L2 é de 6 MB para a
gravação temporária de dados já processados pela CPU, no modo de On-Die, ECC,
Full-Speed.
Alguns termos técnicos usados
As áreas da informática moderna estão repletas de inúmeros termos técnicos.
Porém, aqui, apresentamos alguns termos técnicos relacionados com esta matéria
em questão.
34
Somos de opinião que todos os professores de informática deveriam orientar seus
alunos – já nas primeiras aulas – para que os mesmos estudem os termos técnicos
desta vasta área. Com isto, eles notarão que fica mais fácil estudar, aprender e
conhecer os assuntos que estão estudando naquele momento – e os posteriores
também.
AGP (Acelerated Graphics Port – Porta para aceleradora gráfica);
ALU (Arithmetic Logic Unit – Unidade para processamento de dados aritméticos);
AMD (Advanced Micro Device – Refere ao segundo maior fabricante de CPUs – em
primeiro está a Intel);
BIOS (Basic Input/output System – Sistema básico de entrada e saída);
CMOS (Complementary Metal Oxide Semicondutor – Semicondutor metal-óxido
complementar);
CPU (Central Processing Unit – Unidade para processamento de dados binários –
imagem acima, esquerda);
DC (Dual Core – Núcleo duplo, processadores com 2 núcleos internos);
FlashROM (Flash Read Only Memory – Memória para leituras e escritas rápidas)
FSB (Front Side Bus – Barramento frontal superior);
GPU (Graphic Processing Unit – Unidade para o processamento de dados gráficos –
imagem acima, direita);
L1/L2 (Level 1 e 2 – Memória cachê Nível 1 e 2 no núcleo (ou núcleos) do
processador);
PATA (Parallel Attachment Technology Advanced – Tecnologia avançada para
conexão paralela);
35
PCI-Express (Peripheral Component Interconnect Express – Conexão expressa
para componentes e periférico);
PS/2 (Port Serial 2 – Porta serial versão 2);
ROM (Read Only Memory – Memória para somente leitura);
SATA (Serial Attachment Technology Advanced – Tecnologia avançada para
conexão serial);
USB (Universal Serial Bus – Barramento universal serial);
