Multiprocessadores e
Paralelismo nível de Thread
Roteiro da Aula
• Revisando o problema coerência
• Protocolo de coerência para memória baseado
em Snooping
• Protocolo de coerência baseado em diretórios
– Como funciona
• Implementando protocolo baseado em diretórios
– Tipos de mensagens na rede
– Mudanças do estado do bloco de cache e no diretório
• Sincronização de processos
– Problema em processadores DSM
– Solução para processadores DSM
• Comparação uniprocessadores vs.
multiprocessadores
Coerência
• Só uma pessoa pode falar no
microfone por vez
• Toda modificação em conta deve ser
comunicada entre os funcionários
através do alto falante
• Após modificações cópias devem ser
inutilizadas
Protocolo Snooping de Coerência de Cache
State
Tag
Data
Pn
P1
Bus snoop
$
$
Mem
I/O devices
Cache-memory
transaction
• Controladores de Cache “snoops” todas as transações no
barramento
– Transações relevantes : envolvem bloco que a cache possui
– Realiza ação para garantir coerência
• invalida, atualiza, ou fornece valor
– Atualiza estado de compartilhamento do bloco de cache
Protocolo Snooping de Coerência de Cache
State
Tag
Data
Pn
P1
Bus snoop
$
$
Mem
I/O devices
Cache-memory
transaction
• Problemas:
– Aumento no número de processadores
• Mais acessos à memória
• Congestionamento na utilização do barramento
– Aumento no número de faltas devido à invalidação
por compartilhamento
Memória Distribuída
• Cada nó de processamento inclui cache e memória
local
• Comunicação entre nós: Rede de Interconexão
C - Cache
M
P0
P1
Pn
C
C
C
IO
M
IO
...
Interconnection Network
7
M
M - Memory
IO - Input/Output
IO
Memória Distribuída
• Pro: Abordagem eficaz para um grande número de
processadores
• Pro: reduz tempo de acesso à memória local
• Con: Comunicação bem mais complexa
C - Cache
M
P0
P1
Pn
C
C
C
IO
M
IO
...
Interconnection Network
8
M
M - Memory
IO - Input/Output
IO
Modelos de Comunicação vs. Modelo de
Memória
1.
Comunicação através de endereços compartilhados
(via loads e stores):
multiprocessadores de memória compartilhada
• Memória Centralizada (Symmetric shared memory - SMPs)
• Memória Distribuída
2.
Comunicação explícita através de passagem de
mensagens entre processadores
• Memória Distribuída
Comunicação por Variável Compartilhada
• As memórias fisicamente separadas são
endereçadas como Espaço Compartilhado
Logicamente
– As memórias locais podem ser acessadas por
qualquer processador
• Estes multiprocessadores são denominados
Processadores DSM (distributed shared
memory)
Como garantir Coerência?
• Cada bloco de memória tem informação de
compartilhamento armazenada em um
componente chamado diretório
• O que faz o diretório?
• Tem informação de onde estão as cópias e do
estado de cada cópia
• Manda informação para as caches em caso de
escritas
• Faz a transferência de informações de memória
requisitada entre nós de processamento
Coerência:
Diretório
• Acessos às pastas somente através
do diretório
• Toda modificação em qualquer cópia
deve ser comunicada ao diretório
• Diretório comunica a necessidade de
inutilização
• Diretório envia cópia mais atualizada
Protocolo baseado em Diretório
Interconnection Network
Directory
Directory
Directory
Local Memory
Local Memory
Local Memory
Cache
Cache
Cache
CPU 0
CPU 1
CPU 2
Protocolo baseado em Diretório
Interconnection Network
Bit Vector
X U000
Directories
X 7
Memories
Caches
CPU 0
CPU 1
CPU 2
CPU 0 lê X
Interconnection Network
Read Miss
X U000
Directories
X 7
Memories
Caches
CPU 0
CPU 1
CPU 2
CPU 0 lê X
Interconnection Network
X S100
Directories
X 7
Memories
Caches
CPU 0
CPU 1
CPU 2
CPU 0 lê X
Interconnection Network
X S100
Directories
X 7
Memories
Caches
X 7
CPU 0
CPU 1
CPU 2
CPU 2 lê X
Interconnection Network
X S100
Directories
Memories
Caches
Read Miss
X 7
X 7
CPU 0
CPU 1
CPU 2
CPU 2 lê X
Interconnection Network
X S101
Directories
X 7
Memories
Caches
X 7
CPU 0
CPU 1
CPU 2
CPU 2 lê X
Interconnection Network
X S101
Directories
X 7
Memories
Caches
X 7
CPU 0
X 7
CPU 1
CPU 2
CPU 0 escreve 6 em X
Interconnection Network
Write Miss
X S101
Directories
X 7
Memories
Caches
X 7
CPU 0
X 7
CPU 1
CPU 2
CPU 0 escreve 6 em X
Interconnection Network
X S101
Directories
Invalidate
Memories
Caches
X 7
CPU 0
X 7
X 7
CPU 1
CPU 2
CPU 0 escreve 6 em X
Interconnection Network
X E100
Directories
X 7
Memories
Caches
X 6
CPU 0
CPU 1
CPU 2
CPU 1 lê X
Interconnection Network
Read Miss
X E100
Directories
X 7
Memories
Caches
X 6
CPU 0
CPU 1
CPU 2
CPU 1 lê X
Interconnection Network
Switch to Shared
X E100
Directories
X 7
Memories
Caches
X 6
CPU 0
CPU 1
CPU 2
CPU 1 lê X
Interconnection Network
X E100
Directories
X 6
Memories
Caches
X 6
CPU 0
CPU 1
CPU 2
CPU 1 lê X
Interconnection Network
X S110
Directories
X 6
Memories
Caches
X 6
CPU 0
X 6
CPU 1
CPU 2
CPU 2 escreve 5 em X
Interconnection Network
X S110
Directories
Memories
Caches
Write Miss
X 6
CPU 0
X 6
X 6
CPU 1
CPU 2
CPU 2 escreve 5 em X
Interconnection Network
X S110
Directories
X 6
Memories
Caches
X 6
CPU 0
X 6
CPU 1
CPU 2
CPU 2 escreve 5 em X
(Write back)
Interconnection Network
X E001
Directories
X 6
Memories
X 5
Caches
CPU 0
CPU 1
CPU 2
CPU 0 escreve 4 em X
Interconnection Network
X E001
Directories
X 6
Memories
X 5
Caches
CPU 0
CPU 1
CPU 2
CPU 0 escreve 4 em X
Interconnection Network
X E100
Directories
Memories
Take Away
X 6
X 5
Caches
CPU 0
CPU 1
CPU 2
CPU 0 escreve 4 em X
Interconnection Network
X E100
Directories
X 5
Memories
X 5
Caches
CPU 0
CPU 1
CPU 2
CPU 0 escreve 4 em X
Interconnection Network
X E100
Directories
X 5
Memories
Caches
CPU 0
CPU 1
CPU 2
CPU 0 escreve 4 em X
Interconnection Network
X E100
Directories
X 5
Memories
Caches
X 5
CPU 0
CPU 1
CPU 2
CPU 0 escreve 4 em X
Interconnection Network
X E100
Directories
X 5
Memories
Caches
X 4
CPU 0
CPU 1
CPU 2
Diretório
P
P
Cache
Cache
Interconnection Netw ork
Me mory
• •
•
pr ese nce bits
Dir ectory
dir ty bit
• k processadores: k bits
• Cada bloco de memória: k presence-bits, 1 dirty-bit
• Cada bloco na cache: 1 valid bit, e 1 dirty (owner) bit
Operação Básica de Diretório
P1
Directory Memory
$
CA
Pn
…
$
Directory
Memory Directory
••
•
CA
presence bitsdirty bit
Scalable Interconnection network
• N processadores: N bits
• Cada bloco de memória: N presence-bits, 1 dirty-bit
• Cada bloco na cache: 1 valid bit, e 1 dirty (owner) bit
Operação Básica de Diretório
• k processadores.
P
P
Cache
Cache
• Cada bloco de cache na memória:
k presence-bits, 1 dirty-bit
Int erconnection Netw ork
• •
Me mory
pr ese nce bits
•
Dir ect ory
• Cada bloco na cache:
1 valid bit, e 1 dirty (owner) bit
dir ty bit
• Falta na Leitura da memória pelo processador i:
• Se dirty-bit está OFF então
• leitura da memória;
• atualiza p[i] para ON;
• Se dirty-bit está ON então
•
•
•
•
acessa linha de cache do processador owner (na cache: shared);
atualiza memória;
faz dirty-bit igual a OFF;
faz p[i] igual a ON;
Operação Básica de Diretório
P
P
Cache
Cache
• k processadores.
• Cada bloco de cache na memória:
k presence-bits, 1 dirty-bit
Int erconnection Netw ork
• •
Me mory
pr ese nce bits
•
Dir ect ory
dir ty bit
• Cada bloco na cache:
1 valid bit, e 1 dirty (owner) bit
• Falta devido a Escrita na memória pelo processador i:
• Se dirty-bit igual a OFF então
•
•
•
•
fornece dado para i;
envia invalidations para todas as caches que tem cópia do bloco;
faz dirty-bit igual a ON;
faz p[i] igual a ON;
Protocolo de Diretório
• Estados dos blocos de memória : Três estados
– Shared: ≥ 1 processador tem dado, memória
atualizada
– Uncached: nenhum nó (processador e cache) tem o
endereço; não é válido em nenhuma cache.
– Exclusive: 1 processador (owner) tem o dado;
memória desatualizada.
• Princípios básicos:
– Escrita em dado non-exclusive
=> write miss
– Processador fica esperando até que todos invalidates
tenham sido enviados e confirmados
Protocolo de Diretório
• Não tem barramento para broadcast:
– Todas as mensagens devem ter o recebimento
confirmado
• Cada mensagem pode envolver até 3
processadores
– Local node onde a requisição origina
– Home node onde reside o endereço de memória
– Remote node tem uma cópia do bloco de cache em
estado exclusive ou shared
• Composição da mensagem:
– P = processor number, A = address
Estados dos Blocos de Cache
• Para cada bloco de cache em um sistema
baseado em diretório:
– Estados idênticos ao snoopy:
• Invalid
• Shared
• Exclusive
– Transições causadas por:
•
•
•
•
read misses
write misses
Invalidates
busca de dado (fetch)
Estados dos Blocos de Cache
• Controlador envia mensagens de read
miss e write miss para o diretório do
processador que tem o dado na memória
local
Estados da Cache (Write Back) CPU
• Estados da cache
para requisições
da CPU para cada
bloco de cache
• Blocos que não
estão na cache
não são válidos
CPU Read hit
Invalid
CPU Read
Shared
(read/only)
Send read miss msg
CPU Write
Send Write
Miss msg
Cache Block
State
CPU read hit
CPU write hit
Exclusive
(read/write)
CPU Write Miss
Write back cache block
Send write miss msg
Estados da Cache (Write Back)
Diretório
• Estados da
cache para
requisições do
Directory para
cada cache
block
Invalidate msg
Invalid
Shared
(read/only)
Fetch invalidate
for this block
Write Back
Block; (abort
memory access)
Exclusive
(read/write)
Read miss
for this block
Write Back
Block; (abort
memory access)
Estados da Cache (Write Back) CPU
Estados da cache para
requisições da CPU
para cada
cache block e
para requisições do
directiory para cada
cache block
CPU Read hit
Write miss
for this block
CPU Read
Send read miss
CPU Write
Send Write
Miss
Invalid
Write miss
for this block
Write Back
Block; (abort
memory access)
Cache Block
State
Exclusive
(read/write)
CPU read hit
CPU write hit
Shared
(read/only)
CPU Read miss
Send read miss
CPU Write
Send Write Miss
Write Back
Block; (abort
memory access)
CPU Write Miss
Write back cache block
Place write miss on bus
Estados do Diretório
Estados do Directory
requisição para cada
memory block
Estado Uncached se
estiver não tiver cópias
na cache
Uncached
Data Write Back:
Sharers = {}
(Write back block)
Write Miss:
Sharers = {P};
send Fetch/Invalidate
to remote cache;
send Data Value Reply
msg
Read miss:
Sharers = {P}
send Data Value
Reply
Write Miss:
Sharers = {P};
send Data
Value Reply
msg
Exclusive
(read/write)
Read miss:
Sharers += {P};
send Data Value Reply
Shared
(read only)
Write Miss:
send Invalidate
to Sharers;
then Sharers = {P};
send Data Value
Reply msg
Read miss:
Sharers += {P};
send Fetch to remote
cache;send Data Value
Reply msg
(Write back block)
Exemplo
P
P1
Cache
2
Cache
Interconnection
BusNetw ork
Me mory
• •
•
pr ese nce bits
Dir ectory
dir ty bit
• 2 processadores: 2 bits
• Cada bloco de memória: 2 presence-bits, 1 dirty-bit
• Cada bloco na cache: 1 valid bit, e 1 dirty (owner) bit
Exemplo
P
P1
Cache
2
Cache
Interconnection
BusNetw ork
Me mory
• •
pr ese nce bits
•
Dir ectory
dir ty bit
Estados Cache: Invalid, Shared, Exclusiv
Estados Diretório (memória): Uncached, Shared,
Exclusiv
Exemplo
P
P1
Cache
2
Cache
Interconnection
BusNetw ork
Me mory
• •
pr ese nce bits
•
Dir ectory
dir ty bit
Mensagens do controlador de cache (requisitante do
bloco) para o diretório:
• Read Miss
• Write Miss
Exemplo
P
P1
Cache
2
Cache
Interconnection
BusNetw ork
Me mory
• •
pr ese nce bits
•
Dir ectory
dir ty bit
Mensagens do diretório para os controladores de cache:
• Data reply
• Fetch/Invalidate
• Invalidate
• Fetch
Exemplo
P
P1
2
Cache
Cache
Interconnection
BusNetw ork
• •
Me mory
pr ese nce bits
•
Dir ectory
dir ty bit
Mensagens do controlador de cache (owner do bloco)
para o diretório:
• Data write back
P
P
1
Exemplo
2
Cache
Cache
Interconnection
BusNetw ork
• •
Me mory
pr ese nce bits
•
Dir ectory
dir ty bit
Processor 1 Processor 2 Interconnect
P1
step
P2
State Addr
Bus
Value State Addr Value Action Proc. Addr
Directory Memory
Directory
Value Addr
P1: Write 10 to A1
P1: Read A1
P2: Read A1
P2: Write 20 to A1
P2: Write 40 to A2
A1 and A2 map to the same cache block
State {Procs}
Memory
Value
P
P
1
Exemplo
2
Cache
Cache
Interconnection
BusNetw ork
• •
Me mory
pr ese nce bits
•
Dir ectory
dir ty bit
Processor 1 Processor 2 Interconnect
P1
step
P2
State Addr
A1
Directory
Value State Addr Value Action Proc. Addr
P1: Write 10 to A1
Excl.
Bus
10
Directory Memory
WrMs
P1
A1
DaRp
P1
A1
Value Addr
A1
0
P1: Read A1
P2: Read A1
P2: Write 20 to A1
P2: Write 40 to A2
A1 and A2 map to the same cache block
Memory
State {Procs}
Ex
{P1}
Value
P
P
1
Exemplo
2
Cache
Cache
Interconnection
BusNetw ork
• •
Me mory
pr ese nce bits
•
Dir ectory
dir ty bit
Processor 1 Processor 2 Interconnect
P1
step
P2
State Addr
Directory
Value State Addr Value Action Proc. Addr
P1: Write 10 to A1
P1: Read A1
Bus
Excl.
A1
10
Excl.
A1
10
Directory Memory
WrMs
P1
A1
DaRp
P1
A1
Value Addr
A1
0
P2: Read A1
P2: Write 20 to A1
P2: Write 40 to A2
A1 and A2 map to the same cache block
Memory
State {Procs}
Ex
{P1}
Value
P
P
1
Exemplo
2
Cache
Cache
Interconnection
BusNetw ork
• •
Me mory
•
pr ese nce bits
Dir ectory
dir ty bit
Processor 1 Processor 2 Interconnect
P1
step
P2
State Addr
Bus
P1: Read A1
Excl.
A1
10
Excl.
A1
10
P2: Read A1
Shar.
Shar.
A1
Directory
Value State Addr Value Action Proc. Addr
P1: Write 10 to A1
A1
10
Shar.
A1
10
Directory Memory
Value Addr
A1
Memory
State {Procs}
Ex
Value
WrMs
P1
A1
{P1}
DaRp
P1
A1
RdMs
P2
A1
Ftch
P1
A1
10
A1
A1
10
DaRp
P2
A1
10
A1 Shar. {P1,P2}
10
0
P2: Write 20 to A1
10
10
P2: Write 40 to A2
10
Write Back
A1 and A2 map to the same cache block
P
P
1
Exemplo
2
Cache
Cache
Interconnection
BusNetw ork
• •
Me mory
•
pr ese nce bits
Dir ectory
dir ty bit
Processor 1 Processor 2 Interconnect
P1
step
P2
State Addr
Bus
P1: Read A1
Excl.
A1
10
Excl.
A1
10
P2: Read A1
Shar.
Shar.
P2: Write 20 to A1
Inv.
A1
Directory
Value State Addr Value Action Proc. Addr
P1: Write 10 to A1
A1
10
Directory Memory
Value Addr
State {Procs}
P1
A1
DaRp
P1
A1
RdMs
P2
A1
Ftch
P1
A1
10
A1
A1
10
10
A1 Shar. {P1,P2}
10
A1
10
DaRp
P2
A1
Excl.
A1
20
WrMs
P2
A1
Inval.
P1
A1
Ex
Value
WrMs
Shar.
A1
Memory
{P1}
0
10
A1
P2: Write 40 to A2
Excl.
{P2}
10
10
A1 and A2 map to the same cache block
P
P
1
Exemplo
2
Cache
Cache
Interconnection
BusNetw ork
• •
Me mory
pr ese nce bits
•
Dir ectory
dir ty bit
Processor 1 Processor 2 Interconnect
P1
step
P2
State Addr
Bus
P1: Read A1
Excl.
A1
10
Excl.
A1
10
P2: Read A1
Shar.
Shar.
P2: Write 20 to A1
A1
Directory
Value State Addr Value Action Proc. Addr
P1: Write 10 to A1
A1
10
Directory Memory
Value Addr
A1
Memory
State {Procs}
Ex
Value
WrMs
P1
A1
{P1}
DaRp
P1
A1
RdMs
P2
A1
Ftch
P1
A1
10
A1
A1
10
10
A1 Shar. {P1,P2}
10
0
Shar.
A1
10
DaRp
P2
A1
Excl.
A1
20
WrMs
P2
A1
Inval.
P1
A1
A1
Excl.
{P2}
10
WrMs
P2
A2
A2
Excl.
{P2}
0
WrBk
P2
A1
20
A1
Unca.
{}
20
DaRp
P2
A2
0
A2
Excl.
{P2}
0
Inv.
P2: Write 40 to A2
Excl.
A2
40
10
A1 and A2 map to the same cache block
Desafios da Coerência baseada em
Diretórios
• Devemos assumir operações atômicas:
– Difícil implementação em redes
• Problema na sincronização de processos
– Necessidade de leitura e escrita em variável
compartilhada de forma indivisível
– operações atômicas
Sincronização
• Por que sincronizar? Necessidade de saber
quando é seguro para diferentes processos usar
um dado compartihado.
• Garantindo a Sincronização :
– Instrução que acessa variável compartilhada não
pode ser interrompida entre a leitura e escrita na
memória (operação atômica)
Problema da Sincronização
• Processos necessitam de receber
enviar dados de/para outros
processos
• Exemplo básico:
produtor/consumidor
– Processo A produz dados, Processo
B consome dados produzidos
– Ex: A decodifica pacotes de vídeo, B
mostra pacotes decodificados na
tela
Encoded
video packets
processA() {
// Decode packet
// Communicate
packet to B
}
}
Decoded
video packets
void processB() {
// Get packet from A
// Display packet
}
• Como a comunicação é feita?
– Memória Compartilhada
– Passagem de Mensagem
To display
Problema da Sincronização
•
Exemplo: Produtor/Consumidor com erro
– Compartilham buffer[N], count
– ProcessA produz dados e armazena no buffer
• Se buffer está cheio deve esperar
– processB consome dados do buffer
• Se buffer estiver vazio deve esperar
– Erro quando os processos tentam atualizar o
contador (linhas 10 e 19) e a seguinte sequencia
ocorre
– Considere que “count” é 3.
• A carrega count (count = 3) no registrador
R1 (R1 = 3)
• A incrementa R1 (R1 = 4)
• B carrega (count = 3) no registrador R2 (R2
= 3)
• B decrementa R2 (R2 = 2)
• A armazena R1 na memória na variável
(count = 4)
• B armazena R2 na memória na variável
count (count = 2)
– count tem um valor incorreto
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
data_type buffer[N];
int count = 0;
void processA() {
int i;
while( 1 ) {
produce(&data);
while( count == N );/*loop*/
buffer[i] = data;
i = (i + 1) % N;
count = count + 1;
}
}
void processB() {
int i;
while( 1 ) {
while( count == 0 );/*loop*/
data = buffer[i];
i = (i + 1) % N;
count = count - 1;
consume(&data);
}
}
void main() {
create_process(processA);
create_process(processB);
}
Memória Compartilhada: Exclusão Mútua
• Algumas partes do código que não
podem ser executadas de forma
concorrente
–Região Crítica
• Região do código onde as variáveis
compartilhadas são lidas ou escritas
Memória Compartilhada: Exclusão Mútua
• Quando um processo começa a executar código da
região crítica, todos os outros processos deveriam
esperar até que o processo termine a execução da
região crítica
– Mutex
• Um objeto compartilhado usado para bloquear ou
desbloquear a entrada na região crítica
• Desabilita o acesso de leitura/escrita no endereço que
ele guarda
• Vários processos podem tentar dar lock simultaneamente
mas apenas UM consegue sucesso
• Os demais processos ficam bloqueados até que a
operação de unlock seja realizada pelo processo na
região crítica
• Os processos competirão novamente para entrar na
região crítica
Solução para o Produtor/Consumidor
•
•
Uso da variável count_mutex do tipo mutex
Sequencia de execução
– A/B executam operação de lock em
count_mutex
– Ou A ou B terão sucesso
• Vamos considerar que B conseguiu o lock
• A é bloqueado
– B lê count (count = 3) no registrador R2 (R2 = 3)
– B decrementa R2 (R2 = 2)
– B escreve R2 back na memória (count = 2)
– B executa operação de unlock
• A volta para o estado de execução
– A carrega (count = 2) no registrador R1 (R1 = 2)
– A incrementa R1 (R1 = 3)
– A escreve count na memória (count = 3)
•
Count tem o valor correto: 3
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
data_type buffer[N];
int count = 0;
mutex count_mutex;
void processA() {
int i;
while( 1 ) {
produce(&data);
while( count == N );/*loop*/
buffer[i] = data;
i = (i + 1) % N;
count_mutex.lock();
count = count + 1;
count_mutex.unlock();
}
}
void processB() {
int i;
while( 1 ) {
while( count == 0 );/*loop*/
data = buffer[i];
i = (i + 1) % N;
count_mutex.lock();
count = count - 1;
count_mutex.unlock();
consume(&data);
}
}
void main() {
create_process(processA);
create_process(processB);
}
Como implementar variável lock?.
• Atomic exchange: troca os valores entre um
registrador e um endereço de memória.
– 0  variável de sincronização está livre
– 1  variável de sincronização está locked e não
disponível
Como
garantir
a operação
seja
• Seta
registrador
para que
1 & troca
valor do registrador
com
endereço dede
memória
executada
forma indivisível em
– Novo valor no registrador determina o sucesso em ter
acesso ao lock
DSMs com diretórios?
• 0 se teve sucesso (chegou primeiro)
• 1 se outro processo chegou primeiro
– O segredo é que a operação de exchange seja indivisível
Estratégia para leitura e atualização de memória
de forma atômica
• Dificuldade em ter leitura e escrita na
memória de forma indivisível por apenas 1
instrução
• Processadores possuem 2 instruções
• Load linked (or load locked) + store
conditional
– Load linked retorna o valor inicial
– Store conditional retorna 1 se foi sucesso
(nenhum outro store acessou o endereço
de memória desde o último load) e 0 caso
contrário.
Estratégia para leitura e atualização de memória
de forma atômica
• Load linked (or load locked) + store conditional
– Load linked retorna o valor inicial
– Store conditional retorna 1 se foi sucesso (nenhum outro store acessou
o endereço de memória desde o último load) e 0 caso contrário.
• Exemplo swap atômico com LL & SC:
try: mov R3,R4
; mov exchange value
ll
R2,0(R1)
; load linked
sc
R3,0(R1)
; store conditional
beqz R3,try
; branch store fails (R3 = 0)
mov R4,R2
; put load value in R4
Exemplo T1
• Oito cores: cada um
suporta até 4 threads.
• Cada core consiste num
pipeline de 6 estágios
• Tl usa fine-grained
multithreading,
• Os cores acessam 4
caches de 2 níveis
• Existe coerência entre
caches L1 e um diretório
com cada cache L2
• LI data cache é write
through,
Exemplo T1
Comparação T1 e Superescalares
Comparação T1 e Superescalares
Comparação T1 e Superescalares
Conclusões
• Protocolo de coerência para memória baseado em Snooping
• Problemas
• Protocolo de coerência baseado em diretórios
– Idéia Básica
– Como funciona
• Implementando protocolo baseado em diretórios
– Tipos de mensagens na rede
– Mudanças do estado do bloco de cache
– Mudanças de estado no diretório
• Problemas na Sincronização de processos
– Suporte para sincronização em uniprocessadores
– Problema em processadores DSM
– Solução para processadores DSM
• Exemplo Processador T1 da Sun
• Comparação monoprocessadores vs. multiprocessadores